diff options
Diffstat (limited to 'sys/netatm')
100 files changed, 61962 insertions, 0 deletions
diff --git a/sys/netatm/atm.h b/sys/netatm/atm.h new file mode 100644 index 0000000..46dfb86 --- /dev/null +++ b/sys/netatm/atm.h @@ -0,0 +1,651 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm.h,v 1.8 1998/07/30 22:30:43 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM address family definitions + * + */ + +#ifndef _NETATM_ATM_H +#define _NETATM_ATM_H + + +/* + * The definitions in this file are intended to conform to the + * specifications defined in: + * + * The Open Group, Networking Services (XNS) Issue 5 + * + * ATM Transport Protocol Information for Sockets + * + * which is Copyright (c) 1997, The Open Group. + * + * All extensions contained in this file to the base specification + * are denoted with a comment string of "XNS_EXT". + */ + +/* + * ATM socket protocols + */ +#define ATM_PROTO_AAL5 0x5301 /* AAL type 5 protocol */ +#define ATM_PROTO_SSCOP 0x5302 /* SSCOP protocol */ + + +/* + * ATM address defintions + */ +/* + * General format of an ATM address + */ +#define ATM_ADDR_LEN 20 /* Size of address field (XNS_EXT) */ + +struct t_atm_addr { + int8_t address_format; /* Address format (see below) */ + u_int8_t address_length; /* Length of address field */ + u_int8_t address[ATM_ADDR_LEN]; /* Address field */ +}; +typedef struct t_atm_addr Atm_addr; /* XNS_EXT */ + +/* + * ATM address formats + */ +#define T_ATM_ABSENT (-1) /* No address present */ +#define T_ATM_ENDSYS_ADDR 1 /* ATM Endsystem */ +#define T_ATM_NSAP_ADDR 1 /* NSAP */ +#define T_ATM_E164_ADDR 2 /* E.164 */ +#define T_ATM_SPANS_ADDR 3 /* FORE SPANS (XNS_EXT) */ +#define T_ATM_PVC_ADDR 4 /* PVC (VPI,VCI) (XNS_EXT) */ + +/* + * ATM Endsystem / NSAP address format + */ +struct atm_addr_nsap { /* XNS_EXT */ + u_char aan_afi; /* Authority and Format Identifier */ + /* (see below) */ + u_char aan_afspec[12]; /* AFI specific fields */ + u_char aan_esi[6]; /* End System Identifier */ + u_char aan_sel; /* Selector */ +}; +typedef struct atm_addr_nsap Atm_addr_nsap; + +/* + * AFI codes + */ +#define AFI_DCC 0x39 /* DCC ATM Format (XNS_EXT) */ +#define AFI_ICD 0x47 /* ICD ATM Format (XNS_EXT) */ +#define AFI_E164 0x45 /* E.164 ATM Format (XNS_EXT) */ + +/* + * E.164 address format + */ +struct atm_addr_e164 { /* XNS_EXT */ + u_char aae_addr[15]; /* E.164 address */ +}; +typedef struct atm_addr_e164 Atm_addr_e164; + +/* + * SPANS address format + */ +struct atm_addr_spans { /* XNS_EXT */ + u_char aas_addr[8]; /* See SPANS code for specific fields */ +}; +typedef struct atm_addr_spans Atm_addr_spans; + +/* + * PVC address format + */ +struct atm_addr_pvc { /* XNS_EXT */ + u_int8_t aap_vpi[2]; /* VPI */ + u_int8_t aap_vci[2]; /* VCI */ +}; +typedef struct atm_addr_pvc Atm_addr_pvc; + +#define ATM_PVC_GET_VPI(addr) /* XNS_EXT */ \ + ((u_int16_t)(((addr)->aap_vpi[0] << 8) | (addr)->aap_vpi[1])) +#define ATM_PVC_GET_VCI(addr) /* XNS_EXT */ \ + ((u_int16_t)(((addr)->aap_vci[0] << 8) | (addr)->aap_vci[1])) +#define ATM_PVC_SET_VPI(addr,vpi) { /* XNS_EXT */ \ + (addr)->aap_vpi[0] = ((vpi) >> 8) & 0xff; \ + (addr)->aap_vpi[1] = (vpi) & 0xff; \ +} +#define ATM_PVC_SET_VCI(addr,vci) { /* XNS_EXT */ \ + (addr)->aap_vci[0] = ((vci) >> 8) & 0xff; \ + (addr)->aap_vci[1] = (vci) & 0xff; \ +} + + +/* + * ATM service access point (SAP) + * + * A SAP address consists of SAP Vector Elements (SVE). Each SVE consists + * of the following fields: + * o tag - defines the interpretation of the SVE; + * o length - the length of the SVE value field; + * o value - the value associated with the SVE; + * + * All of the possible SAP field values are either defined below + * or in the corresponding option value definitions. + */ + +/* + * ATM Address and Selector SVE + */ +struct t_atm_sap_addr { + int8_t SVE_tag_addr; /* SVE tag (address) */ + int8_t SVE_tag_selector; /* SVE tag (selector) */ + /* Address/selector value */ + int8_t address_format; /* Address format */ + u_int8_t address_length; /* Length of address field */ + u_int8_t address[ATM_ADDR_LEN]; /* Address field */ +}; + +/* + * B-LLI Layer 2 SVE + */ +struct t_atm_sap_layer2 { + int8_t SVE_tag; /* SVE tag */ + u_int8_t ID_type; /* Layer 2 protocol discriminator */ + union { /* Layer 2 protocol */ + u_int8_t simple_ID; /* ITU */ + u_int8_t user_defined_ID;/* User-defined */ + } ID; +}; + +/* + * B-LLI Layer 3 SVE + */ +struct t_atm_sap_layer3 { + int8_t SVE_tag; /* SVE tag */ + u_int8_t ID_type; /* Layer 3 protocol discriminator */ + union { /* Layer 3 protocol */ + u_int8_t simple_ID; /* ITU */ + u_int8_t IPI_ID; /* ISO IPI */ + struct { /* IEEE 802.1 SNAP ID */ + u_int8_t OUI[3]; + u_int8_t PID[2]; + } SNAP_ID; + u_int8_t user_defined_ID;/* User-defined */ + } ID; +}; + +/* + * B_HLI SVE + */ +struct t_atm_sap_appl { + int8_t SVE_tag; /* SVE tag */ + u_int8_t ID_type; /* High Layer type discriminator */ + union { /* High Layer type */ + u_int8_t ISO_ID[8]; /* ISO */ + struct { /* Vendor-specific */ + u_int8_t OUI[3]; + u_int8_t app_ID[4]; + } vendor_ID; + u_int8_t user_defined_ID[8];/* User-defined */ + } ID; +}; + +/* + * ATM SAP (protocol) address structure + */ +struct t_atm_sap { + struct t_atm_sap_addr t_atm_sap_addr; + struct t_atm_sap_layer2 t_atm_sap_layer2; + struct t_atm_sap_layer3 t_atm_sap_layer3; + struct t_atm_sap_appl t_atm_sap_appl; +}; + +/* + * SVE Tag values + */ +#define T_ATM_ABSENT (-1) /* Value field invalid; match none */ +#define T_ATM_PRESENT (-2) /* Value field valid; match value */ +#define T_ATM_ANY (-3) /* Value field invalid; match any */ + + +/* + * ATM socket address + */ +struct sockaddr_atm { /* XNS_EXT */ +#if (defined(BSD) && (BSD >= 199103)) + u_char satm_len; /* Length of socket structure */ + u_char satm_family; /* Address family */ +#else + u_short satm_family; /* Address family */ +#endif + struct t_atm_sap satm_addr; /* Protocol address */ +}; + + +/* + * ATM socket options for use with [gs]etsockopt() + */ +#define T_ATM_SIGNALING 0x5301 /* Option level */ + +#define T_ATM_AAL5 1 /* ATM adaptation layer 5 */ +#define T_ATM_TRAFFIC 2 /* ATM traffic descriptor */ +#define T_ATM_BEARER_CAP 3 /* ATM service capabilities */ +#define T_ATM_BHLI 4 /* Higher-layer protocol */ +#define T_ATM_BLLI 5 /* Lower-layer protocol */ +#define T_ATM_DEST_ADDR 6 /* Call responder's address */ +#define T_ATM_DEST_SUB 7 /* Call responder's subaddress */ +#define T_ATM_ORIG_ADDR 8 /* Call initiator's address */ +#define T_ATM_ORIG_SUB 9 /* Call initiator's subaddress */ +#define T_ATM_CALLER_ID 10 /* Caller's ID attributes */ +#define T_ATM_CAUSE 11 /* Cause of disconection */ +#define T_ATM_QOS 12 /* Quality of service */ +#define T_ATM_TRANSIT 13 /* Choice of public carrier */ +#define T_ATM_ADD_LEAF 14 /* Add leaf to connection */ +#define T_ATM_DROP_LEAF 15 /* Remove leaf from connection */ +#define T_ATM_LEAF_IND 16 /* Indication of leaf status */ +#define T_ATM_NET_INTF 17 /* Network interface XNS_EXT */ +#define T_ATM_LLC 18 /* LLC multiplexing XNS_EXT */ +#define T_ATM_APP_NAME 19 /* Application name XNS_EXT */ + + +/* + * Common socket option values + * + * See API specification for individual option applicability/meaning + */ +#define T_ATM_ABSENT (-1) /* No option value present */ +#define T_ATM_NULL 0 /* Option value is null */ +#define T_NO 0 /* Option is not requested */ +#define T_YES 1 /* Option is requested */ + + +/* + * T_ATM_AAL5 option value structure + */ +struct t_atm_aal5 { + int32_t forward_max_SDU_size; + int32_t backward_max_SDU_size; + int32_t SSCS_type; +}; + +/* + * T_ATM_AAL5 option values + */ + /* SSCS_type */ +#define T_ATM_SSCS_SSCOP_REL 1 /* SSCOP assured operation */ +#define T_ATM_SSCS_SSCOP_UNREL 2 /* SSCOP non-assured operation */ +#define T_ATM_SSCS_FR 4 /* Frame relay */ + + +/* + * T_ATM_TRAFFIC option value structure + */ +struct t_atm_traffic_substruct { + int32_t PCR_high_priority; + int32_t PCR_all_traffic; + int32_t SCR_high_priority; + int32_t SCR_all_traffic; + int32_t MBS_high_priority; + int32_t MBS_all_traffic; + int32_t tagging; +}; + +struct t_atm_traffic { + struct t_atm_traffic_substruct forward; + struct t_atm_traffic_substruct backward; + u_int8_t best_effort; +}; + + +/* + * T_ATM_BEARER_CAP option value structure + */ +struct t_atm_bearer { + u_int8_t bearer_class; + u_int8_t traffic_type; + u_int8_t timing_requirements; + u_int8_t clipping_susceptibility; + u_int8_t connection_configuration; +}; + +/* + * T_ATM_BEARER_CAP option values + */ + /* bearer_class */ +#define T_ATM_CLASS_A 0x01 /* Bearer class A */ +#define T_ATM_CLASS_C 0x03 /* Bearer class C */ +#define T_ATM_CLASS_X 0x10 /* Bearer class X */ + + /* traffic_type */ +#define T_ATM_CBR 0x01 /* Constant bit rate */ +#define T_ATM_VBR 0x02 /* Variable bit rate */ + + /* timing_requirements */ +#define T_ATM_END_TO_END 0x01 /* End-to-end timing required */ +#define T_ATM_NO_END_TO_END 0x02 /* End-to-end timing not required */ + + /* connection_configuration */ +#define T_ATM_1_TO_1 0x00 /* Point-to-point connection */ +#define T_ATM_1_TO_MANY 0x01 /* Point-to-multipoint connection */ + + +/* + * T_ATM_BHLI option value structure + */ +struct t_atm_bhli { + int32_t ID_type; + union { + u_int8_t ISO_ID[8]; + struct { + u_int8_t OUI[3]; + u_int8_t app_ID[4]; + } vendor_ID; + u_int8_t user_defined_ID[8]; + } ID; +}; + +/* + * T_ATM_BHLI option values + */ + /* ID_type */ +#define T_ATM_ISO_APP_ID 0 /* ISO codepoint */ +#define T_ATM_USER_APP_ID 1 /* User-specific codepoint */ +#define T_ATM_VENDOR_APP_ID 3 /* Vendor-specific codepoint */ + +/* + * T_ATM_BLLI option value structure + */ +struct t_atm_blli { + struct { + int8_t ID_type; + union { + u_int8_t simple_ID; + u_int8_t user_defined_ID; + } ID; + int8_t mode; + int8_t window_size; + } layer_2_protocol; + struct { + int8_t ID_type; + union { + u_int8_t simple_ID; + int32_t IPI_ID; + struct { + u_int8_t OUI[3]; + u_int8_t PID[2]; + } SNAP_ID; + u_int8_t user_defined_ID; + } ID; + int8_t mode; + int8_t packet_size; + int8_t window_size; + } layer_3_protocol; +}; + + +/* + * T_ATM_BLLI option values + */ + /* layer_[23]_protocol.ID_type */ +#define T_ATM_SIMPLE_ID 1 /* ID via ITU encoding */ +#define T_ATM_IPI_ID 2 /* ID via ISO/IEC TR 9577 */ +#define T_ATM_SNAP_ID 3 /* ID via SNAP */ +#define T_ATM_USER_ID 4 /* ID via user codepoints */ + + /* layer_[23]_protocol.mode */ +#define T_ATM_BLLI_NORMAL_MODE 1 +#define T_ATM_BLLI_EXTENDED_MODE 2 + + /* layer_2_protocol.simple_ID */ +#define T_ATM_BLLI2_I1745 1 /* I.1745 */ +#define T_ATM_BLLI2_Q921 2 /* Q.921 */ +#define T_ATM_BLLI2_X25_LINK 6 /* X.25, link layer */ +#define T_ATM_BLLI2_X25_MLINK 7 /* X.25, multilink */ +#define T_ATM_BLLI2_LAPB 8 /* Extended LAPB */ +#define T_ATM_BLLI2_HDLC_ARM 9 /* I.4335, ARM */ +#define T_ATM_BLLI2_HDLC_NRM 10 /* I.4335, NRM */ +#define T_ATM_BLLI2_HDLC_ABM 11 /* I.4335, ABM */ +#define T_ATM_BLLI2_I8802 12 /* I.8802 */ +#define T_ATM_BLLI2_X75 13 /* X.75 */ +#define T_ATM_BLLI2_Q922 14 /* Q.922 */ +#define T_ATM_BLLI2_I7776 17 /* I.7776 */ + + /* layer_3_protocol.simple_ID */ +#define T_ATM_BLLI3_X25 6 /* X.25 */ +#define T_ATM_BLLI3_I8208 7 /* I.8208 */ +#define T_ATM_BLLI3_X223 8 /* X.223 */ +#define T_ATM_BLLI3_I8473 9 /* I.8473 */ +#define T_ATM_BLLI3_T70 10 /* T.70 */ +#define T_ATM_BLLI3_I9577 11 /* I.9577 */ + + /* layer_3_protocol.packet_size */ +#define T_ATM_PACKET_SIZE_16 4 +#define T_ATM_PACKET_SIZE_32 5 +#define T_ATM_PACKET_SIZE_64 6 +#define T_ATM_PACKET_SIZE_128 7 +#define T_ATM_PACKET_SIZE_256 8 +#define T_ATM_PACKET_SIZE_512 9 +#define T_ATM_PACKET_SIZE_1024 10 +#define T_ATM_PACKET_SIZE_2048 11 +#define T_ATM_PACKET_SIZE_4096 12 + + +/* + * T_ATM_CALLER_ID option value structure + */ +struct t_atm_caller_id { + int8_t presentation; + u_int8_t screening; +}; + +/* + * T_ATM_CALLER_ID option values + */ + /* presentation */ +#define T_ATM_PRES_ALLOWED 0 +#define T_ATM_PRES_RESTRICTED 1 +#define T_ATM_PRES_UNAVAILABLE 2 + /* screening */ +#define T_ATM_USER_ID_NOT_SCREENED 0 +#define T_ATM_USER_ID_PASSED_SCREEN 1 +#define T_ATM_USER_ID_FAILED_SCREEN 2 +#define T_ATM_NETWORK_PROVIDED_ID 3 + + +/* + * T_ATM_CAUSE option value structure + */ +struct t_atm_cause { + int8_t coding_standard; + u_int8_t location; + u_int8_t cause_value; + u_int8_t diagnostics[4]; +}; + +/* + * T_ATM_CAUSE option values + */ + /* coding_standard */ +#define T_ATM_ITU_CODING 0 +#define T_ATM_NETWORK_CODING 3 + + /* location */ +#define T_ATM_LOC_USER 0 +#define T_ATM_LOC_LOCAL_PRIVATE_NET 1 +#define T_ATM_LOC_LOCAL_PUBLIC_NET 2 +#define T_ATM_LOC_TRANSIT_NET 3 +#define T_ATM_LOC_REMOTE_PUBLIC_NET 4 +#define T_ATM_LOC_REMOTE_PRIVATE_NET 5 +#define T_ATM_LOC_INTERNATIONAL_NET 7 +#define T_ATM_LOC_BEYOND_INTERWORKING 10 + + /* cause_value */ +#define T_ATM_CAUSE_UNALLOCATED_NUMBER 1 +#define T_ATM_CAUSE_NO_ROUTE_TO_TRANSIT_NETWORK 2 +#define T_ATM_CAUSE_NO_ROUTE_TO_DESTINATION 3 +#define T_ATM_CAUSE_NORMAL_CALL_CLEARING 16 +#define T_ATM_CAUSE_USER_BUSY 17 +#define T_ATM_CAUSE_NO_USER_RESPONDING 18 +#define T_ATM_CAUSE_CALL_REJECTED 21 +#define T_ATM_CAUSE_NUMBER_CHANGED 22 +#define T_ATM_CAUSE_ALL_CALLS_WITHOUT_CALLER_ID_REJECTED 23 +#define T_ATM_CAUSE_DESTINATION_OUT_OF_ORDER 27 +#define T_ATM_CAUSE_INVALID_NUMBER_FORMAT 28 +#define T_ATM_CAUSE_RESPONSE_TO_STATUS_ENQUIRY 30 +#define T_ATM_CAUSE_UNSPECIFIED_NORMAL 31 +#define T_ATM_CAUSE_REQUESTED_VPCI_VCI_NOT_AVAILABLE 35 +#define T_ATM_CAUSE_VPCI_VCI_ASSIGNMENT_FAILURE 36 +#define T_ATM_CAUSE_USER_CELL_RATE_NOT_AVAILABLE 37 +#define T_ATM_CAUSE_NETWORK_OUT_OF_ORDER 38 +#define T_ATM_CAUSE_TEMPORARY_FAILURE 41 +#define T_ATM_CAUSE_ACCESS_INFO_DISCARDED 43 +#define T_ATM_CAUSE_NO_VPCI_VCI_AVAILABLE 45 +#define T_ATM_CAUSE_UNSPECIFIED_RESOURCE_UNAVAILABLE 47 +#define T_ATM_CAUSE_QUALITY_OF_SERVICE_UNAVAILABLE 49 +#define T_ATM_CAUSE_BEARER_CAPABILITY_NOT_AUTHORIZED 57 +#define T_ATM_CAUSE_BEARER_CAPABILITY_UNAVAILABLE 58 +#define T_ATM_CAUSE_SERVICE_OR_OPTION_UNAVAILABLE 63 +#define T_ATM_CAUSE_BEARER_CAPABILITY_NOT_IMPLEMENTED 65 +#define T_ATM_CAUSE_INVALID_TRAFFIC_PARAMETERS 73 +#define T_ATM_CAUSE_AAL_PARAMETERS_NOT_SUPPORTED 78 +#define T_ATM_CAUSE_INVALID_CALL_REFERENCE_VALUE 81 +#define T_ATM_CAUSE_IDENTIFIED_CHANNEL_DOES_NOT_EXIST 82 +#define T_ATM_CAUSE_INCOMPATIBLE_DESTINATION 88 +#define T_ATM_CAUSE_INVALID_ENDPOINT_REFERENCE 89 +#define T_ATM_CAUSE_INVALID_TRANSIT_NETWORK_SELECTION 91 +#define T_ATM_CAUSE_TOO_MANY_PENDING_ADD_PARTY_REQUESTS 92 +#define T_ATM_CAUSE_MANDITORY_INFO_ELEMENT_MISSING 96 +#define T_ATM_CAUSE_MESSAGE_TYPE_NOT_IMPLEMENTED 97 +#define T_ATM_CAUSE_INFO_ELEMENT_NOT_IMPLEMENTED 99 +#define T_ATM_CAUSE_INVALID_INFO_ELEMENT_CONTENTS 100 +#define T_ATM_CAUSE_MESSAGE_INCOMPATIBLE_WITH_CALL_STATE 101 +#define T_ATM_CAUSE_RECOVERY_ON_TIMER_EXPIRY 102 +#define T_ATM_CAUSE_INCORRECT_MESSAGE_LENGTH 104 +#define T_ATM_CAUSE_UNSPECIFIED_PROTOCOL_ERROR 111 + + +/* + * T_ATM_QOS option value structure + */ +struct t_atm_qos_substruct { + int32_t qos_class; +}; + +struct t_atm_qos { + int8_t coding_standard; + struct t_atm_qos_substruct forward; + struct t_atm_qos_substruct backward; +}; + +/* + * T_ATM_QOS option values + */ + /* qos_class */ +#define T_ATM_QOS_CLASS_0 0 +#define T_ATM_QOS_CLASS_1 1 +#define T_ATM_QOS_CLASS_2 2 +#define T_ATM_QOS_CLASS_3 3 +#define T_ATM_QOS_CLASS_4 4 + + +/* + * T_ATM_TRANSIT structure + */ +#define T_ATM_MAX_NET_ID 4 /* XNS_EXT */ +struct t_atm_transit { + u_int8_t length; + u_int8_t network_id[T_ATM_MAX_NET_ID]; +}; + + +/* + * T_ATM_ADD_LEAF option value structure + */ +struct t_atm_add_leaf { + int32_t leaf_ID; + struct t_atm_addr leaf_address; +}; + + +/* + * T_ATM_DROP_LEAF option value structure + */ +struct t_atm_drop_leaf { + int32_t leaf_ID; + int32_t reason; +}; + +/* + * T_ATM_LEAF_IND option value structure + */ +struct t_atm_leaf_ind { + int32_t status; + int32_t leaf_ID; + int32_t reason; +}; + +/* + * T_ATM_LEAF_IND option values + */ + /* status */ +#define T_LEAF_NOCHANGE 0 +#define T_LEAF_CONNECTED 1 +#define T_LEAF_DISCONNECTED 2 + +/* + * T_ATM_NET_INTF option value structure (XNS_EXT) + */ +struct t_atm_net_intf { /* XNS_EXT */ + char net_intf[IFNAMSIZ]; +}; + +/* + * T_ATM_LLC option value structure (XNS_EXT) + */ +#define T_ATM_LLC_MIN_LEN 3 +#define T_ATM_LLC_MAX_LEN 8 + +struct t_atm_llc { /* XNS_EXT */ + u_int8_t flags; /* LLC flags (see below) */ + u_int8_t llc_len; /* Length of LLC information */ + u_int8_t llc_info[T_ATM_LLC_MAX_LEN]; /* LLC information */ +}; + +/* + * T_ATM_LLC option values + */ + /* flags */ +#define T_ATM_LLC_SHARING 0x01 /* LLC sharing allowed */ + +/* + * T_ATM_APP_NAME option value structure (XNS_EXT) + */ +#define T_ATM_APP_NAME_LEN 8 +struct t_atm_app_name { /* XNS_EXT */ + char app_name[T_ATM_APP_NAME_LEN]; +}; + +#endif /* _NETATM_ATM_H */ diff --git a/sys/netatm/atm_aal5.c b/sys/netatm/atm_aal5.c new file mode 100644 index 0000000..c0e8fe4 --- /dev/null +++ b/sys/netatm/atm_aal5.c @@ -0,0 +1,905 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_aal5.c,v 1.4 1998/07/30 22:30:46 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM AAL5 socket protocol processing + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: atm_aal5.c,v 1.4 1998/07/30 22:30:46 mks Exp $"; +#endif + +#include <netatm/kern_include.h> +#include <sys/stat.h> + + +/* + * Global variables + */ +u_long atm_aal5_sendspace = 64 * 1024; /* XXX */ +u_long atm_aal5_recvspace = 64 * 1024; /* XXX */ + + +/* + * Local functions + */ +static int atm_aal5_attach __P((struct socket *, int, struct proc *)); +static int atm_aal5_detach __P((struct socket *)); +static int atm_aal5_bind __P((struct socket *, struct sockaddr *, + struct proc *)); +static int atm_aal5_listen __P((struct socket *, struct proc *)); +static int atm_aal5_connect __P((struct socket *, struct sockaddr *, + struct proc *)); +static int atm_aal5_accept __P((struct socket *, struct sockaddr **)); +static int atm_aal5_disconnect __P((struct socket *)); +static int atm_aal5_shutdown __P((struct socket *)); +static int atm_aal5_send __P((struct socket *, int, KBuffer *, + struct sockaddr *, KBuffer *, struct proc *)); +static int atm_aal5_abort __P((struct socket *)); +static int atm_aal5_control __P((struct socket *, u_long, caddr_t, + struct ifnet *, struct proc *)); +static int atm_aal5_sense __P((struct socket *, struct stat *)); +static int atm_aal5_sockaddr __P((struct socket *, struct sockaddr **)); +static int atm_aal5_peeraddr __P((struct socket *, struct sockaddr **)); +static int atm_aal5_incoming __P((void *, Atm_connection *, + Atm_attributes *, void **)); +static void atm_aal5_cpcs_data __P((void *, KBuffer *)); +static caddr_t atm_aal5_getname __P((void *)); + + +#if (defined(__FreeBSD__) && (BSD >= 199506)) +/* + * New-style socket request routines + */ +struct pr_usrreqs atm_aal5_usrreqs = { + atm_aal5_abort, /* pru_abort */ + atm_aal5_accept, /* pru_accept */ + atm_aal5_attach, /* pru_attach */ + atm_aal5_bind, /* pru_bind */ + atm_aal5_connect, /* pru_connect */ + pru_connect2_notsupp, /* pru_connect2 */ + atm_aal5_control, /* pru_control */ + atm_aal5_detach, /* pru_detach */ + atm_aal5_disconnect, /* pru_disconnect */ + atm_aal5_listen, /* pru_listen */ + atm_aal5_peeraddr, /* pru_peeraddr */ + pru_rcvd_notsupp, /* pru_rcvd */ + pru_rcvoob_notsupp, /* pru_rcvoob */ + atm_aal5_send, /* pru_send */ + atm_aal5_sense, /* pru_sense */ + atm_aal5_shutdown, /* pru_shutdown */ + atm_aal5_sockaddr, /* pru_sockaddr */ + sosend, /* pru_sosend */ + soreceive, /* pru_soreceive */ + sopoll /* pru_sopoll */ +}; +#endif + + +/* + * Local variables + */ +static Atm_endpoint atm_aal5_endpt = { + NULL, + ENDPT_SOCK_AAL5, + NULL, + atm_aal5_getname, + atm_sock_connected, + atm_sock_cleared, + atm_aal5_incoming, + NULL, + NULL, + NULL, + atm_aal5_cpcs_data, + NULL, + NULL, + NULL, + NULL +}; + +static Atm_attributes atm_aal5_defattr = { + NULL, /* nif */ + CMAPI_CPCS, /* api */ + 0, /* api_init */ + 0, /* headin */ + 0, /* headout */ + { /* aal */ + T_ATM_PRESENT, + ATM_AAL5 + }, + { /* traffic */ + T_ATM_ABSENT, + }, + { /* bearer */ + T_ATM_ABSENT, + }, + { /* bhli */ + T_ATM_ABSENT + }, + { /* blli */ + T_ATM_ABSENT, + T_ATM_ABSENT, + }, + { /* llc */ + T_ATM_ABSENT, + }, + { /* called */ + T_ATM_ABSENT, + { + T_ATM_ABSENT, + 0 + }, + { + T_ATM_ABSENT, + 0 + } + }, + { /* calling */ + T_ATM_ABSENT + }, + { /* qos */ + T_ATM_ABSENT, + }, + { /* transit */ + T_ATM_ABSENT + }, + { /* cause */ + T_ATM_ABSENT + } +}; + + +/* + * Handy common code macros + */ +#ifdef DIAGNOSTIC +#define ATM_INTRO(f) \ + int s, err = 0; \ + s = splnet(); \ + ATM_DEBUG2("aal5 socket %s (0x%x)\n", f, (int)so); \ + /* \ + * Stack queue should have been drained \ + */ \ + if (atm_stackq_head != NULL) \ + panic("atm_aal5: stack queue not empty"); \ + ; +#else +#define ATM_INTRO(f) \ + int s, err = 0; \ + s = splnet(); \ + ; +#endif + +#define ATM_OUTRO() \ +out: \ + /* \ + * Drain any deferred calls \ + */ \ + STACK_DRAIN(); \ + (void) splx(s); \ + return (err); \ + ; + +#define ATM_RETERR(errno) { \ + err = errno; \ + goto out; \ +} + + +/* + * Attach protocol to socket + * + * Arguments: + * so pointer to socket + * proto protocol identifier + * p pointer to process + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_aal5_attach(so, proto, p) + struct socket *so; + int proto; + struct proc *p; +{ + Atm_pcb *atp; + + ATM_INTRO("attach"); + + /* + * Do general attach stuff + */ + err = atm_sock_attach(so, atm_aal5_sendspace, atm_aal5_recvspace); + if (err) + goto out; + + /* + * Finish up any protocol specific stuff + */ + atp = sotoatmpcb(so); + atp->atp_type = ATPT_AAL5; + + /* + * Set default connection attributes + */ + atp->atp_attr = atm_aal5_defattr; + strncpy(atp->atp_name, "(AAL5)", T_ATM_APP_NAME_LEN); + + ATM_OUTRO(); +} + + +/* + * Detach protocol from socket + * + * Arguments: + * so pointer to socket + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_aal5_detach(so) + struct socket *so; +{ + ATM_INTRO("detach"); + + err = atm_sock_detach(so); + + ATM_OUTRO(); +} + + +/* + * Bind address to socket + * + * Arguments: + * so pointer to socket + * addr pointer to protocol address + * p pointer to process + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_aal5_bind(so, addr, p) + struct socket *so; + struct sockaddr *addr; + struct proc *p; +{ + ATM_INTRO("bind"); + + err = atm_sock_bind(so, addr); + + ATM_OUTRO(); +} + + +/* + * Listen for incoming connections + * + * Arguments: + * so pointer to socket + * p pointer to process + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_aal5_listen(so, p) + struct socket *so; + struct proc *p; +{ + ATM_INTRO("listen"); + + err = atm_sock_listen(so, &atm_aal5_endpt); + + ATM_OUTRO(); +} + + +/* + * Connect socket to peer + * + * Arguments: + * so pointer to socket + * addr pointer to protocol address + * p pointer to process + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_aal5_connect(so, addr, p) + struct socket *so; + struct sockaddr *addr; + struct proc *p; +{ + Atm_pcb *atp; + + ATM_INTRO("connect"); + + atp = sotoatmpcb(so); + + /* + * Resize send socket buffer to maximum sdu size + */ + if (atp->atp_attr.aal.tag == T_ATM_PRESENT) { + long size; + + size = atp->atp_attr.aal.v.aal5.forward_max_SDU_size; + if (size != T_ATM_ABSENT) + (void) sbreserve(&so->so_snd, size); + } + + /* + * Now get the socket connected + */ + err = atm_sock_connect(so, addr, &atm_aal5_endpt); + + ATM_OUTRO(); +} + + +/* + * Accept pending connection + * + * Arguments: + * so pointer to socket + * addr pointer to pointer to contain protocol address + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_aal5_accept(so, addr) + struct socket *so; + struct sockaddr **addr; +{ + ATM_INTRO("accept"); + + /* + * Everything is pretty much done already, we just need to + * return the caller's address to the user. + */ + err = atm_sock_peeraddr(so, addr); + + ATM_OUTRO(); +} + + +/* + * Disconnect connected socket + * + * Arguments: + * so pointer to socket + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_aal5_disconnect(so) + struct socket *so; +{ + ATM_INTRO("disconnect"); + + err = atm_sock_disconnect(so); + + ATM_OUTRO(); +} + + +/* + * Shut down socket data transmission + * + * Arguments: + * so pointer to socket + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_aal5_shutdown(so) + struct socket *so; +{ + ATM_INTRO("shutdown"); + + socantsendmore(so); + + ATM_OUTRO(); +} + + +/* + * Send user data + * + * Arguments: + * so pointer to socket + * flags send data flags + * m pointer to buffer containing user data + * addr pointer to protocol address + * control pointer to buffer containing protocol control data + * p pointer to process + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_aal5_send(so, flags, m, addr, control, p) + struct socket *so; + int flags; + KBuffer *m; + struct sockaddr *addr; + KBuffer *control; + struct proc *p; +{ + Atm_pcb *atp; + + ATM_INTRO("send"); + + /* + * We don't support any control functions + */ + if (control) { + int clen; + + clen = KB_LEN(control); + KB_FREEALL(control); + if (clen) { + KB_FREEALL(m); + ATM_RETERR(EINVAL); + } + } + + /* + * We also don't support any flags or send-level addressing + */ + if (flags || addr) { + KB_FREEALL(m); + ATM_RETERR(EINVAL); + } + + /* + * All we've got left is the data, so push it out + */ + atp = sotoatmpcb(so); + err = atm_cm_cpcs_data(atp->atp_conn, m); + if (err) { + /* + * Output problem, drop packet + */ + atm_sock_stat.as_outdrop[atp->atp_type]++; + KB_FREEALL(m); + } + + ATM_OUTRO(); +} + + +/* + * Abnormally terminate service + * + * Arguments: + * so pointer to socket + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_aal5_abort(so) + struct socket *so; +{ + ATM_INTRO("abort"); + + so->so_error = ECONNABORTED; + err = atm_sock_detach(so); + + ATM_OUTRO(); +} + + +/* + * Do control operation - ioctl system call + * + * Arguments: + * so pointer to socket + * cmd ioctl code + * data pointer to code specific parameter data area + * ifp pointer to ifnet structure if it's an interface ioctl + * p pointer to process + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_aal5_control(so, cmd, data, ifp, p) + struct socket *so; + u_long cmd; + caddr_t data; + struct ifnet *ifp; + struct proc *p; +{ + ATM_INTRO("control"); + + switch (cmd) { + + default: + err = EOPNOTSUPP; + } + + ATM_OUTRO(); +} + +/* + * Sense socket status - fstat system call + * + * Arguments: + * so pointer to socket + * st pointer to file status structure + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_aal5_sense(so, st) + struct socket *so; + struct stat *st; +{ + ATM_INTRO("sense"); + + /* + * Just return the max sdu size for the connection + */ + st->st_blksize = so->so_snd.sb_hiwat; + + ATM_OUTRO(); +} + + +/* + * Retrieve local socket address + * + * Arguments: + * so pointer to socket + * addr pointer to pointer to contain protocol address + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_aal5_sockaddr(so, addr) + struct socket *so; + struct sockaddr **addr; +{ + ATM_INTRO("sockaddr"); + + err = atm_sock_sockaddr(so, addr); + + ATM_OUTRO(); +} + + +/* + * Retrieve peer socket address + * + * Arguments: + * so pointer to socket + * addr pointer to pointer to contain protocol address + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_aal5_peeraddr(so, addr) + struct socket *so; + struct sockaddr **addr; +{ + ATM_INTRO("peeraddr"); + + err = atm_sock_peeraddr(so, addr); + + ATM_OUTRO(); +} + + +/* + * Process Incoming Calls + * + * This function will receive control when an incoming call has been matched + * to one of our registered listen parameter blocks. Assuming the call passes + * acceptance criteria and all required resources are available, we will + * create a new protocol control block and socket association. We must + * then await notification of the final SVC setup results. If any + * problems are encountered, we will just tell the connection manager to + * reject the call. + * + * Called at splnet. + * + * Arguments: + * tok owner's matched listening token + * cop pointer to incoming call's connection block + * ap pointer to incoming call's attributes + * tokp pointer to location to store our connection token + * + * Returns: + * 0 call is accepted + * errno call rejected - reason indicated + * + */ +static int +atm_aal5_incoming(tok, cop, ap, tokp) + void *tok; + Atm_connection *cop; + Atm_attributes *ap; + void **tokp; +{ + Atm_pcb *atp = tok; + struct socket *so; + int err = 0; + + /* + * Allocate a new socket and pcb for this connection. + * + * Note that our attach function will be called via sonewconn + * and it will allocate and setup most of the pcb. + */ + atm_sock_stat.as_inconn[atp->atp_type]++; +#if (defined(BSD) && (BSD >= 199103)) + so = sonewconn(atp->atp_socket, 0); +#else + so = sonewconn(atp->atp_socket); +#endif + + if (so) { + /* + * Finish pcb setup and pass pcb back to CM + */ + atp = sotoatmpcb(so); + atp->atp_conn = cop; + *tokp = atp; + } else { + err = ECONNABORTED; + atm_sock_stat.as_connfail[atp->atp_type]++; + } + + return (err); +} + + +/* + * Process Socket VCC Input Data + * + * Arguments: + * tok owner's connection token (atm_pcb) + * m pointer to input packet buffer chain + * + * Returns: + * none + * + */ +static void +atm_aal5_cpcs_data(tok, m) + void *tok; + KBuffer *m; +{ + Atm_pcb *atp = tok; + struct socket *so; + int len; + + so = atp->atp_socket; + + KB_PLENGET(m, len); + + /* + * Ensure that the socket is able to receive data and + * that there's room in the socket buffer + */ + if (((so->so_state & SS_ISCONNECTED) == 0) || + (so->so_state & SS_CANTRCVMORE) || + (len > sbspace(&so->so_rcv))) { + atm_sock_stat.as_indrop[atp->atp_type]++; + KB_FREEALL(m); + return; + } + + /* + * Queue the data and notify the user + */ + sbappendrecord(&so->so_rcv, m); + sorwakeup(so); + + return; +} + + +/* + * Process getsockopt/setsockopt system calls + * + * Arguments: + * so pointer to socket + * sopt pointer to socket option info + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +int +atm_aal5_ctloutput(so, sopt) + struct socket *so; + struct sockopt *sopt; +{ + Atm_pcb *atp; + + ATM_INTRO("ctloutput"); + + /* + * Make sure this is for us + */ + if (sopt->sopt_level != T_ATM_SIGNALING) { + ATM_RETERR(EINVAL); + } + atp = sotoatmpcb(so); + if (atp == NULL) { + ATM_RETERR(ENOTCONN); + } + + switch (sopt->sopt_dir) { + + case SOPT_SET: + /* + * setsockopt() + */ + + /* + * Validate socket state + */ + switch (sopt->sopt_name) { + + case T_ATM_ADD_LEAF: + case T_ATM_DROP_LEAF: + if ((so->so_state & SS_ISCONNECTED) == 0) { + ATM_RETERR(ENOTCONN); + } + break; + + case T_ATM_CAUSE: + break; + + default: + if (so->so_state & SS_ISCONNECTED) { + ATM_RETERR(EISCONN); + } + break; + } + + /* + * Validate and save user-supplied option data + */ + err = atm_sock_setopt(so, sopt, atp); + + break; + + case SOPT_GET: + /* + * getsockopt() + */ + + /* + * Return option data + */ + err = atm_sock_getopt(so, sopt, atp); + + break; + } + + ATM_OUTRO(); +} + + +/* + * Initialize AAL5 Sockets + * + * Arguments: + * none + * + * Returns: + * none + * + */ +void +atm_aal5_init() +{ + /* + * Register our endpoint + */ + if (atm_endpoint_register(&atm_aal5_endpt)) + panic("atm_aal5_init: register"); + + /* + * Set default connection attributes + */ + atm_aal5_defattr.aal.v.aal5.forward_max_SDU_size = T_ATM_ABSENT; + atm_aal5_defattr.aal.v.aal5.backward_max_SDU_size = T_ATM_ABSENT; + atm_aal5_defattr.aal.v.aal5.SSCS_type = T_ATM_NULL; +} + + +/* + * Get Connection's Application/Owner Name + * + * Arguments: + * tok owner's connection token (atm_pcb) + * + * Returns: + * addr pointer to string containing our name + * + */ +static caddr_t +atm_aal5_getname(tok) + void *tok; +{ + Atm_pcb *atp = tok; + + return (atp->atp_name); +} + diff --git a/sys/netatm/atm_cm.c b/sys/netatm/atm_cm.c new file mode 100644 index 0000000..55612e3 --- /dev/null +++ b/sys/netatm/atm_cm.c @@ -0,0 +1,3464 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_cm.c,v 1.8 1998/08/06 18:10:42 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM Connection Manager + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: atm_cm.c,v 1.8 1998/08/06 18:10:42 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + + +/* + * Global variables + */ +struct atm_cm_stat atm_cm_stat = {0}; + +/* + * Local functions + */ +static void atm_cm_cpcs_upper __P((int, void *, int, int)); +static void atm_cm_saal_upper __P((int, void *, int, int)); +static void atm_cm_sscop_upper __P((int, void *, int, int)); +static Atm_connvc * atm_cm_share_llc __P((Atm_attributes *)); +static void atm_cm_closeconn __P((Atm_connection *, + struct t_atm_cause *)); +static void atm_cm_closevc __P((Atm_connvc *)); +static void atm_cm_timeout __P((struct atm_time *)); +static KTimeout_ret atm_cm_procinq __P((void *)); +static void atm_cm_incall __P((Atm_connvc *)); +static int atm_cm_accept __P((Atm_connvc *, Atm_connection *)); + +/* + * Local variables + */ +static Queue_t atm_connection_queue = {NULL}; +static Queue_t atm_incoming_queue = {NULL}; +static int atm_incoming_qlen = 0; +static Atm_connection *atm_listen_queue = NULL; +static struct attr_cause atm_cause_tmpl = + {T_ATM_PRESENT, {T_ATM_ITU_CODING, T_ATM_LOC_USER, 0, {0, 0, 0, 0}}}; + +/* + * Stack commands, indexed by API + */ +static struct { + int init; + int term; +} atm_stackcmds[] = { + {CPCS_INIT, CPCS_TERM}, /* CMAPI_CPCS */ + {SSCF_UNI_INIT, SSCF_UNI_TERM}, /* CMAPI_SAAL */ + {SSCOP_INIT, SSCOP_TERM}, /* CMAPI_SSCOP */ +}; + + +static struct sp_info atm_connection_pool = { + "atm connection pool", /* si_name */ + sizeof(Atm_connection), /* si_blksiz */ + 10, /* si_blkcnt */ + 100 /* si_maxallow */ +}; +static struct sp_info atm_connvc_pool = { + "atm connection vcc pool", /* si_name */ + sizeof(Atm_connvc), /* si_blksiz */ + 10, /* si_blkcnt */ + 100 /* si_maxallow */ +}; + + +/* + * Initiate Outgoing ATM Call + * + * Called by an endpoint service to create a new Connection Manager API + * instance and to initiate an outbound ATM connection. The endpoint + * provided token will be used in all further CM -> endpoint function + * calls, and the returned connection block pointer must be used in all + * subsequent endpoint -> CM function calls. + * + * If the return indicates that the connection setup has been immediately + * successful (typically only for PVCs and shared SVCs), then the connection + * is ready for data transmission. + * + * If the return indicates that the connection setup is still in progress, + * then the endpoint must wait for notification from the Connection Manager + * indicating the final status of the call setup. If the call setup completes + * successfully, then a "call connected" notification will be sent to the + * endpoint by the Connection Manager. If the call setup fails, then the + * endpoint will receive a "call cleared" notification. + * + * All connection instances must be freed with an atm_cm_release() call. + * + * Arguments: + * epp pointer to endpoint definition structure + * token endpoint's connection instance token + * ap pointer to requested connection attributes + * copp pointer to location to return allocated connection block + * + * Returns: + * 0 connection has been successfully established + * EINPROGRESS connection establishment is in progress + * errno connection failed - reason indicated + * + */ +int +atm_cm_connect(epp, token, ap, copp) + Atm_endpoint *epp; + void *token; + Atm_attributes *ap; + Atm_connection **copp; +{ + Atm_connection *cop; + Atm_connvc *cvp; + struct atm_pif *pip; + struct sigmgr *smp; + struct stack_list sl; + void (*upf)__P((int, void *, int, int)); + int s, sli, err, err2; + + *copp = NULL; + cvp = NULL; + + /* + * Get a connection block + */ + cop = (Atm_connection *)atm_allocate(&atm_connection_pool); + if (cop == NULL) + return (ENOMEM); + + /* + * Initialize connection info + */ + cop->co_endpt = epp; + cop->co_toku = token; + + /* + * Initialize stack list index + */ + sli = 0; + + /* + * Validate and extract useful attribute information + */ + + /* + * Must specify a network interface (validated below) + */ + if (ap->nif == NULL) { + err = EINVAL; + goto done; + } + + /* + * Check out Data API + */ + switch (ap->api) { + + case CMAPI_CPCS: + upf = atm_cm_cpcs_upper; + break; + + case CMAPI_SAAL: + sl.sl_sap[sli++] = SAP_SSCF_UNI; + sl.sl_sap[sli++] = SAP_SSCOP; + upf = atm_cm_saal_upper; + break; + + case CMAPI_SSCOP: + sl.sl_sap[sli++] = SAP_SSCOP; + upf = atm_cm_sscop_upper; + break; + + default: + err = EINVAL; + goto done; + } + + /* + * AAL Attributes + */ + if (ap->aal.tag != T_ATM_PRESENT) { + err = EINVAL; + goto done; + } + + switch (ap->aal.type) { + + case ATM_AAL5: + sl.sl_sap[sli++] = SAP_CPCS_AAL5; + sl.sl_sap[sli++] = SAP_SAR_AAL5; + sl.sl_sap[sli++] = SAP_ATM; + break; + + case ATM_AAL3_4: + sl.sl_sap[sli++] = SAP_CPCS_AAL3_4; + sl.sl_sap[sli++] = SAP_SAR_AAL3_4; + sl.sl_sap[sli++] = SAP_ATM; + break; + + default: + err = EINVAL; + goto done; + } + + /* + * Broadband Bearer Attributes + */ + if (ap->bearer.tag != T_ATM_PRESENT) { + err = EINVAL; + goto done; + } + + switch (ap->bearer.v.connection_configuration) { + + case T_ATM_1_TO_1: + cop->co_flags |= COF_P2P; + break; + + case T_ATM_1_TO_MANY: + /* Not supported */ + cop->co_flags |= COF_P2MP; + err = EINVAL; + goto done; + + default: + err = EINVAL; + goto done; + } + + /* + * Logical Link Control Attributes + */ + if (ap->llc.tag == T_ATM_PRESENT) { + if ((ap->blli.tag_l2 != T_ATM_PRESENT) || + (ap->blli.v.layer_2_protocol.ID_type != T_ATM_SIMPLE_ID) || + (ap->blli.v.layer_2_protocol.ID.simple_ID != + T_ATM_BLLI2_I8802) || + (ap->llc.v.llc_len < T_ATM_LLC_MIN_LEN) || + (ap->llc.v.llc_len > T_ATM_LLC_MAX_LEN)) { + err = EINVAL; + goto done; + } + cop->co_mpx = ATM_ENC_LLC; + cop->co_llc = ap->llc; + } else + cop->co_mpx = ATM_ENC_NULL; + + /* + * Called Party Attributes + */ + if (ap->called.tag != T_ATM_PRESENT) { + err = EINVAL; + goto done; + } + + if ((ap->called.addr.address_format == T_ATM_ABSENT) || + (ap->called.addr.address_length == 0)) { + err = EINVAL; + goto done; + } + + /* + * Calling Party Attributes + */ + if (ap->calling.tag != T_ATM_ABSENT) { + err = EINVAL; + goto done; + } + + /* + * Quality of Service Attributes + */ + if (ap->qos.tag != T_ATM_PRESENT) { + err = EINVAL; + goto done; + } + + /* + * Terminate stack list + */ + sl.sl_sap[sli] = 0; + + s = splnet(); + + /* + * Let multiplexors decide whether we need a new VCC + */ + switch (cop->co_mpx) { + + case ATM_ENC_NULL: + /* + * All of these connections require a new VCC + */ + break; + + case ATM_ENC_LLC: + /* + * See if we can share an existing LLC connection + */ + cvp = atm_cm_share_llc(ap); + if (cvp == NULL) + break; + + /* + * We've got a connection to share + */ + cop->co_connvc = cvp; + if (cvp->cvc_state == CVCS_ACTIVE) { + cop->co_state = COS_ACTIVE; + err = 0; + } else { + cop->co_state = COS_OUTCONN; + err = EINPROGRESS; + } + LINK2TAIL(cop, Atm_connection, cvp->cvc_conn->co_mxh, co_next); + cop->co_mxh = cvp->cvc_conn->co_mxh; + *copp = cop; + + (void) splx(s); + return (err); + + default: + panic("atm_cm_connect: unknown mpx"); + } + + /* + * If we get here, it means we need to create + * a new VCC for this connection + */ + + /* + * Validate that network interface is registered and that + * a signalling manager is attached + */ + for (pip = atm_interface_head; pip != NULL; pip = pip->pif_next) { + struct atm_nif *nip; + for (nip = pip->pif_nif; nip; nip = nip->nif_pnext) { + if (nip == ap->nif) + break; + } + if (nip) + break; + } + if (pip == NULL) { + err = ENXIO; + goto donex; + } + + if ((smp = pip->pif_sigmgr) == NULL) { + err = ENXIO; + goto donex; + } + + /* + * Get a connection VCC block + */ + cvp = (Atm_connvc *)atm_allocate(&atm_connvc_pool); + if (cvp == NULL) { + err = ENOMEM; + goto donex; + } + + /* + * Save VCC attributes + */ + cvp->cvc_attr = *ap; + cvp->cvc_flags |= CVCF_CALLER; + + /* + * Link the control blocks + */ + cop->co_connvc = cvp; + cvp->cvc_conn = cop; + cvp->cvc_sigmgr = smp; + + /* + * Create a service stack + */ + err = atm_create_stack(cvp, &sl, upf); + if (err) { + cvp->cvc_state = CVCS_CLEAR; + atm_cm_closevc(cvp); + goto donex; + } + + /* + * Let the signalling manager handle the VCC creation + */ + cvp->cvc_state = CVCS_SETUP; + switch ((*smp->sm_setup)(cvp, &err)) { + + case CALL_CONNECTED: + /* + * Connection is fully setup - initialize the stack + */ + cvp->cvc_state = CVCS_INIT; + STACK_CALL(atm_stackcmds[ap->api].init, cvp->cvc_lower, + cvp->cvc_tokl, cvp, ap->api_init, 0, err2); + if (err2) + panic("atm_cm_connect: init"); + + if (cvp->cvc_flags & CVCF_ABORTING) { + /* + * Someone on the stack bailed out...schedule the + * VCC and stack termination + */ + atm_cm_closevc(cvp); + err = EFAULT; + } else { + /* + * Everything looks fine from here + */ + cvp->cvc_state = CVCS_ACTIVE; + cop->co_state = COS_ACTIVE; + } + break; + + case CALL_FAILED: + /* + * Terminate stack and clean up before we leave + */ + cvp->cvc_state = CVCS_CLEAR; + atm_cm_closevc(cvp); + break; + + case CALL_PROCEEDING: + /* + * We'll just wait for final call status + */ + cop->co_state = COS_OUTCONN; + err = EINPROGRESS; + break; + + default: + panic("atm_cm_connect: setup"); + } + +donex: + (void) splx(s); + +done: + if (err && err != EINPROGRESS) { + /* + * Undo any partial setup stuff + */ + if (cop) + atm_free((caddr_t)cop); + } else { + /* + * Finish connection setup + */ + s = splnet(); + cvp->cvc_flags |= CVCF_CONNQ; + ENQUEUE(cvp, Atm_connvc, cvc_q, atm_connection_queue); + LINK2TAIL(cop, Atm_connection, cop->co_mxh, co_next); + (void) splx(s); + *copp = cop; + } + return (err); +} + + +/* + * Listen for Incoming ATM Calls + * + * Called by an endpoint service in order to indicate its willingness to + * accept certain incoming calls. The types of calls which the endpoint + * is prepared to accept are specified in the Atm_attributes parameter. + * + * For each call which meets the criteria specified by the endpoint, the + * endpoint service will receive an incoming call notification via the + * endpoint's ep_incoming() function. + * + * To cancel the listening connection, the endpoint user should invoke + * atm_cm_release(). + * + * Arguments: + * epp pointer to endpoint definition structure + * token endpoint's listen instance token + * ap pointer to listening connection attributes + * copp pointer to location to return allocated connection block + * + * Returns: + * 0 listening connection installed + * errno listen failed - reason indicated + * + */ +int +atm_cm_listen(epp, token, ap, copp) + Atm_endpoint *epp; + void *token; + Atm_attributes *ap; + Atm_connection **copp; +{ + Atm_connection *cop; + int s, err = 0; + + *copp = NULL; + + /* + * Get a connection block + */ + cop = (Atm_connection *)atm_allocate(&atm_connection_pool); + if (cop == NULL) + return (ENOMEM); + + /* + * Initialize connection info + */ + cop->co_endpt = epp; + cop->co_toku = token; + cop->co_mxh = cop; + + /* + * Validate and extract useful attribute information + */ + + /* + * Check out Data API + */ + switch (ap->api) { + + case CMAPI_CPCS: + case CMAPI_SAAL: + case CMAPI_SSCOP: + break; + + default: + err = EINVAL; + goto done; + } + + /* + * AAL Attributes + */ + switch (ap->aal.tag) { + + case T_ATM_PRESENT: + + switch (ap->aal.type) { + + case ATM_AAL5: + case ATM_AAL3_4: + break; + + default: + err = EINVAL; + goto done; + } + break; + + case T_ATM_ABSENT: + case T_ATM_ANY: + break; + + default: + err = EINVAL; + goto done; + } + + /* + * Broadband High Layer Information Attributes + */ + switch (ap->bhli.tag) { + + case T_ATM_PRESENT: + case T_ATM_ABSENT: + case T_ATM_ANY: + break; + + default: + err = EINVAL; + goto done; + } + + /* + * Broadband Low Layer Information Attributes + */ + switch (ap->blli.tag_l2) { + + case T_ATM_PRESENT: + case T_ATM_ABSENT: + case T_ATM_ANY: + break; + + default: + err = EINVAL; + goto done; + } + + switch (ap->blli.tag_l3) { + + case T_ATM_PRESENT: + case T_ATM_ABSENT: + case T_ATM_ANY: + break; + + default: + err = EINVAL; + goto done; + } + + /* + * Logical Link Control Attributes + */ + switch (ap->llc.tag) { + + case T_ATM_PRESENT: + if ((ap->blli.tag_l2 != T_ATM_PRESENT) || + (ap->blli.v.layer_2_protocol.ID_type != T_ATM_SIMPLE_ID) || + (ap->blli.v.layer_2_protocol.ID.simple_ID != + T_ATM_BLLI2_I8802) || + (ap->llc.v.llc_len < T_ATM_LLC_MIN_LEN) || + (ap->llc.v.llc_len > T_ATM_LLC_MAX_LEN)) { + err = EINVAL; + goto done; + } + cop->co_mpx = ATM_ENC_LLC; + cop->co_llc = ap->llc; + break; + + case T_ATM_ABSENT: + case T_ATM_ANY: + cop->co_mpx = ATM_ENC_NULL; + break; + + default: + err = EINVAL; + goto done; + } + + /* + * Called Party Attributes + */ + switch (ap->called.tag) { + + case T_ATM_PRESENT: + switch (ap->called.addr.address_format) { + + case T_ATM_ABSENT: + ap->called.tag = T_ATM_ABSENT; + break; + + case T_ATM_PVC_ADDR: + err = EINVAL; + goto done; + } + break; + + case T_ATM_ABSENT: + case T_ATM_ANY: + break; + + default: + err = EINVAL; + goto done; + } + + /* + * Get an attribute block and save listening attributes + */ + cop->co_lattr = (Atm_attributes *)atm_allocate(&atm_attributes_pool); + if (cop->co_lattr == NULL) { + err = ENOMEM; + goto done; + } + *cop->co_lattr = *ap; + + /* + * Now try to register the listening connection + */ + s = splnet(); + if (atm_cm_match(cop->co_lattr, NULL) != NULL) { + /* + * Can't have matching listeners + */ + err = EADDRINUSE; + goto donex; + } + cop->co_state = COS_LISTEN; + LINK2TAIL(cop, Atm_connection, atm_listen_queue, co_next); + +donex: + (void) splx(s); + +done: + if (err) { + /* + * Undo any partial setup stuff + */ + if (cop) { + if (cop->co_lattr) + atm_free((caddr_t)cop->co_lattr); + atm_free((caddr_t)cop); + } + } else { + /* + * Finish connection setup + */ + *copp = cop; + } + return (err); +} + + +/* + * Add to LLC Connection + * + * Called by an endpoint service to create a new Connection Manager API + * instance to be associated with an LLC-multiplexed connection instance + * which has been previously created. The endpoint provided token will + * be used in all further CM -> endpoint function calls, and the returned + * connection block pointer must be used in all subsequent endpoint -> CM + * function calls. + * + * If the return indicates that the connection setup has been immediately + * successful, then the connection is ready for data transmission. + * + * If the return indicates that the connection setup is still in progress, + * then the endpoint must wait for notification from the Connection Manager + * indicating the final status of the call setup. If the call setup completes + * successfully, then a "call connected" notification will be sent to the + * endpoint by the Connection Manager. If the call setup fails, then the + * endpoint will receive a "call cleared" notification. + * + * All connection instances must be freed with an atm_cm_release() call. + * + * Arguments: + * epp pointer to endpoint definition structure + * token endpoint's connection instance token + * llc pointer to llc attributes for new connection + * ecop pointer to existing connection block + * copp pointer to location to return allocated connection block + * + * Returns: + * 0 connection has been successfully established + * EINPROGRESS connection establishment is in progress + * errno addllc failed - reason indicated + * + */ +int +atm_cm_addllc(epp, token, llc, ecop, copp) + Atm_endpoint *epp; + void *token; + struct attr_llc *llc; + Atm_connection *ecop; + Atm_connection **copp; +{ + Atm_connection *cop, *cop2; + Atm_connvc *cvp; + int s, err; + + *copp = NULL; + + /* + * Check out requested LLC attributes + */ + if ((llc->tag != T_ATM_PRESENT) || + ((llc->v.flags & T_ATM_LLC_SHARING) == 0) || + (llc->v.llc_len < T_ATM_LLC_MIN_LEN) || + (llc->v.llc_len > T_ATM_LLC_MAX_LEN)) + return (EINVAL); + + /* + * Get a connection block + */ + cop = (Atm_connection *)atm_allocate(&atm_connection_pool); + if (cop == NULL) + return (ENOMEM); + + /* + * Initialize connection info + */ + cop->co_endpt = epp; + cop->co_toku = token; + cop->co_llc = *llc; + + s = splnet(); + + /* + * Ensure that supplied connection is really valid + */ + cop2 = NULL; + for (cvp = Q_HEAD(atm_connection_queue, Atm_connvc); cvp; + cvp = Q_NEXT(cvp, Atm_connvc, cvc_q)) { + for (cop2 = cvp->cvc_conn; cop2; cop2 = cop2->co_next) { + if (ecop == cop2) + break; + } + if (cop2) + break; + } + if (cop2 == NULL) { + err = ENOENT; + goto done; + } + + switch (ecop->co_state) { + + case COS_OUTCONN: + case COS_INACCEPT: + err = EINPROGRESS; + break; + + case COS_ACTIVE: + err = 0; + break; + + default: + err = EINVAL; + goto done; + } + + /* + * Connection must be LLC multiplexed and shared + */ + if ((ecop->co_mpx != ATM_ENC_LLC) || + ((ecop->co_llc.v.flags & T_ATM_LLC_SHARING) == 0)) { + err = EINVAL; + goto done; + } + + /* + * This new LLC header must be unique for this VCC + */ + cop2 = ecop->co_mxh; + while (cop2) { + int i = MIN(llc->v.llc_len, cop2->co_llc.v.llc_len); + + if (KM_CMP(llc->v.llc_info, cop2->co_llc.v.llc_info, i) == 0) { + err = EINVAL; + goto done; + } + + cop2 = cop2->co_next; + } + + /* + * Everything seems to check out + */ + cop->co_flags = ecop->co_flags; + cop->co_state = ecop->co_state; + cop->co_mpx = ecop->co_mpx; + cop->co_connvc = ecop->co_connvc; + + LINK2TAIL(cop, Atm_connection, ecop->co_mxh, co_next); + cop->co_mxh = ecop->co_mxh; + +done: + (void) splx(s); + + if (err && err != EINPROGRESS) { + /* + * Undo any partial setup stuff + */ + if (cop) + atm_free((caddr_t)cop); + } else { + /* + * Pass new connection back to caller + */ + *copp = cop; + } + return (err); +} + + +/* + * XXX + * + * Arguments: + * cop pointer to connection block + * id identifier for party to be added + * addr address of party to be added + * + * Returns: + * 0 addparty successful + * errno addparty failed - reason indicated + * + */ +int +atm_cm_addparty(cop, id, addr) + Atm_connection *cop; + int id; + struct t_atm_sap *addr; +{ + return (0); +} + + +/* + * XXX + * + * Arguments: + * cop pointer to connection block + * id identifier for party to be added + * cause pointer to cause of drop + * + * Returns: + * 0 dropparty successful + * errno dropparty failed - reason indicated + * + */ +int +atm_cm_dropparty(cop, id, cause) + Atm_connection *cop; + int id; + struct t_atm_cause *cause; +{ + return (0); +} + + +/* + * Release Connection Resources + * + * Called by the endpoint service in order to terminate an ATM connection + * and to release all system resources for the connection. This function + * must be called for every allocated connection instance and must only + * be called by the connection's owner. + * + * Arguments: + * cop pointer to connection block + * cause pointer to cause of release + * + * Returns: + * 0 release successful + * errno release failed - reason indicated + * + */ +int +atm_cm_release(cop, cause) + Atm_connection *cop; + struct t_atm_cause *cause; +{ + Atm_connvc *cvp; + int s; + + s = splnet(); + + /* + * First, a quick state validation check + */ + switch (cop->co_state) { + + case COS_OUTCONN: + case COS_LISTEN: + case COS_INACCEPT: + case COS_ACTIVE: + case COS_CLEAR: + /* + * Break link to user + */ + cop->co_toku = NULL; + break; + + case COS_INCONN: + (void) splx(s); + return (EFAULT); + + default: + panic("atm_cm_release: bogus conn state"); + } + + /* + * Check out the VCC state too + */ + if (cvp = cop->co_connvc) { + + switch (cvp->cvc_state) { + + case CVCS_SETUP: + case CVCS_INIT: + case CVCS_ACCEPT: + case CVCS_ACTIVE: + break; + + case CVCS_INCOMING: + (void) splx(s); + return (EFAULT); + + case CVCS_CLEAR: + (void) splx(s); + return (EALREADY); + + default: + panic("atm_cm_release: bogus connvc state"); + } + + /* + * If we're the only connection, terminate the VCC + */ + if ((cop->co_mxh == cop) && (cop->co_next == NULL)) { + cvp->cvc_attr.cause.tag = T_ATM_PRESENT; + cvp->cvc_attr.cause.v = *cause; + atm_cm_closevc(cvp); + } + } + + /* + * Now get rid of the connection + */ + atm_cm_closeconn(cop, cause); + + return (0); +} + + +/* + * Abort an ATM Connection VCC + * + * This function allows any non-owner kernel entity to request an + * immediate termination of an ATM VCC. This will normally be called + * when encountering a catastrophic error condition that cannot be + * resolved via the available stack protocols. The connection manager + * will schedule the connection's termination, including notifying the + * connection owner of the termination. + * + * This function should only be called by a stack entity instance. After + * calling the function, the caller should set a protocol state which just + * waits for a <sap>_TERM stack command to be delivered. + * + * Arguments: + * cvp pointer to connection VCC block + * cause pointer to cause of abort + * + * Returns: + * 0 abort successful + * errno abort failed - reason indicated + * + */ +int +atm_cm_abort(cvp, cause) + Atm_connvc *cvp; + struct t_atm_cause *cause; +{ + ATM_DEBUG2("atm_cm_abort: cvp=0x%x cause=%d\n", + (int)cvp, cause->cause_value); + + /* + * Note that we're aborting + */ + cvp->cvc_flags |= CVCF_ABORTING; + + switch (cvp->cvc_state) { + + case CVCS_INIT: + /* + * In-line code will handle this + */ + cvp->cvc_attr.cause.tag = T_ATM_PRESENT; + cvp->cvc_attr.cause.v = *cause; + break; + + case CVCS_SETUP: + case CVCS_ACCEPT: + case CVCS_ACTIVE: + /* + * Schedule connection termination, since we want + * to avoid any sequencing interactions + */ + cvp->cvc_attr.cause.tag = T_ATM_PRESENT; + cvp->cvc_attr.cause.v = *cause; + CVC_TIMER(cvp, 0); + break; + + case CVCS_REJECT: + case CVCS_RELEASE: + case CVCS_CLEAR: + case CVCS_TERM: + /* + * Ignore abort, as we're already terminating + */ + break; + + default: + log(LOG_ERR, + "atm_cm_abort: invalid state: cvp=0x%x, state=%d\n", + (int)cvp, cvp->cvc_state); + } + return (0); +} + + +/* + * Incoming ATM Call Received + * + * Called by a signalling manager to indicate that a new call request has + * been received. This function will allocate and initialize the connection + * manager control blocks and queue this call request. The call request + * processing function, atm_cm_procinq(), will be scheduled to perform the + * call processing. + * + * Arguments: + * vcp pointer to incoming call's VCC control block + * ap pointer to incoming call's attributes + * + * Returns: + * 0 call queuing successful + * errno call queuing failed - reason indicated + * + */ +int +atm_cm_incoming(vcp, ap) + struct vccb *vcp; + Atm_attributes *ap; +{ + Atm_connvc *cvp; + int s, err; + + + /* + * Do some minimal attribute validation + */ + + /* + * Must specify a network interface + */ + if (ap->nif == NULL) + return (EINVAL); + + /* + * AAL Attributes + */ + if ((ap->aal.tag != T_ATM_PRESENT) || + ((ap->aal.type != ATM_AAL5) && + (ap->aal.type != ATM_AAL3_4))) + return (EINVAL); + + /* + * Traffic Descriptor Attributes + */ + if ((ap->traffic.tag != T_ATM_PRESENT) && + (ap->traffic.tag != T_ATM_ABSENT)) + return (EINVAL); + + /* + * Broadband Bearer Attributes + */ + if ((ap->bearer.tag != T_ATM_PRESENT) || + ((ap->bearer.v.connection_configuration != T_ATM_1_TO_1) && + (ap->bearer.v.connection_configuration != T_ATM_1_TO_MANY))) + return (EINVAL); + + /* + * Broadband High Layer Attributes + */ + if ((ap->bhli.tag != T_ATM_PRESENT) && + (ap->bhli.tag != T_ATM_ABSENT)) + return (EINVAL); + + /* + * Broadband Low Layer Attributes + */ + if ((ap->blli.tag_l2 != T_ATM_PRESENT) && + (ap->blli.tag_l2 != T_ATM_ABSENT)) + return (EINVAL); + if ((ap->blli.tag_l3 != T_ATM_PRESENT) && + (ap->blli.tag_l3 != T_ATM_ABSENT)) + return (EINVAL); + + /* + * Logical Link Control Attributes + */ + if (ap->llc.tag == T_ATM_PRESENT) + return (EINVAL); + ap->llc.tag = T_ATM_ANY; + + /* + * Called Party Attributes + */ + if ((ap->called.tag != T_ATM_PRESENT) || + (ap->called.addr.address_format == T_ATM_ABSENT)) + return (EINVAL); + if (ap->called.tag == T_ATM_ABSENT) { + ap->called.addr.address_format = T_ATM_ABSENT; + ap->called.addr.address_length = 0; + ap->called.subaddr.address_format = T_ATM_ABSENT; + ap->called.subaddr.address_length = 0; + } + + /* + * Calling Party Attributes + */ + if ((ap->calling.tag != T_ATM_PRESENT) && + (ap->calling.tag != T_ATM_ABSENT)) + return (EINVAL); + if (ap->calling.tag == T_ATM_ABSENT) { + ap->calling.addr.address_format = T_ATM_ABSENT; + ap->calling.addr.address_length = 0; + ap->calling.subaddr.address_format = T_ATM_ABSENT; + ap->calling.subaddr.address_length = 0; + } + + /* + * Quality of Service Attributes + */ + if (ap->qos.tag != T_ATM_PRESENT) + return (EINVAL); + + /* + * Transit Network Attributes + */ + if ((ap->transit.tag != T_ATM_PRESENT) && + (ap->transit.tag != T_ATM_ABSENT)) + return (EINVAL); + + /* + * Cause Attributes + */ + if ((ap->cause.tag != T_ATM_PRESENT) && + (ap->cause.tag != T_ATM_ABSENT)) + return (EINVAL); + + /* + * Get a connection VCC block + */ + cvp = (Atm_connvc *)atm_allocate(&atm_connvc_pool); + if (cvp == NULL) { + err = ENOMEM; + goto fail; + } + + /* + * Initialize the control block + */ + cvp->cvc_vcc = vcp; + cvp->cvc_sigmgr = vcp->vc_pif->pif_sigmgr; + cvp->cvc_attr = *ap; + cvp->cvc_state = CVCS_INCOMING; + + /* + * Control queue length + */ + s = splnet(); + if (atm_incoming_qlen >= ATM_CALLQ_MAX) { + (void) splx(s); + err = EBUSY; + goto fail; + } + + /* + * Queue request and schedule call processing function + */ + cvp->cvc_flags |= CVCF_INCOMQ; + ENQUEUE(cvp, Atm_connvc, cvc_q, atm_incoming_queue); + if (atm_incoming_qlen++ == 0) { + timeout(atm_cm_procinq, (void *)0, 0); + } + + /* + * Link for signalling manager + */ + vcp->vc_connvc = cvp; + + (void) splx(s); + + return (0); + +fail: + /* + * Free any resources + */ + if (cvp) + atm_free((caddr_t)cvp); + return (err); +} + + +/* + * VCC Connected Notification + * + * This function is called by a signalling manager as notification that a + * VCC call setup has been successful. + * + * Arguments: + * cvp pointer to connection VCC block + * + * Returns: + * none + * + */ +void +atm_cm_connected(cvp) + Atm_connvc *cvp; +{ + Atm_connection *cop, *cop2; + KBuffer *m; + int s, err; + + s = splnet(); + + /* + * Validate connection vcc + */ + switch (cvp->cvc_state) { + + case CVCS_SETUP: + /* + * Initialize the stack + */ + cvp->cvc_state = CVCS_INIT; + STACK_CALL(atm_stackcmds[cvp->cvc_attr.api].init, + cvp->cvc_lower, cvp->cvc_tokl, + cvp, cvp->cvc_attr.api_init, 0, err); + if (err) + panic("atm_cm_connected: init"); + + if (cvp->cvc_flags & CVCF_ABORTING) { + /* + * Someone on the stack bailed out...notify all of the + * connections and schedule the VCC termination + */ + cop = cvp->cvc_conn; + while (cop) { + cop2 = cop->co_next; + atm_cm_closeconn(cop, &cvp->cvc_attr.cause.v); + cop = cop2; + } + atm_cm_closevc(cvp); + (void) splx(s); + return; + } + break; + + case CVCS_ACCEPT: + /* + * Stack already initialized + */ + break; + + default: + panic("atm_cm_connected: connvc state"); + } + + /* + * VCC is ready for action + */ + cvp->cvc_state = CVCS_ACTIVE; + + /* + * Notify all connections that the call has completed + */ + cop = cvp->cvc_conn; + while (cop) { + cop2 = cop->co_next; + + switch (cop->co_state) { + + case COS_OUTCONN: + case COS_INACCEPT: + cop->co_state = COS_ACTIVE; + (*cop->co_endpt->ep_connected)(cop->co_toku); + break; + + case COS_ACTIVE: + /* + * May get here if an ep_connected() call (from + * above) results in an atm_cm_addllc() call for + * the just connected connection. + */ + break; + + default: + panic("atm_cm_connected: connection state"); + } + + cop = cop2; + } + + (void) splx(s); + + /* + * Input any queued packets + */ + while (m = cvp->cvc_rcvq) { + cvp->cvc_rcvq = KB_QNEXT(m); + cvp->cvc_rcvqlen--; + KB_QNEXT(m) = NULL; + + /* + * Currently only supported for CPCS API + */ + atm_cm_cpcs_upper(CPCS_UNITDATA_SIG, cvp, (int)m, 0); + } + + return; +} + + +/* + * VCC Cleared Notification + * + * This function is called by a signalling manager as notification that a + * VCC call has been cleared. The cause information describing the reason + * for the call clearing will be contained in the connection VCC attributes. + * + * Arguments: + * cvp pointer to connection VCC block + * + * Returns: + * none + * + */ +void +atm_cm_cleared(cvp) + Atm_connvc *cvp; +{ + Atm_connection *cop, *cop2; + int s; + +#ifdef DIAGNOSTIC + if ((cvp->cvc_state == CVCS_FREE) || + (cvp->cvc_state >= CVCS_CLEAR)) + panic("atm_cm_cleared"); +#endif + + cvp->cvc_state = CVCS_CLEAR; + + s = splnet(); + + /* + * Terminate all connections + */ + cop = cvp->cvc_conn; + while (cop) { + cop2 = cop->co_next; + atm_cm_closeconn(cop, &cvp->cvc_attr.cause.v); + cop = cop2; + } + + /* + * Clean up connection VCC + */ + atm_cm_closevc(cvp); + + (void) splx(s); + + return; +} + + +/* + * Process Incoming Call Queue + * + * This function is scheduled by atm_cm_incoming() in order to process + * all the entries on the incoming call queue. + * + * Arguments: + * arg argument passed on timeout() call + * + * Returns: + * none + * + */ +static KTimeout_ret +atm_cm_procinq(arg) + void *arg; +{ + Atm_connvc *cvp; + int cnt = 0, s; + + /* + * Only process incoming calls up to our quota + */ + while (cnt++ < ATM_CALLQ_MAX) { + + s = splnet(); + + /* + * Get next awaiting call + */ + cvp = Q_HEAD(atm_incoming_queue, Atm_connvc); + if (cvp == NULL) { + (void) splx(s); + break; + } + DEQUEUE(cvp, Atm_connvc, cvc_q, atm_incoming_queue); + atm_incoming_qlen--; + cvp->cvc_flags &= ~CVCF_INCOMQ; + + /* + * Handle the call + */ + atm_cm_incall(cvp); + + (void) splx(s); + } + + /* + * If we've expended our quota, reschedule ourselves + */ + if (cnt >= ATM_CALLQ_MAX) + timeout(atm_cm_procinq, (void *)0, 0); +} + + +/* + * Process Incoming Call + * + * This function will search through the listening queue and try to find + * matching endpoint(s) for the incoming call. If we find any, we will + * notify the endpoint service(s) of the incoming call and will then + * notify the signalling manager to progress the call to an active status. + * + * If there are no listeners for the call, the signalling manager will be + * notified of a call rejection. + * + * Called at splnet. + * + * Arguments: + * cvp pointer to connection VCC for incoming call + * + * Returns: + * none + * + */ +static void +atm_cm_incall(cvp) + Atm_connvc *cvp; +{ + Atm_connection *cop, *lcop, *hcop; + Atm_attributes attr; + int err; + + hcop = NULL; + lcop = NULL; + cop = NULL; + attr = cvp->cvc_attr; + + /* + * Look for matching listeners + */ + while (lcop = atm_cm_match(&attr, lcop)) { + + if (cop == NULL) { + /* + * Need a new connection block + */ + cop = (Atm_connection *) + atm_allocate(&atm_connection_pool); + if (cop == NULL) { + cvp->cvc_attr.cause = atm_cause_tmpl; + cvp->cvc_attr.cause.v.cause_value = + T_ATM_CAUSE_TEMPORARY_FAILURE; + goto fail; + } + } + + /* + * Initialize connection from listener and incoming call + */ + cop->co_mxh = NULL; + cop->co_state = COS_INCONN; + cop->co_mpx = lcop->co_mpx; + cop->co_endpt = lcop->co_endpt; + cop->co_llc = lcop->co_llc; + + switch (attr.bearer.v.connection_configuration) { + + case T_ATM_1_TO_1: + cop->co_flags |= COF_P2P; + break; + + case T_ATM_1_TO_MANY: + /* Not supported */ + cop->co_flags |= COF_P2MP; + cvp->cvc_attr.cause = atm_cause_tmpl; + cvp->cvc_attr.cause.v.cause_value = + T_ATM_CAUSE_BEARER_CAPABILITY_NOT_IMPLEMENTED; + goto fail; + } + + /* + * Notify endpoint of incoming call + */ + err = (*cop->co_endpt->ep_incoming) + (lcop->co_toku, cop, &cvp->cvc_attr, &cop->co_toku); + + if (err == 0) { + + /* + * Endpoint has accepted the call + * + * Setup call attributes + */ + if (hcop == NULL) { + cvp->cvc_attr.api = lcop->co_lattr->api; + cvp->cvc_attr.api_init = + lcop->co_lattr->api_init; + cvp->cvc_attr.llc = lcop->co_lattr->llc; + } + cvp->cvc_attr.headin = MAX(cvp->cvc_attr.headin, + lcop->co_lattr->headin); + + /* + * Setup connection info and queueing + */ + cop->co_state = COS_INACCEPT; + cop->co_connvc = cvp; + LINK2TAIL(cop, Atm_connection, hcop, co_next); + cop->co_mxh = hcop; + + /* + * Need a new connection block next time around + */ + cop = NULL; + + } else { + /* + * Endpoint refuses call + */ + goto fail; + } + } + + /* + * We're done looking for listeners + */ + if (hcop) { + /* + * Someone actually wants the call, so notify + * the signalling manager to continue + */ + cvp->cvc_flags |= CVCF_CONNQ; + ENQUEUE(cvp, Atm_connvc, cvc_q, atm_connection_queue); + if (atm_cm_accept(cvp, hcop)) + goto fail; + + } else { + /* + * Nobody around to take the call + */ + cvp->cvc_attr.cause = atm_cause_tmpl; + cvp->cvc_attr.cause.v.cause_value = + T_ATM_CAUSE_INCOMPATIBLE_DESTINATION; + goto fail; + } + + /* + * Clean up loose ends + */ + if (cop) + atm_free((caddr_t)cop); + + /* + * Call has been accepted + */ + return; + +fail: + /* + * Call failed - notify any endpoints of the call failure + */ + + /* + * Clean up loose ends + */ + if (cop) + atm_free((caddr_t)cop); + + if (cvp->cvc_attr.cause.tag != T_ATM_PRESENT) { + cvp->cvc_attr.cause = atm_cause_tmpl; + cvp->cvc_attr.cause.v.cause_value = + T_ATM_CAUSE_UNSPECIFIED_NORMAL; + } + cop = hcop; + while (cop) { + Atm_connection *cop2 = cop->co_next; + atm_cm_closeconn(cop, &cvp->cvc_attr.cause.v); + cop = cop2; + } + + /* + * Tell the signalling manager to reject the call + */ + atm_cm_closevc(cvp); + + return; +} + + +/* + * Accept an Incoming ATM Call + * + * Some endpoint service(s) wants to accept an incoming call, so the + * signalling manager will be notified to attempt to progress the call + * to an active status. + * + * If the signalling manager indicates that connection activation has + * been immediately successful, then all of the endpoints will be notified + * that the connection is ready for data transmission. + * + * If the return indicates that connection activation is still in progress, + * then the endpoints must wait for notification from the Connection Manager + * indicating the final status of the call setup. If the call setup completes + * successfully, then a "call connected" notification will be sent to the + * endpoints by the Connection Manager. If the call setup fails, then the + * endpoints will receive a "call cleared" notification. + * + * Called at splnet. + * + * Arguments: + * cvp pointer to connection VCC for incoming call + * cop pointer to head of accepted connections + * + * Returns: + * 0 connection has been successfully activated + * errno accept failed - reason indicated + * + */ +static int +atm_cm_accept(cvp, cop) + Atm_connvc *cvp; + Atm_connection *cop; +{ + struct stack_list sl; + void (*upf)__P((int, void *, int, int)); + int sli, err, err2; + + + /* + * Link vcc to connections + */ + cvp->cvc_conn = cop; + + /* + * Initialize stack list index + */ + sli = 0; + + /* + * Check out Data API + */ + switch (cvp->cvc_attr.api) { + + case CMAPI_CPCS: + upf = atm_cm_cpcs_upper; + break; + + case CMAPI_SAAL: + sl.sl_sap[sli++] = SAP_SSCF_UNI; + sl.sl_sap[sli++] = SAP_SSCOP; + upf = atm_cm_saal_upper; + break; + + case CMAPI_SSCOP: + sl.sl_sap[sli++] = SAP_SSCOP; + upf = atm_cm_sscop_upper; + break; + + default: + upf = NULL; + } + + /* + * AAL Attributes + */ + switch (cvp->cvc_attr.aal.type) { + + case ATM_AAL5: + sl.sl_sap[sli++] = SAP_CPCS_AAL5; + sl.sl_sap[sli++] = SAP_SAR_AAL5; + sl.sl_sap[sli++] = SAP_ATM; + break; + + case ATM_AAL3_4: + sl.sl_sap[sli++] = SAP_CPCS_AAL3_4; + sl.sl_sap[sli++] = SAP_SAR_AAL3_4; + sl.sl_sap[sli++] = SAP_ATM; + break; + } + + /* + * Terminate stack list + */ + sl.sl_sap[sli] = 0; + + /* + * Create a service stack + */ + err = atm_create_stack(cvp, &sl, upf); + if (err) { + goto done; + } + + /* + * Let the signalling manager finish the VCC activation + */ + switch ((*cvp->cvc_sigmgr->sm_accept)(cvp->cvc_vcc, &err)) { + + case CALL_PROCEEDING: + /* + * Note that we're not finished yet + */ + err = EINPROGRESS; + /* FALLTHRU */ + + case CALL_CONNECTED: + /* + * Initialize the stack now, even if the call isn't totally + * active yet. We want to avoid the delay between getting + * the "call connected" event and actually notifying the + * adapter to accept cells on the new VCC - if the delay is + * too long, then we end up dropping the first pdus sent by + * the caller. + */ + cvp->cvc_state = CVCS_INIT; + STACK_CALL(atm_stackcmds[cvp->cvc_attr.api].init, + cvp->cvc_lower, cvp->cvc_tokl, cvp, + cvp->cvc_attr.api_init, 0, err2); + if (err2) + panic("atm_cm_accept: init"); + + if (cvp->cvc_flags & CVCF_ABORTING) { + /* + * Someone on the stack bailed out...schedule the + * VCC and stack termination + */ + err = ECONNABORTED; + } else { + /* + * Everything looks fine from here + */ + if (err) + cvp->cvc_state = CVCS_ACCEPT; + else + cvp->cvc_state = CVCS_ACTIVE; + } + break; + + case CALL_FAILED: + /* + * Terminate stack and clean up before we leave + */ + cvp->cvc_state = CVCS_CLEAR; + break; + + default: + panic("atm_cm_accept: accept"); + } + +done: + if (err == 0) { + /* + * Call has been connected, notify endpoints + */ + while (cop) { + Atm_connection *cop2 = cop->co_next; + + cop->co_state = COS_ACTIVE; + (*cop->co_endpt->ep_connected)(cop->co_toku); + cop = cop2; + } + + } else if (err == EINPROGRESS) { + /* + * Call is still in progress, endpoint must wait + */ + err = 0; + + } else { + /* + * Let caller know we failed + */ + cvp->cvc_attr.cause = atm_cause_tmpl; + cvp->cvc_attr.cause.v.cause_value = + T_ATM_CAUSE_UNSPECIFIED_RESOURCE_UNAVAILABLE; + } + + return (err); +} + + +/* + * Match Attributes on Listening Queue + * + * This function will attempt to match the supplied connection attributes + * with one of the registered attributes in the listening queue. The pcop + * argument may be supplied in order to allow multiple listeners to share + * an incoming call (if supported by the listeners). + * + * Called at splnet. + * + * Arguments: + * ap pointer to attributes to be matched + * pcop pointer to the previously matched connection + * + * Returns: + * addr connection with which a match was found + * 0 no match found + * + */ +Atm_connection * +atm_cm_match(ap, pcop) + Atm_attributes *ap; + Atm_connection *pcop; +{ + Atm_connection *cop; + Atm_attributes *lap; + + + /* + * If we've already matched a listener... + */ + if (pcop) { + /* + * Make sure already matched listener supports sharing + */ + if ((pcop->co_mpx != ATM_ENC_LLC) || + ((pcop->co_llc.v.flags & T_ATM_LLC_SHARING) == 0)) + return (NULL); + + /* + * Position ourselves after the matched entry + */ + for (cop = atm_listen_queue; cop; cop = cop->co_next) { + if (cop == pcop) { + cop = pcop->co_next; + break; + } + } + } else { + /* + * Start search at top of listening queue + */ + cop = atm_listen_queue; + } + + /* + * Search through listening queue + */ + for (; cop; cop = cop->co_next) { + + lap = cop->co_lattr; + + /* + * If we're trying to share, check that this entry allows it + */ + if (pcop) { + if ((cop->co_mpx != ATM_ENC_LLC) || + ((cop->co_llc.v.flags & T_ATM_LLC_SHARING) == 0)) + continue; + } + + /* + * ALL "matchable" attributes must match + */ + + /* + * BHLI + */ + if (lap->bhli.tag == T_ATM_ABSENT) { + if (ap->bhli.tag == T_ATM_PRESENT) + continue; + } else if (lap->bhli.tag == T_ATM_PRESENT) { + if (ap->bhli.tag == T_ATM_ABSENT) + continue; + if (ap->bhli.tag == T_ATM_PRESENT) + if (KM_CMP(&lap->bhli.v, &ap->bhli.v, + sizeof(struct t_atm_bhli))) + continue; + } + + /* + * BLLI Layer 2 + */ + if (lap->blli.tag_l2 == T_ATM_ABSENT) { + if (ap->blli.tag_l2 == T_ATM_PRESENT) + continue; + } else if (lap->blli.tag_l2 == T_ATM_PRESENT) { + if (ap->blli.tag_l2 == T_ATM_ABSENT) + continue; + if (ap->blli.tag_l2 == T_ATM_PRESENT) { + if (KM_CMP(&lap->blli.v.layer_2_protocol.ID, + &ap->blli.v.layer_2_protocol.ID, + sizeof( + ap->blli.v.layer_2_protocol.ID))) + continue; + } + } + + /* + * BLLI Layer 3 + */ + if (lap->blli.tag_l3 == T_ATM_ABSENT) { + if (ap->blli.tag_l3 == T_ATM_PRESENT) + continue; + } else if (lap->blli.tag_l3 == T_ATM_PRESENT) { + if (ap->blli.tag_l3 == T_ATM_ABSENT) + continue; + if (ap->blli.tag_l3 == T_ATM_PRESENT) { + if (KM_CMP(&lap->blli.v.layer_3_protocol.ID, + &ap->blli.v.layer_3_protocol.ID, + sizeof( + ap->blli.v.layer_3_protocol.ID))) + continue; + } + } + + /* + * LLC + */ + if (lap->llc.tag == T_ATM_ABSENT) { + if (ap->llc.tag == T_ATM_PRESENT) + continue; + } else if (lap->llc.tag == T_ATM_PRESENT) { + if (ap->llc.tag == T_ATM_ABSENT) + continue; + if (ap->llc.tag == T_ATM_PRESENT) { + int i = MIN(lap->llc.v.llc_len, + ap->llc.v.llc_len); + + if (KM_CMP(lap->llc.v.llc_info, + ap->llc.v.llc_info, i)) + continue; + } + } + + /* + * AAL + */ + if (lap->aal.tag == T_ATM_ABSENT) { + if (ap->aal.tag == T_ATM_PRESENT) + continue; + } else if (lap->aal.tag == T_ATM_PRESENT) { + if (ap->aal.tag == T_ATM_ABSENT) + continue; + if (ap->aal.tag == T_ATM_PRESENT) { + if (lap->aal.type != ap->aal.type) + continue; + if (lap->aal.type == ATM_AAL5) { + if (lap->aal.v.aal5.SSCS_type != + ap->aal.v.aal5.SSCS_type) + continue; + } else { + if (lap->aal.v.aal4.SSCS_type != + ap->aal.v.aal4.SSCS_type) + continue; + } + } + } + + /* + * Called Party + */ + if (lap->called.tag == T_ATM_ABSENT) { + if (ap->called.tag == T_ATM_PRESENT) + continue; + } else if (lap->called.tag == T_ATM_PRESENT) { + if (ap->called.tag == T_ATM_ABSENT) + continue; + if (ap->called.tag == T_ATM_PRESENT) { + if ((!ATM_ADDR_EQUAL(&lap->called.addr, + &ap->called.addr)) || + (!ATM_ADDR_EQUAL(&lap->called.subaddr, + &ap->called.subaddr))) + continue; + } + } + + /* + * Found a full match - return it + */ + break; + } + + return (cop); +} + + +/* + * Find Shareable LLC VCC + * + * Given a endpoint-supplied connection attribute using LLC multiplexing, + * this function will attempt to locate an existing connection which meets + * the requirements of the supplied attributes. + * + * Called at splnet. + * + * Arguments: + * ap pointer to requested attributes + * + * Returns: + * addr shareable LLC connection VCC + * 0 no shareable VCC available + * + */ +static Atm_connvc * +atm_cm_share_llc(ap) + Atm_attributes *ap; +{ + Atm_connection *cop; + Atm_connvc *cvp; + + /* + * Is requestor willing to share? + */ + if ((ap->llc.v.flags & T_ATM_LLC_SHARING) == 0) + return (NULL); + + /* + * Try to find a shareable connection + */ + for (cvp = Q_HEAD(atm_connection_queue, Atm_connvc); cvp; + cvp = Q_NEXT(cvp, Atm_connvc, cvc_q)) { + + /* + * Dont use terminating connections + */ + switch (cvp->cvc_state) { + + case CVCS_SETUP: + case CVCS_ACCEPT: + case CVCS_ACTIVE: + break; + + default: + continue; + } + + /* + * Is connection LLC and shareable? + */ + if ((cvp->cvc_attr.llc.tag != T_ATM_PRESENT) || + ((cvp->cvc_attr.llc.v.flags & T_ATM_LLC_SHARING) == 0)) + continue; + + /* + * Match requested attributes with existing connection + */ + if (ap->nif != cvp->cvc_attr.nif) + continue; + + if ((ap->api != cvp->cvc_attr.api) || + (ap->api_init != cvp->cvc_attr.api_init)) + continue; + + /* + * Remote Party + */ + if (cvp->cvc_flags & CVCF_CALLER) { + if ((!ATM_ADDR_EQUAL(&ap->called.addr, + &cvp->cvc_attr.called.addr)) || + (!ATM_ADDR_EQUAL(&ap->called.subaddr, + &cvp->cvc_attr.called.subaddr))) + continue; + } else { + if (cvp->cvc_attr.calling.tag != T_ATM_PRESENT) + continue; + if ((!ATM_ADDR_EQUAL(&ap->called.addr, + &cvp->cvc_attr.calling.addr)) || + (!ATM_ADDR_EQUAL(&ap->called.subaddr, + &cvp->cvc_attr.calling.subaddr))) + continue; + } + + /* + * AAL + */ + if (ap->aal.type = ATM_AAL5) { + struct t_atm_aal5 *ap5, *cv5; + + ap5 = &ap->aal.v.aal5; + cv5 = &cvp->cvc_attr.aal.v.aal5; + + if ((cvp->cvc_attr.aal.type != ATM_AAL5) || + (ap5->SSCS_type != cv5->SSCS_type)) + continue; + + if (cvp->cvc_flags & CVCF_CALLER) { + if (ap5->forward_max_SDU_size > + cv5->forward_max_SDU_size) + continue; + } else { + if (ap5->forward_max_SDU_size > + cv5->backward_max_SDU_size) + continue; + } + } else { + struct t_atm_aal4 *ap4, *cv4; + + ap4 = &ap->aal.v.aal4; + cv4 = &cvp->cvc_attr.aal.v.aal4; + + if ((cvp->cvc_attr.aal.type != ATM_AAL3_4) || + (ap4->SSCS_type != cv4->SSCS_type)) + continue; + + if (cvp->cvc_flags & CVCF_CALLER) { + if (ap4->forward_max_SDU_size > + cv4->forward_max_SDU_size) + continue; + } else { + if (ap4->forward_max_SDU_size > + cv4->backward_max_SDU_size) + continue; + } + } + + /* + * Traffic Descriptor + */ + if ((ap->traffic.tag != T_ATM_PRESENT) || + (cvp->cvc_attr.traffic.tag != T_ATM_PRESENT) || + (ap->traffic.v.best_effort != T_YES) || + (cvp->cvc_attr.traffic.v.best_effort != T_YES)) + continue; + + /* + * Broadband Bearer + */ + if (ap->bearer.v.connection_configuration != + cvp->cvc_attr.bearer.v.connection_configuration) + continue; + + /* + * QOS + */ + if (cvp->cvc_flags & CVCF_CALLER) { + if ((ap->qos.v.forward.qos_class != + cvp->cvc_attr.qos.v.forward.qos_class) || + (ap->qos.v.backward.qos_class != + cvp->cvc_attr.qos.v.backward.qos_class)) + continue; + } else { + if ((ap->qos.v.forward.qos_class != + cvp->cvc_attr.qos.v.backward.qos_class) || + (ap->qos.v.backward.qos_class != + cvp->cvc_attr.qos.v.forward.qos_class)) + continue; + } + + /* + * The new LLC header must also be unique for this VCC + */ + for (cop = cvp->cvc_conn; cop; cop = cop->co_next) { + int i = MIN(ap->llc.v.llc_len, + cop->co_llc.v.llc_len); + + if (KM_CMP(ap->llc.v.llc_info, + cop->co_llc.v.llc_info, i) == 0) + break; + } + + /* + * If no header overlaps, then we're done + */ + if (cop == NULL) + break; + } + + return (cvp); +} + + +/* + * Close Connection + * + * This function will terminate a connection, including notifying the + * user, if necessary, and freeing up control block memory. The caller + * is responsible for managing the connection VCC. + * + * Called at splnet. + * + * Arguments: + * cop pointer to connection block + * cause pointer to cause of close + * + * Returns: + * none + * + */ +static void +atm_cm_closeconn(cop, cause) + Atm_connection *cop; + struct t_atm_cause *cause; +{ + + /* + * Decide whether user needs notification + */ + switch (cop->co_state) { + + case COS_OUTCONN: + case COS_LISTEN: + case COS_INCONN: + case COS_INACCEPT: + case COS_ACTIVE: + /* + * Yup, let 'em know connection is gone + */ + if (cop->co_toku) + (*cop->co_endpt->ep_cleared)(cop->co_toku, cause); + break; + + case COS_CLEAR: + /* + * Nope,they should know already + */ + break; + + default: + panic("atm_cm_closeconn: bogus state"); + } + + /* + * Unlink connection from its queues + */ + switch (cop->co_state) { + + case COS_LISTEN: + atm_free((caddr_t)cop->co_lattr); + UNLINK(cop, Atm_connection, atm_listen_queue, co_next); + break; + + default: + /* + * Remove connection from multiplexor queue + */ + if (cop->co_mxh != cop) { + /* + * Connection is down the chain, just unlink it + */ + UNLINK(cop, Atm_connection, cop->co_mxh, co_next); + + } else if (cop->co_next != NULL) { + /* + * Connection is at the head of a non-singleton chain, + * so unlink and reset the chain head + */ + Atm_connection *t, *nhd; + + t = nhd = cop->co_next; + while (t) { + t->co_mxh = nhd; + t = t->co_next; + } + if (nhd->co_connvc) + nhd->co_connvc->cvc_conn = nhd; + } + } + + /* + * Free the connection block + */ + cop->co_state = COS_FREE; + atm_free((caddr_t)cop); + + return; +} + + +/* + * Close Connection VCC + * + * This function will terminate a connection VCC, including releasing the + * the call to the signalling manager, terminating the VCC protocol stack, + * and freeing up control block memory. + * + * Called at splnet. + * + * Arguments: + * cvp pointer to connection VCC block + * + * Returns: + * none + * + */ +static void +atm_cm_closevc(cvp) + Atm_connvc *cvp; +{ + int err; + + /* + * Break links with the connection block + */ + cvp->cvc_conn = NULL; + + /* + * Cancel any running timer + */ + CVC_CANCEL(cvp); + + /* + * Free queued packets + */ + while (cvp->cvc_rcvq) { + KBuffer *m; + + m = cvp->cvc_rcvq; + cvp->cvc_rcvq = KB_QNEXT(m); + KB_QNEXT(m) = NULL; + KB_FREEALL(m); + } + + /* + * Unlink from any queues + */ + if (cvp->cvc_flags & CVCF_INCOMQ) { + DEQUEUE(cvp, Atm_connvc, cvc_q, atm_incoming_queue); + atm_incoming_qlen--; + cvp->cvc_flags &= ~CVCF_INCOMQ; + + } else if (cvp->cvc_flags & CVCF_CONNQ) { + DEQUEUE(cvp, Atm_connvc, cvc_q, atm_connection_queue); + cvp->cvc_flags &= ~CVCF_CONNQ; + } + + /* + * Release the signalling call + */ + switch (cvp->cvc_state) { + + case CVCS_SETUP: + case CVCS_INIT: + case CVCS_ACCEPT: + case CVCS_ACTIVE: + case CVCS_RELEASE: + if (cvp->cvc_vcc) { + cvp->cvc_state = CVCS_RELEASE; + switch ((*cvp->cvc_sigmgr->sm_release) + (cvp->cvc_vcc, &err)) { + + case CALL_CLEARED: + /* + * Looks good so far... + */ + break; + + case CALL_PROCEEDING: + /* + * We'll have to wait for the call to clear + */ + return; + + case CALL_FAILED: + /* + * If there's a memory shortage, retry later. + * Otherwise who knows what's going on.... + */ + if ((err == ENOMEM) || (err == ENOBUFS)) { + CVC_TIMER(cvp, 1 * ATM_HZ); + return; + } + log(LOG_ERR, + "atm_cm_closevc: release %d\n", err); + break; + } + } + break; + + case CVCS_INCOMING: + case CVCS_REJECT: + if (cvp->cvc_vcc) { + cvp->cvc_state = CVCS_REJECT; + switch ((*cvp->cvc_sigmgr->sm_reject) + (cvp->cvc_vcc, &err)) { + + case CALL_CLEARED: + /* + * Looks good so far... + */ + break; + + case CALL_FAILED: + /* + * If there's a memory shortage, retry later. + * Otherwise who knows what's going on.... + */ + if ((err == ENOMEM) || (err == ENOBUFS)) { + CVC_TIMER(cvp, 1 * ATM_HZ); + return; + } + log(LOG_ERR, + "atm_cm_closevc: reject %d\n", err); + break; + } + } + break; + + case CVCS_CLEAR: + case CVCS_TERM: + /* + * No need for anything here + */ + break; + + default: + panic("atm_cm_closevc: bogus state"); + } + + /* + * Now terminate the stack + */ + if (cvp->cvc_tokl) { + cvp->cvc_state = CVCS_TERM; + + /* + * Wait until stack is unwound before terminating + */ + if ((cvp->cvc_downcnt > 0) || (cvp->cvc_upcnt > 0)) { + CVC_TIMER(cvp, 0); + return; + } + + STACK_CALL(atm_stackcmds[cvp->cvc_attr.api].term, + cvp->cvc_lower, cvp->cvc_tokl, cvp, 0, 0, err); + + cvp->cvc_tokl = NULL; + } + + /* + * Let signalling manager finish up + */ + cvp->cvc_state = CVCS_FREE; + if (cvp->cvc_vcc) { + (void) (*cvp->cvc_sigmgr->sm_free)(cvp->cvc_vcc); + } + + /* + * Finally, free our own control blocks + */ + atm_free((caddr_t)cvp); + + return; +} + + +/* + * Process a Connection VCC timeout + * + * Called when a previously scheduled cvc control block timer expires. + * Processing will be based on the current cvc state. + * + * Called at splnet. + * + * Arguments: + * tip pointer to cvc timer control block + * + * Returns: + * none + * + */ +static void +atm_cm_timeout(tip) + struct atm_time *tip; +{ + Atm_connection *cop, *cop2; + Atm_connvc *cvp; + + /* + * Back-off to cvc control block + */ + cvp = (Atm_connvc *) + ((caddr_t)tip - (int)(&((Atm_connvc *)0)->cvc_time)); + + /* + * Process timeout based on protocol state + */ + switch (cvp->cvc_state) { + + case CVCS_SETUP: + case CVCS_ACCEPT: + case CVCS_ACTIVE: + /* + * Handle VCC abort + */ + if ((cvp->cvc_flags & CVCF_ABORTING) == 0) + goto logerr; + + /* + * Terminate all connections + */ + cop = cvp->cvc_conn; + while (cop) { + cop2 = cop->co_next; + atm_cm_closeconn(cop, &cvp->cvc_attr.cause.v); + cop = cop2; + } + + /* + * Terminate VCC + */ + atm_cm_closevc(cvp); + + break; + + case CVCS_REJECT: + case CVCS_RELEASE: + case CVCS_TERM: + /* + * Retry failed operation + */ + atm_cm_closevc(cvp); + break; + + default: +logerr: + log(LOG_ERR, + "atm_cm_timeout: invalid state: cvp=0x%x, state=%d\n", + (int)cvp, cvp->cvc_state); + } +} + + +/* + * CPCS User Control Commands + * + * This function is called by an endpoint user to pass a control command + * across a CPCS data API. Mostly we just send these down the stack. + * + * Arguments: + * cmd stack command code + * cop pointer to connection block + * arg argument + * + * Returns: + * 0 command output successful + * errno output failed - reason indicated + * + */ +int +atm_cm_cpcs_ctl(cmd, cop, arg) + int cmd; + Atm_connection *cop; + void *arg; +{ + Atm_connvc *cvp; + int err = 0; + + /* + * Validate connection state + */ + if (cop->co_state != COS_ACTIVE) { + err = EFAULT; + goto done; + } + + cvp = cop->co_connvc; + if (cvp->cvc_state != CVCS_ACTIVE) { + err = EFAULT; + goto done; + } + + if (cvp->cvc_attr.api != CMAPI_CPCS) { + err = EFAULT; + goto done; + } + + switch (cmd) { + + default: + err = EINVAL; + } + +done: + return (err); +} + + +/* + * CPCS Data Output + * + * This function is called by an endpoint user to output a data packet + * across a CPCS data API. After we've validated the connection state, the + * packet will be encapsulated (if necessary) and sent down the data stack. + * + * Arguments: + * cop pointer to connection block + * m pointer to packet buffer chain to be output + * + * Returns: + * 0 packet output successful + * errno output failed - reason indicated + * + */ +int +atm_cm_cpcs_data(cop, m) + Atm_connection *cop; + KBuffer *m; +{ + Atm_connvc *cvp; + struct attr_llc *llcp; + int err, space; + void *bp; + + + /* + * Validate connection state + */ + if (cop->co_state != COS_ACTIVE) { + err = EFAULT; + goto done; + } + + cvp = cop->co_connvc; + if (cvp->cvc_state != CVCS_ACTIVE) { + err = EFAULT; + goto done; + } + + if (cvp->cvc_attr.api != CMAPI_CPCS) { + err = EFAULT; + goto done; + } + + /* + * Add any packet encapsulation + */ + switch (cop->co_mpx) { + + case ATM_ENC_NULL: + /* + * None needed... + */ + break; + + case ATM_ENC_LLC: + /* + * Need to add an LLC header + */ + llcp = &cop->co_llc; + + /* + * See if there's room to add LLC header to front of packet. + */ + KB_HEADROOM(m, space); + if (space < llcp->v.llc_len) { + KBuffer *n; + + /* + * We have to allocate another buffer and tack it + * onto the front of the packet + */ + KB_ALLOCPKT(n, llcp->v.llc_len, KB_F_NOWAIT, + KB_T_HEADER); + if (n == 0) { + err = ENOMEM; + goto done; + } + KB_TAILALIGN(n, llcp->v.llc_len); + KB_LINKHEAD(n, m); + m = n; + } else { + /* + * Header fits, just adjust buffer controls + */ + KB_HEADADJ(m, llcp->v.llc_len); + } + + /* + * Add the LLC header + */ + KB_DATASTART(m, bp, void *); + KM_COPY(llcp->v.llc_info, bp, llcp->v.llc_len); + KB_PLENADJ(m, llcp->v.llc_len); + break; + + default: + panic("atm_cm_cpcs_data: mpx"); + } + + /* + * Finally, we can send the packet on its way + */ + STACK_CALL(CPCS_UNITDATA_INV, cvp->cvc_lower, cvp->cvc_tokl, + cvp, (int)m, 0, err); + +done: + return (err); +} + + +/* + * Process CPCS Stack Commands + * + * This is the top of the CPCS API data stack. All upward stack commands + * for the CPCS data API will be received and processed here. + * + * Arguments: + * cmd stack command code + * tok session token (pointer to connection VCC control block) + * arg1 argument 1 + * arg2 argument 2 + * + * Returns: + * none + * + */ +static void +atm_cm_cpcs_upper(cmd, tok, arg1, arg2) + int cmd; + void *tok; + int arg1; + int arg2; +{ + Atm_connection *cop; + Atm_connvc *cvp = tok; + KBuffer *m; + void *bp; + int s; + + switch (cmd) { + + case CPCS_UNITDATA_SIG: + /* + * Input data packet + */ + m = (KBuffer *)arg1; + + if (cvp->cvc_state != CVCS_ACTIVE) { + if (cvp->cvc_state == CVCS_ACCEPT) { + KBuffer *n; + + /* + * Queue up any packets received before sigmgr + * notifies us of incoming call completion + */ + if (cvp->cvc_rcvqlen >= CVC_RCVQ_MAX) { + KB_FREEALL(m); + atm_cm_stat.cms_rcvconnvc++; + return; + } + KB_QNEXT(m) = NULL; + if (cvp->cvc_rcvq == NULL) { + cvp->cvc_rcvq = m; + } else { + for (n = cvp->cvc_rcvq; + KB_QNEXT(n) != NULL; + n = KB_QNEXT(n)) + ; + KB_QNEXT(n) = m; + } + cvp->cvc_rcvqlen++; + return; + } else { + KB_FREEALL(m); + atm_cm_stat.cms_rcvconnvc++; + return; + } + } + + /* + * Locate packet's connection + */ + cop = cvp->cvc_conn; + switch (cop->co_mpx) { + + case ATM_ENC_NULL: + /* + * We're already there... + */ + break; + + case ATM_ENC_LLC: + /* + * Find connection with matching LLC header + */ + if (KB_LEN(m) < T_ATM_LLC_MAX_LEN) { + KB_PULLUP(m, T_ATM_LLC_MAX_LEN, m); + if (m == 0) { + atm_cm_stat.cms_llcdrop++; + return; + } + } + KB_DATASTART(m, bp, void *); + + s = splnet(); + + while (cop) { + if (KM_CMP(bp, cop->co_llc.v.llc_info, + cop->co_llc.v.llc_len) == 0) + break; + cop = cop->co_next; + } + + (void) splx(s); + + if (cop == NULL) { + /* + * No connected user for this LLC + */ + KB_FREEALL(m); + atm_cm_stat.cms_llcid++; + return; + } + + /* + * Strip off the LLC header + */ + KB_HEADADJ(m, -cop->co_llc.v.llc_len); + KB_PLENADJ(m, -cop->co_llc.v.llc_len); + break; + + default: + panic("atm_cm_cpcs_upper: mpx"); + } + + /* + * We've found our connection, so hand the packet off + */ + if (cop->co_state != COS_ACTIVE) { + KB_FREEALL(m); + atm_cm_stat.cms_rcvconn++; + return; + } + (*cop->co_endpt->ep_cpcs_data)(cop->co_toku, m); + break; + + case CPCS_UABORT_SIG: + case CPCS_PABORT_SIG: + /* + * We don't support these (yet), so just fall thru... + */ + + default: + log(LOG_ERR, "atm_cm_cpcs_upper: unknown cmd 0x%x\n", cmd); + } +} + + +/* + * SAAL User Control Commands + * + * This function is called by an endpoint user to pass a control command + * across a SAAL data API. Mostly we just send these down the stack. + * + * Arguments: + * cmd stack command code + * cop pointer to connection block + * arg argument + * + * Returns: + * 0 command output successful + * errno output failed - reason indicated + * + */ +int +atm_cm_saal_ctl(cmd, cop, arg) + int cmd; + Atm_connection *cop; + void *arg; +{ + Atm_connvc *cvp; + int err = 0; + + /* + * Validate connection state + */ + if (cop->co_state != COS_ACTIVE) { + err = EFAULT; + goto done; + } + + cvp = cop->co_connvc; + if (cvp->cvc_state != CVCS_ACTIVE) { + err = EFAULT; + goto done; + } + + if (cvp->cvc_attr.api != CMAPI_SAAL) { + err = EFAULT; + goto done; + } + + switch (cmd) { + + case SSCF_UNI_ESTABLISH_REQ: + case SSCF_UNI_RELEASE_REQ: + /* + * Pass command down the stack + */ + STACK_CALL(cmd, cvp->cvc_lower, cvp->cvc_tokl, cvp, + (int)arg, 0, err); + break; + + default: + err = EINVAL; + } + +done: + return (err); +} + + +/* + * SAAL Data Output + * + * This function is called by an endpoint user to output a data packet + * across a SAAL data API. After we've validated the connection state, + * the packet will be sent down the data stack. + * + * Arguments: + * cop pointer to connection block + * m pointer to packet buffer chain to be output + * + * Returns: + * 0 packet output successful + * errno output failed - reason indicated + * + */ +int +atm_cm_saal_data(cop, m) + Atm_connection *cop; + KBuffer *m; +{ + Atm_connvc *cvp; + int err; + + + /* + * Validate connection state + */ + if (cop->co_state != COS_ACTIVE) { + err = EFAULT; + goto done; + } + + cvp = cop->co_connvc; + if (cvp->cvc_state != CVCS_ACTIVE) { + err = EFAULT; + goto done; + } + + if (cvp->cvc_attr.api != CMAPI_SAAL) { + err = EFAULT; + goto done; + } + + /* + * Finally, we can send the packet on its way + */ + STACK_CALL(SSCF_UNI_DATA_REQ, cvp->cvc_lower, cvp->cvc_tokl, + cvp, (int)m, 0, err); + +done: + return (err); +} + + +/* + * Process SAAL Stack Commands + * + * This is the top of the SAAL API data stack. All upward stack commands + * for the SAAL data API will be received and processed here. + * + * Arguments: + * cmd stack command code + * tok session token (pointer to connection VCC control block) + * arg1 argument 1 + * arg2 argument 2 + * + * Returns: + * none + * + */ +static void +atm_cm_saal_upper(cmd, tok, arg1, arg2) + int cmd; + void *tok; + int arg1; + int arg2; +{ + Atm_connection *cop; + Atm_connvc *cvp = tok; + + + switch (cmd) { + + case SSCF_UNI_ESTABLISH_IND: + case SSCF_UNI_ESTABLISH_CNF: + case SSCF_UNI_RELEASE_IND: + case SSCF_UNI_RELEASE_CNF: + /* + * Control commands + */ + cop = cvp->cvc_conn; + if (cvp->cvc_state != CVCS_ACTIVE) + break; + if (cop->co_state != COS_ACTIVE) + break; + + (*cop->co_endpt->ep_saal_ctl)(cmd, cop->co_toku, (void *)arg1); + break; + + case SSCF_UNI_DATA_IND: + /* + * User data + */ + cop = cvp->cvc_conn; + if (cvp->cvc_state != CVCS_ACTIVE) { + atm_cm_stat.cms_rcvconnvc++; + KB_FREEALL((KBuffer *)arg1); + break; + } + if (cop->co_state != COS_ACTIVE) { + atm_cm_stat.cms_rcvconn++; + KB_FREEALL((KBuffer *)arg1); + break; + } + + (*cop->co_endpt->ep_saal_data)(cop->co_toku, (KBuffer *)arg1); + break; + + case SSCF_UNI_UNITDATA_IND: + /* + * Not supported + */ + KB_FREEALL((KBuffer *)arg1); + + /* FALLTHRU */ + + default: + log(LOG_ERR, "atm_cm_saal_upper: unknown cmd 0x%x\n", cmd); + } +} + + +/* + * SSCOP User Control Commands + * + * This function is called by an endpoint user to pass a control command + * across a SSCOP data API. Mostly we just send these down the stack. + * + * Arguments: + * cmd stack command code + * cop pointer to connection block + * arg1 argument + * arg2 argument + * + * Returns: + * 0 command output successful + * errno output failed - reason indicated + * + */ +int +atm_cm_sscop_ctl(cmd, cop, arg1, arg2) + int cmd; + Atm_connection *cop; + void *arg1; + void *arg2; +{ + Atm_connvc *cvp; + int err = 0; + + /* + * Validate connection state + */ + if (cop->co_state != COS_ACTIVE) { + err = EFAULT; + goto done; + } + + cvp = cop->co_connvc; + if (cvp->cvc_state != CVCS_ACTIVE) { + err = EFAULT; + goto done; + } + + if (cvp->cvc_attr.api != CMAPI_SSCOP) { + err = EFAULT; + goto done; + } + + switch (cmd) { + + case SSCOP_ESTABLISH_REQ: + case SSCOP_ESTABLISH_RSP: + case SSCOP_RELEASE_REQ: + case SSCOP_RESYNC_REQ: + case SSCOP_RESYNC_RSP: + case SSCOP_RECOVER_RSP: + case SSCOP_RETRIEVE_REQ: + /* + * Pass command down the stack + */ + STACK_CALL(cmd, cvp->cvc_lower, cvp->cvc_tokl, cvp, + (int)arg1, (int)arg2, err); + break; + + default: + err = EINVAL; + } + +done: + return (err); +} + + +/* + * SSCOP Data Output + * + * This function is called by an endpoint user to output a data packet + * across a SSCOP data API. After we've validated the connection state, + * the packet will be encapsulated and sent down the data stack. + * + * Arguments: + * cop pointer to connection block + * m pointer to packet buffer chain to be output + * + * Returns: + * 0 packet output successful + * errno output failed - reason indicated + * + */ +int +atm_cm_sscop_data(cop, m) + Atm_connection *cop; + KBuffer *m; +{ + Atm_connvc *cvp; + int err; + + + /* + * Validate connection state + */ + if (cop->co_state != COS_ACTIVE) { + err = EFAULT; + goto done; + } + + cvp = cop->co_connvc; + if (cvp->cvc_state != CVCS_ACTIVE) { + err = EFAULT; + goto done; + } + + if (cvp->cvc_attr.api != CMAPI_SSCOP) { + err = EFAULT; + goto done; + } + + /* + * Finally, we can send the packet on its way + */ + STACK_CALL(SSCOP_DATA_REQ, cvp->cvc_lower, cvp->cvc_tokl, + cvp, (int)m, 0, err); + +done: + return (err); +} + + +/* + * Process SSCOP Stack Commands + * + * This is the top of the SSCOP API data stack. All upward stack commands + * for the SSCOP data API will be received and processed here. + * + * Arguments: + * cmd stack command code + * tok session token (pointer to connection VCC control block) + * arg1 argument 1 + * arg2 argument 2 + * + * Returns: + * none + * + */ +static void +atm_cm_sscop_upper(cmd, tok, arg1, arg2) + int cmd; + void *tok; + int arg1; + int arg2; +{ + Atm_connection *cop; + Atm_connvc *cvp = tok; + + switch (cmd) { + + case SSCOP_ESTABLISH_IND: + case SSCOP_ESTABLISH_CNF: + case SSCOP_RELEASE_IND: + case SSCOP_RESYNC_IND: + /* + * Control commands + */ + cop = cvp->cvc_conn; + if ((cvp->cvc_state != CVCS_ACTIVE) || + (cop->co_state != COS_ACTIVE)) { + KB_FREEALL((KBuffer *)arg1); + break; + } + + (*cop->co_endpt->ep_sscop_ctl) + (cmd, cop->co_toku, (void *)arg1, (void *)arg2); + break; + + case SSCOP_RELEASE_CNF: + case SSCOP_RESYNC_CNF: + case SSCOP_RECOVER_IND: + case SSCOP_RETRIEVE_IND: + case SSCOP_RETRIEVECMP_IND: + /* + * Control commands + */ + cop = cvp->cvc_conn; + if ((cvp->cvc_state != CVCS_ACTIVE) || + (cop->co_state != COS_ACTIVE)) + break; + + (*cop->co_endpt->ep_sscop_ctl) + (cmd, cop->co_toku, (void *)arg1, (void *)arg2); + break; + + case SSCOP_DATA_IND: + /* + * User data + */ + cop = cvp->cvc_conn; + if (cvp->cvc_state != CVCS_ACTIVE) { + atm_cm_stat.cms_rcvconnvc++; + KB_FREEALL((KBuffer *)arg1); + break; + } + if (cop->co_state != COS_ACTIVE) { + atm_cm_stat.cms_rcvconn++; + KB_FREEALL((KBuffer *)arg1); + break; + } + + (*cop->co_endpt->ep_sscop_data) + (cop->co_toku, (KBuffer *)arg1, arg2); + break; + + case SSCOP_UNITDATA_IND: + /* + * Not supported + */ + KB_FREEALL((KBuffer *)arg1); + + /* FALLTHRU */ + + default: + log(LOG_ERR, "atm_cm_sscop_upper: unknown cmd 0x%x\n", cmd); + } +} + + +/* + * Register an ATM Endpoint Service + * + * Every ATM endpoint service must register itself here before it can + * issue or receive any connection requests. + * + * Arguments: + * epp pointer to endpoint definition structure + * + * Returns: + * 0 registration successful + * errno registration failed - reason indicated + * + */ +int +atm_endpoint_register(epp) + Atm_endpoint *epp; +{ + int s = splnet(); + + /* + * See if we need to be initialized + */ + if (!atm_init) + atm_initialize(); + + /* + * Validate endpoint + */ + if (epp->ep_id > ENDPT_MAX) { + (void) splx(s); + return (EINVAL); + } + if (atm_endpoints[epp->ep_id] != NULL) { + (void) splx(s); + return (EEXIST); + } + + /* + * Add endpoint to list + */ + atm_endpoints[epp->ep_id] = epp; + + (void) splx(s); + return (0); +} + + +/* + * De-register an ATM Endpoint Service + * + * Each ATM endpoint service provider must de-register its registered + * endpoint(s) before terminating. Specifically, loaded kernel modules + * must de-register their services before unloading themselves. + * + * Arguments: + * epp pointer to endpoint definition structure + * + * Returns: + * 0 de-registration successful + * errno de-registration failed - reason indicated + * + */ +int +atm_endpoint_deregister(epp) + Atm_endpoint *epp; +{ + int s = splnet(); + + /* + * Validate endpoint + */ + if (epp->ep_id > ENDPT_MAX) { + (void) splx(s); + return (EINVAL); + } + if (atm_endpoints[epp->ep_id] != epp) { + (void) splx(s); + return (ENOENT); + } + + /* + * Remove endpoint from list + */ + atm_endpoints[epp->ep_id] = NULL; + + (void) splx(s); + return (0); +} + diff --git a/sys/netatm/atm_cm.h b/sys/netatm/atm_cm.h new file mode 100644 index 0000000..9e000ab --- /dev/null +++ b/sys/netatm/atm_cm.h @@ -0,0 +1,348 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_cm.h,v 1.3 1998/03/24 20:41:40 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM Connection Management definitions + * + */ + +#ifndef _NETATM_ATM_CM_H +#define _NETATM_ATM_CM_H + +/* + * Forward declaration + */ +struct atm_connection; +struct atm_attributes; + + +#ifdef ATM_KERNEL +/* + * Structure used to define a kernel ATM endpoint service module and its + * associated entry points. An endpoint service is defined as a kernel + * entity which will serve as the endpoint of an ATM connection, i.e. it is + * responsible for issuing/receiving requests to/from the connection manager. + */ +struct atm_endpoint { + struct atm_endpoint *ep_next; /* Next in registry list */ + u_int ep_id; /* Endpoint ID (see below) */ + +/* Exported functions: Miscellaneous */ + int (*ep_ioctl) /* Ioctl */ + __P((int, caddr_t, caddr_t)); + caddr_t (*ep_getname) /* Get application/owner name */ + __P((void *)); + +/* Exported functions: Connection Manager Control API */ + void (*ep_connected) /* Call connected */ + __P((void *)); + void (*ep_cleared) /* Call cleared */ + __P((void *, struct t_atm_cause *)); + int (*ep_incoming) /* Incoming call */ + __P((void *, struct atm_connection *, + struct atm_attributes *, void **)); + int (*ep_addparty) /* Add Party notification */ + __P((void *, int, int)); + int (*ep_dropparty) /* Drop Party notification */ + __P((void *, int, int)); + +/* Exported functions: Connection Manager Data API: CPCS */ + void (*ep_cpcs_ctl) /* Control operation */ + __P((int, void *, void *)); + void (*ep_cpcs_data) /* Received data */ + __P((void *, KBuffer *)); + +/* Exported functions: Connection Manager Data API: SAAL */ + void (*ep_saal_ctl) /* Control operation */ + __P((int, void *, void *)); + void (*ep_saal_data) /* Received data */ + __P((void *, KBuffer *)); + +/* Exported functions: Connection Manager Data API: SSCOP */ + void (*ep_sscop_ctl) /* Control operation */ + __P((int, void *, void *, void *)); + void (*ep_sscop_data) /* Received data */ + __P((void *, KBuffer *, u_int)); +}; +typedef struct atm_endpoint Atm_endpoint; +#endif /* ATM_KERNEL */ + +/* + * Endpoint IDs + */ +#define ENDPT_UNKNOWN 0 /* Unknown */ +#define ENDPT_IP 1 /* IP over ATM */ +#define ENDPT_ATMARP 2 /* ATMARP */ +#define ENDPT_SPANS_SIG 3 /* SPANS Signalling */ +#define ENDPT_SPANS_CLS 4 /* SPANS CLS */ +#define ENDPT_UNI_SIG 5 /* UNI Signalling */ +#define ENDPT_SOCK_AAL5 6 /* Socket - AAL5 */ +#define ENDPT_SOCK_SSCOP 7 /* Socket - SSCOP */ +#define ENDPT_MAX 7 + + +/* + * ATM Connection Attributes + * + * Note: Attribute tag values are the same as the SVE_tag values. + * Unless otherwise specified, attribute field values are the same + * as the corresponding socket option values. + * The above values are all defined in netatm/atm.h. + */ + +/* AAL Attributes */ +struct t_atm_aal4 { + int32_t forward_max_SDU_size; + int32_t backward_max_SDU_size; + int32_t SSCS_type; + int32_t mid_low; + int32_t mid_high; +}; + +struct attr_aal { + int tag; /* Attribute tag */ + Aal_t type; /* AAL type (discriminator) */ + union { + struct t_atm_aal4 aal4; + struct t_atm_aal5 aal5; + } v; /* Attribute value */ +}; + +/* Traffic Descriptor Attributes */ +struct attr_traffic { + int tag; /* Attribute tag */ + struct t_atm_traffic v; /* Attribute value */ +}; + +/* Broadband Bearer Attributes */ +struct attr_bearer { + int tag; /* Attribute tag */ + struct t_atm_bearer v; /* Attribute value */ +}; + +/* Broadband High Layer Information Attributes */ +struct attr_bhli { + int tag; /* Attribute tag */ + struct t_atm_bhli v; /* Attribute value */ +}; + +/* Broadband Low Layer Information Attributes */ +struct attr_blli { + int tag_l2; /* Layer 2 attribute tag */ + int tag_l3; /* Layer 3 attribute tag */ + struct t_atm_blli v; /* Attribute value */ +}; + +/* Logical Link Control Attributes (multiplexing use only, not signalled) */ +struct attr_llc { + int tag; /* Attribute tag */ + struct t_atm_llc v; /* Attribute value */ +}; + +/* Called Party Attributes */ +struct attr_called { + int tag; /* Attribute tag */ + Atm_addr addr; /* Called party address */ + Atm_addr subaddr; /* Called party subaddress */ +}; + +/* Calling Party Attributes */ +struct attr_calling { + int tag; /* Attribute tag */ + Atm_addr addr; /* Calling party address */ + Atm_addr subaddr; /* Calling party subaddress */ + struct t_atm_caller_id cid; /* Caller ID */ +}; + +/* Quality of Service Attributes */ +struct attr_qos { + int tag; /* Attribute tag */ + struct t_atm_qos v; /* Attribute value */ +}; + +/* Transit Network Attributes */ +struct attr_transit { + int tag; /* Attribute tag */ + struct t_atm_transit v; /* Attribute value */ +}; + +/* Cause Attributes */ +struct attr_cause { + int tag; /* Attribute tag */ + struct t_atm_cause v; /* Attribute value */ +}; + + +struct atm_attributes { + struct atm_nif *nif; /* Network interface */ + u_int api; /* Connect Mgr Data API (see below) */ + int api_init;/* API initialization parameter */ + u_short headin; /* Input buffer headroom */ + u_short headout;/* Output buffer headroom */ + struct attr_aal aal; /* AAL attributes */ + struct attr_traffic traffic;/* Traffic descriptor attributes */ + struct attr_bearer bearer; /* Broadband bearer attributes */ + struct attr_bhli bhli; /* Broadband high layer attributes */ + struct attr_blli blli; /* Broadband low layer attributes */ + struct attr_llc llc; /* Logical link control attributes */ + struct attr_called called; /* Called party attributes */ + struct attr_calling calling;/* Calling party attributes */ + struct attr_qos qos; /* Quality of service attributes */ + struct attr_transit transit;/* Transit network attributes */ + struct attr_cause cause; /* Cause attributes */ +}; +typedef struct atm_attributes Atm_attributes; + +/* + * Connection Manager Data APIs + */ +#define CMAPI_CPCS 0 /* AAL CPCS */ +#define CMAPI_SAAL 1 /* Signalling AAL */ +#define CMAPI_SSCOP 2 /* Reliable data (SSCOP) */ + + +#ifdef ATM_KERNEL +/* + * ATM Connection Instance + * + * There will be one connection block for each endpoint <-> Connection Manager + * API instance. Note that with connection multiplexors (e.g. LLC), there + * may be multiple connections per VCC. + */ +struct atm_connection { + struct atm_connection *co_next; /* Multiplexor/listen queue link */ + struct atm_connection *co_mxh; /* Connection multiplexor head */ + u_char co_flags; /* Connection flags (see below) */ + u_char co_state; /* User <-> CM state (see below) */ + Encaps_t co_mpx; /* Multiplexor type */ + void *co_toku; /* Endpoint's session token */ + Atm_endpoint *co_endpt; /* Endpoint service */ + struct atm_connvc *co_connvc; /* Connection VCC */ + struct attr_llc co_llc; /* Connection LLC header */ + Atm_attributes *co_lattr; /* Listening attributes */ +}; +typedef struct atm_connection Atm_connection; + +/* + * Connection Flags + */ +#define COF_P2P 0x01 /* Point-to-point */ +#define COF_P2MP 0x02 /* Point-to-multipoint */ + +/* + * Endpoint <-> Connection Manager States + */ +#define COS_FREE 0 /* Not allocated */ +#define COS_OUTCONN 1 /* Outgoing connection pending */ +#define COS_LISTEN 2 /* Listening for connection */ +#define COS_INCONN 3 /* Incoming connection pending */ +#define COS_INACCEPT 4 /* Incoming connection accepted */ +#define COS_ACTIVE 5 /* Connection active */ +#define COS_CLEAR 6 /* Connection is clearing */ + + +/* + * ATM Connection VCC Instance + * + * There will be one connection-vcc block for each VCC created by the + * Connection Manager. For multiplexed connections, there may be multiple + * connection blocks associated with each connection-vcc. This block is + * used to control the Connection Manager <-> VCC interface, including the + * interfaces to stack management and the signalling manager. + */ +struct atm_connvc { + Qelem_t cvc_q; /* Queueing links */ + Atm_connection *cvc_conn; /* Connection head */ + struct vccb *cvc_vcc; /* VCC for connection */ + struct sigmgr *cvc_sigmgr; /* VCC signalling manager */ + u_char cvc_flags; /* Connection flags (see below) */ + u_char cvc_state; /* CM - VCC state (see below) */ + void *cvc_tokl; /* Stack lower layer token */ + void (*cvc_lower) /* Stack lower layer handler */ + __P((int, void *, int, int)); + u_short cvc_upcnt; /* Up stack calls in progress */ + u_short cvc_downcnt; /* Down stack calls in progress */ + KBuffer *cvc_rcvq; /* Packet receive queue */ + int cvc_rcvqlen; /* Receive queue length */ + Atm_attributes cvc_attr; /* VCC attributes */ + struct atm_time cvc_time; /* Timer controls */ +}; +typedef struct atm_connvc Atm_connvc; + +/* + * Connection Flags + */ +#define CVCF_ABORTING 0x01 /* VCC abort is pending */ +#define CVCF_INCOMQ 0x02 /* VCC is on incoming queue */ +#define CVCF_CONNQ 0x04 /* VCC is on connection queue */ +#define CVCF_CALLER 0x08 /* We are the call originator */ + +/* + * Connection Manager <-> VCC States + */ +#define CVCS_FREE 0 /* Not allocated */ +#define CVCS_SETUP 1 /* Call setup pending */ +#define CVCS_INIT 2 /* Stack INIT pending */ +#define CVCS_INCOMING 3 /* Incoming call present */ +#define CVCS_ACCEPT 4 /* Incoming call accepted */ +#define CVCS_REJECT 5 /* Incoming call rejected */ +#define CVCS_ACTIVE 6 /* Stack active */ +#define CVCS_RELEASE 7 /* Connection release pending */ +#define CVCS_CLEAR 8 /* Call has been cleared */ +#define CVCS_TERM 9 /* Stack TERM pending */ + + +/* + * Connection VCC variables + */ +#define CVC_RCVQ_MAX 3 /* Max length of receive queue */ + + +/* + * Timer macros + */ +#define CVC_TIMER(s, t) atm_timeout(&(s)->cvc_time, (t), atm_cm_timeout) +#define CVC_CANCEL(s) atm_untimeout(&(s)->cvc_time) + + +/* + * Connection Manager Statistics + */ +struct atm_cm_stat { + u_long cms_llcdrop; /* Packets dropped by llc demux'ing */ + u_long cms_llcid; /* Packets with unknown llc id */ + u_long cms_rcvconn; /* Packets dropped, bad conn state */ + u_long cms_rcvconnvc; /* Packets dropped, bad connvc state */ +}; +#endif /* ATM_KERNEL */ + +#endif /* _NETATM_ATM_CM_H */ diff --git a/sys/netatm/atm_device.c b/sys/netatm/atm_device.c new file mode 100644 index 0000000..7f26695 --- /dev/null +++ b/sys/netatm/atm_device.c @@ -0,0 +1,883 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_device.c,v 1.7 1998/03/24 20:42:39 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM device support functions + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: atm_device.c,v 1.7 1998/03/24 20:42:39 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + + +/* + * Private structures for managing allocated kernel memory resources + * + * For each allocation of kernel memory, one Mem_ent will be used. + * The Mem_ent structures will be allocated in blocks inside of a + * Mem_blk structure. + */ +#define MEM_NMEMENT 10 /* How many Mem_ent's in a Mem_blk */ + +struct mem_ent { + void *me_kaddr; /* Allocated memory address */ + u_int me_ksize; /* Allocated memory length */ + void *me_uaddr; /* Memory address returned to caller */ + u_int me_flags; /* Flags (see below) */ +}; +typedef struct mem_ent Mem_ent; + +/* + * Memory entry flags + */ +#define MEF_NONCACHE 1 /* Memory is noncacheable */ + + +struct mem_blk { + struct mem_blk *mb_next; /* Next block in chain */ + Mem_ent mb_mement[MEM_NMEMENT]; /* Allocated memory entries */ +}; +typedef struct mem_blk Mem_blk; + +static Mem_blk *atm_mem_head = NULL; + +static struct t_atm_cause atm_dev_cause = { + T_ATM_ITU_CODING, + T_ATM_LOC_USER, + T_ATM_CAUSE_VPCI_VCI_ASSIGNMENT_FAILURE, + {0, 0, 0, 0} +}; + + +/* + * ATM Device Stack Instantiation + * + * Called at splnet. + * + * Arguments + * ssp pointer to array of stack definition pointers + * for connection + * ssp[0] points to upper layer's stack definition + * ssp[1] points to this layer's stack definition + * ssp[2] points to lower layer's stack definition + * cvcp pointer to connection vcc for this stack + * + * Returns + * 0 instantiation successful + * err instantiation failed - reason indicated + * + */ +int +atm_dev_inst(ssp, cvcp) + struct stack_defn **ssp; + Atm_connvc *cvcp; +{ + Cmn_unit *cup = (Cmn_unit *)cvcp->cvc_attr.nif->nif_pif; + Cmn_vcc *cvp; + int err; + + /* + * Check to see if device has been initialized + */ + if ((cup->cu_flags & CUF_INITED) == 0) + return ( EIO ); + + /* + * Validate lower SAP + */ + /* + * Device driver is the lowest layer - no need to validate + */ + + /* + * Validate PVC vpi.vci + */ + if (cvcp->cvc_attr.called.addr.address_format == T_ATM_PVC_ADDR) { + /* + * Look through existing circuits - return error if found + */ + Atm_addr_pvc *pp; + + pp = (Atm_addr_pvc *)cvcp->cvc_attr.called.addr.address; + if (atm_dev_vcc_find(cup, ATM_PVC_GET_VPI(pp), + ATM_PVC_GET_VCI(pp), 0)) + return ( EADDRINUSE ); + } + + /* + * Validate our SAP type + */ + switch ((*(ssp+1))->sd_sap) { + case SAP_CPCS_AAL3_4: + case SAP_CPCS_AAL5: + case SAP_ATM: + break; + default: + return (EINVAL); + } + + /* + * Allocate a VCC control block + */ + if ( ( cvp = (Cmn_vcc *)atm_allocate(cup->cu_vcc_pool) ) == NULL ) + return ( ENOMEM ); + + cvp->cv_state = CVS_INST; + cvp->cv_toku = (*ssp)->sd_toku; + cvp->cv_upper = (*ssp)->sd_upper; + cvp->cv_connvc = cvcp; + + /* + * Let device have a look at the connection request + */ + err = (*cup->cu_instvcc)(cup, cvp); + if (err) { + atm_free((caddr_t)cvp); + return (err); + } + + /* + * Looks good so far, so link in device VCC + */ + LINK2TAIL ( cvp, Cmn_vcc, cup->cu_vcc, cv_next ); + + /* + * Save my token + */ + (*++ssp)->sd_toku = cvp; + + /* + * Pass instantiation down the stack + */ + /* + * No need - we're the lowest point. + */ + /* err = (*(ssp + 1))->sd_inst(ssp, cvcp); */ + + /* + * Save the lower layer's interface info + */ + /* + * No need - we're the lowest point + */ + /* cvp->cv_lower = (*++ssp)->sd_lower; */ + /* cvp->cv_tok1 = (*ssp)->sd_toku; */ + + return (0); +} + + +/* + * ATM Device Stack Command Handler + * + * Arguments + * cmd stack command code + * tok session token (Cmn_vcc) + * arg1 command specific argument + * arg2 command specific argument + * + * Returns + * none + * + */ +/*ARGSUSED*/ +void +atm_dev_lower(cmd, tok, arg1, arg2) + int cmd; + void *tok; + int arg1; + int arg2; +{ + Cmn_vcc *cvp = (Cmn_vcc *)tok; + Atm_connvc *cvcp = cvp->cv_connvc; + Cmn_unit *cup = (Cmn_unit *)cvcp->cvc_attr.nif->nif_pif; + struct vccb *vcp; + u_int state; + int s; + + switch ( cmd ) { + + case CPCS_INIT: + /* + * Sanity check + */ + if ( cvp->cv_state != CVS_INST ) { + log ( LOG_ERR, + "atm_dev_lower: INIT: tok=0x%x, state=%d\n", + (int)tok, cvp->cv_state ); + break; + } + + vcp = cvp->cv_connvc->cvc_vcc; + + /* + * Validate SVC vpi.vci + */ + if ( vcp->vc_type & VCC_SVC ) { + + if (atm_dev_vcc_find(cup, vcp->vc_vpi, vcp->vc_vci, + vcp->vc_type & (VCC_IN | VCC_OUT)) + != cvp){ + log ( LOG_ERR, + "atm_dev_lower: dup SVC (%d,%d) tok=0x%x\n", + vcp->vc_vpi, vcp->vc_vci, (int)tok ); + atm_cm_abort(cvp->cv_connvc, &atm_dev_cause); + break; + } + } + + /* + * Tell the device to open the VCC + */ + cvp->cv_state = CVS_INITED; + s = splimp(); + if ((*cup->cu_openvcc)(cup, cvp)) { + atm_cm_abort(cvp->cv_connvc, &atm_dev_cause); + (void) splx(s); + break; + } + (void) splx(s); + break; + + case CPCS_TERM: { + KBuffer *m, *prev, *next; + int *ip; + + s = splimp(); + + /* + * Disconnect the VCC - ignore return code + */ + if ((cvp->cv_state == CVS_INITED) || + (cvp->cv_state == CVS_ACTIVE)) { + (void) (*cup->cu_closevcc)(cup, cvp); + } + cvp->cv_state = CVS_TERM; + + /* + * Remove from interface list + */ + UNLINK ( cvp, Cmn_vcc, cup->cu_vcc, cv_next ); + + /* + * Free any buffers from this VCC on the ATM interrupt queue + */ + prev = NULL; + for (m = atm_intrq.ifq_head; m; m = next) { + next = KB_QNEXT(m); + + /* + * See if this entry is for the terminating VCC + */ + KB_DATASTART(m, ip, int *); + ip++; + if (*ip == (int)cvp) { + /* + * Yep, so dequeue the entry + */ + if (prev == NULL) + atm_intrq.ifq_head = next; + else + KB_QNEXT(prev) = next; + + if (next == NULL) + atm_intrq.ifq_tail = prev; + + atm_intrq.ifq_len--; + + /* + * Free the unwanted buffers + */ + KB_FREEALL(m); + } else { + prev = m; + } + } + (void) splx(s); + + /* + * Free VCC resources + */ + (void) atm_free((caddr_t)cvp); + break; + } + + case CPCS_UNITDATA_INV: + + /* + * Sanity check + * + * Use temp state variable since we dont want to lock out + * interrupts, but initial VC activation interrupt may + * happen here, changing state somewhere in the middle. + */ + state = cvp->cv_state; + if ((state != CVS_ACTIVE) && + (state != CVS_INITED)) { + log ( LOG_ERR, + "atm_dev_lower: UNITDATA: tok=0x%x, state=%d\n", + (int)tok, state ); + KB_FREEALL((KBuffer *)arg1); + break; + } + + /* + * Hand the data off to the device + */ + (*cup->cu_output)(cup, cvp, (KBuffer *)arg1); + + break; + + case CPCS_UABORT_INV: + log ( LOG_ERR, + "atm_dev_lower: unimplemented stack cmd 0x%x, tok=0x%x\n", + cmd, (int)tok ); + break; + + default: + log ( LOG_ERR, + "atm_dev_lower: unknown stack cmd 0x%x, tok=0x%x\n", + cmd, (int)tok ); + + } + + return; +} + + + +/* + * Allocate kernel memory block + * + * This function will allocate a kernel memory block of the type specified + * in the flags parameter. The returned address will point to a memory + * block of the requested size and alignment. The memory block will also + * be zeroed. The alloc/free functions will manage/mask both the OS-specific + * kernel memory management requirements and the bookkeeping required to + * deal with data alignment issues. + * + * This function should not be called from interrupt level. + * + * Arguments: + * size size of memory block to allocate + * align data alignment requirement + * flags allocation flags (ATM_DEV_*) + * + * Returns: + * uaddr pointer to aligned memory block + * NULL unable to allocate memory + * + */ +void * +atm_dev_alloc(size, align, flags) + u_int size; + u_int align; + u_int flags; +{ + Mem_blk *mbp; + Mem_ent *mep; + u_int kalign, ksize; + int s, i; + + s = splimp(); + + /* + * Find a free Mem_ent + */ + mep = NULL; + for (mbp = atm_mem_head; mbp && mep == NULL; mbp = mbp->mb_next) { + for (i = 0; i < MEM_NMEMENT; i++) { + if (mbp->mb_mement[i].me_uaddr == NULL) { + mep = &mbp->mb_mement[i]; + break; + } + } + } + + /* + * If there are no free Mem_ent's, then allocate a new Mem_blk + * and link it into the chain + */ + if (mep == NULL) { + mbp = (Mem_blk *) KM_ALLOC(sizeof(Mem_blk), M_DEVBUF, M_NOWAIT); + if (mbp == NULL) { + log(LOG_ERR, "atm_dev_alloc: Mem_blk failure\n"); + (void) splx(s); + return (NULL); + } + KM_ZERO(mbp, sizeof(Mem_blk)); + + mbp->mb_next = atm_mem_head; + atm_mem_head = mbp; + mep = mbp->mb_mement; + } + + /* + * Now we need to get the kernel's allocation alignment minimum + * + * This is obviously very OS-specific stuff + */ +#ifdef sun + if (flags & ATM_DEV_NONCACHE) { + /* Byte-aligned */ + kalign = sizeof(long); + } else { + /* Doubleword-aligned */ + kalign = sizeof(double); + } +#elif (defined(BSD) && (BSD >= 199103)) + kalign = MINALLOCSIZE; +#else + #error Unsupported/unconfigured OS +#endif + + /* + * Figure out how much memory we must allocate to satify the + * user's size and alignment needs + */ + if (align <= kalign) + ksize = size; + else + ksize = size + align - kalign; + + /* + * Finally, go get the memory + */ + if (flags & ATM_DEV_NONCACHE) { +#ifdef sun + mep->me_kaddr = IOPBALLOC(ksize); +#elif defined(__i386__) + mep->me_kaddr = KM_ALLOC(ksize, M_DEVBUF, M_NOWAIT); +#else + #error Unsupported/unconfigured OS +#endif + } else { + mep->me_kaddr = KM_ALLOC(ksize, M_DEVBUF, M_NOWAIT); + } + + if (mep->me_kaddr == NULL) { + log(LOG_ERR, "atm_dev_alloc: %skernel memory unavailable\n", + (flags & ATM_DEV_NONCACHE) ? "non-cacheable " : ""); + (void) splx(s); + return (NULL); + } + + /* + * Calculate correct alignment address to pass back to user + */ + mep->me_uaddr = (void *) roundup((u_int)mep->me_kaddr, align); + mep->me_ksize = ksize; + mep->me_flags = flags; + + /* + * Clear memory for user + */ + KM_ZERO(mep->me_uaddr, size); + + ATM_DEBUG4("atm_dev_alloc: size=%d, align=%d, flags=%d, uaddr=0x%x\n", + size, align, flags, (int)mep->me_uaddr); + + (void) splx(s); + + return (mep->me_uaddr); +} + + +/* + * Free kernel memory block + * + * This function will free a kernel memory block previously allocated by + * the atm_dev_alloc function. + * + * This function should not be called from interrupt level. + * + * Arguments: + * uaddr pointer to allocated aligned memory block + * + * Returns: + * none + * + */ +void +atm_dev_free(uaddr) + void *uaddr; +{ + Mem_blk *mbp; + Mem_ent *mep; + int s, i; + + ATM_DEBUG1("atm_dev_free: uaddr=0x%x\n", (int)uaddr); + + s = splimp(); + + /* + * Protect ourselves... + */ + if (uaddr == NULL) + panic("atm_dev_free: trying to free null address"); + + /* + * Find our associated entry + */ + mep = NULL; + for (mbp = atm_mem_head; mbp && mep == NULL; mbp = mbp->mb_next) { + for (i = 0; i < MEM_NMEMENT; i++) { + if (mbp->mb_mement[i].me_uaddr == uaddr) { + mep = &mbp->mb_mement[i]; + break; + } + } + } + + /* + * If we didn't find our entry, then unceremoniously let the caller + * know they screwed up (it certainly couldn't be a bug here...) + */ + if (mep == NULL) + panic("atm_dev_free: trying to free unknown address"); + + /* + * Give the memory space back to the kernel + */ + if (mep->me_flags & ATM_DEV_NONCACHE) { +#ifdef sun + IOPBFREE(mep->me_kaddr, mep->me_ksize); +#elif defined(__i386__) + KM_FREE(mep->me_kaddr, mep->me_ksize, M_DEVBUF); +#else + #error Unsupported/unconfigured OS +#endif + } else { + KM_FREE(mep->me_kaddr, mep->me_ksize, M_DEVBUF); + } + + /* + * Free our entry + */ + mep->me_uaddr = NULL; + + (void) splx(s); + + return; +} + + +#ifdef sun4m + +typedef int (*func_t)(); + +/* + * Map an address into DVMA space + * + * This function will take a kernel virtual address and map it to + * a DMA virtual address which can be used during SBus DMA cycles. + * + * Arguments: + * addr kernel virtual address + * len length of DVMA space requested + * flags allocation flags (ATM_DEV_*) + * + * Returns: + * a DVMA address + * NULL unable to map into DMA space + * + */ +void * +atm_dma_map(addr, len, flags) + caddr_t addr; + int len; + int flags; +{ + if (flags & ATM_DEV_NONCACHE) + /* + * Non-cacheable memory is already DMA'able + */ + return ((void *)addr); + else + return ((void *)mb_nbmapalloc(bigsbusmap, addr, len, + MDR_BIGSBUS|MB_CANTWAIT, (func_t)NULL, (caddr_t)NULL)); +} + + +/* + * Free a DVMA map address + * + * This function will free DVMA map resources (addresses) previously + * allocated with atm_dma_map(). + * + * Arguments: + * addr DMA virtual address + * flags allocation flags (ATM_DEV_*) + * + * Returns: + * none + * + */ +void +atm_dma_free(addr, flags) + caddr_t addr; + int flags; +{ + if ((flags & ATM_DEV_NONCACHE) == 0) + mb_mapfree(bigsbusmap, (int)&addr); + + return; +} +#endif /* sun4m */ + + +/* + * Compress buffer chain + * + * This function will compress a supplied buffer chain into a minimum number + * of kernel buffers. Typically, this function will be used because the + * number of buffers in an output buffer chain is too large for a device's + * DMA capabilities. This should only be called as a last resort, since + * all the data copying will surely kill any hopes of decent performance. + * + * Arguments: + * m pointer to source buffer chain + * + * Returns: + * n pointer to compressed buffer chain + * + */ +KBuffer * +atm_dev_compress(m) + KBuffer *m; +{ + KBuffer *n, *n0, **np; + int len, space; + caddr_t src, dst; + + n = n0 = NULL; + np = &n0; + dst = NULL; + space = 0; + + /* + * Copy each source buffer into compressed chain + */ + while (m) { + + if (space == 0) { + + /* + * Allocate another buffer for compressed chain + */ + KB_ALLOCEXT(n, ATM_DEV_CMPR_LG, KB_F_NOWAIT, KB_T_DATA); + if (n) { + space = ATM_DEV_CMPR_LG; + } else { + KB_ALLOC(n, ATM_DEV_CMPR_SM, KB_F_NOWAIT, + KB_T_DATA); + if (n) { + space = ATM_DEV_CMPR_SM; + } else { + /* + * Unable to get any new buffers, so + * just return the partially compressed + * chain and hope... + */ + *np = m; + break; + } + } + + KB_HEADSET(n, 0); + KB_LEN(n) = 0; + KB_BFRSTART(n, dst, caddr_t); + + *np = n; + np = &KB_NEXT(n); + } + + /* + * Copy what we can from source buffer + */ + len = MIN(space, KB_LEN(m)); + KB_DATASTART(m, src, caddr_t); + KM_COPY(src, dst, len); + + /* + * Adjust for copied data + */ + dst += len; + space -= len; + + KB_HEADADJ(m, -len); + KB_TAILADJ(n, len); + + /* + * If we've exhausted our current source buffer, free it + * and move to the next one + */ + if (KB_LEN(m) == 0) { + KB_FREEONE(m, m); + } + } + + return (n0); +} + + +/* + * Locate VCC entry + * + * This function will return the VCC entry for a specified interface and + * VPI/VCI value. + * + * Arguments: + * cup pointer to interface unit structure + * vpi VPI value + * vci VCI value + * type VCC type + * + * Returns: + * vcp pointer to located VCC entry matching + * NULL no VCC found + * + */ +Cmn_vcc * +atm_dev_vcc_find(cup, vpi, vci, type) + Cmn_unit *cup; + u_int vpi; + u_int vci; + u_int type; +{ + Cmn_vcc *cvp; + int s = splnet(); + + /* + * Go find VCC + * + * (Probably should stick in a hash table some time) + */ + for (cvp = cup->cu_vcc; cvp; cvp = cvp->cv_next) { + struct vccb *vcp; + + vcp = cvp->cv_connvc->cvc_vcc; + if ((vcp->vc_vci == vci) && (vcp->vc_vpi == vpi) && + ((vcp->vc_type & type) == type)) + break; + } + + (void) splx(s); + return (cvp); +} + + +#ifdef notdef +/* + * Module unloading notification + * + * This function must be called just prior to unloading the module from + * memory. All allocated memory will be freed here and anything else that + * needs cleaning up. + * + * Arguments: + * none + * + * Returns: + * none + * + */ +void +atm_unload() +{ + Mem_blk *mbp; + Mem_ent *mep; + int s, i; + + s = splimp(); + + /* + * Free up all of our memory management storage + */ + while (mbp = atm_mem_head) { + + /* + * Make sure users have freed up all of their memory + */ + for (i = 0; i < MEM_NMEMENT; i++) { + if (mbp->mb_mement[i].me_uaddr != NULL) { + panic("atm_unload: unfreed memory"); + } + } + + atm_mem_head = mbp->mb_next; + + /* + * Hand this block back to the kernel + */ + KM_FREE((caddr_t) mbp, sizeof(Mem_blk), M_DEVBUF); + } + + (void) splx(s); + + return; +} +#endif /* notdef */ + + +/* + * Print a PDU + * + * Arguments: + * cup pointer to device unit + * cvp pointer to VCC control block + * m pointer to pdu buffer chain + * msg pointer to message string + * + * Returns: + * none + * + */ +void +atm_dev_pdu_print(cup, cvp, m, msg) + Cmn_unit *cup; + Cmn_vcc *cvp; + KBuffer *m; + char *msg; +{ + char buf[128]; + + sprintf(buf, "%s vcc=(%d,%d)", msg, + cvp->cv_connvc->cvc_vcc->vc_vpi, + cvp->cv_connvc->cvc_vcc->vc_vci); + + atm_pdu_print(m, buf); +} + diff --git a/sys/netatm/atm_if.c b/sys/netatm/atm_if.c new file mode 100644 index 0000000..a07ccc2 --- /dev/null +++ b/sys/netatm/atm_if.c @@ -0,0 +1,1202 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_if.c,v 1.13 1998/07/23 21:43:55 root Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM interface management + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: atm_if.c,v 1.13 1998/07/23 21:43:55 root Exp $"; +#endif + +#include <netatm/kern_include.h> + + +#if (defined(BSD) && (BSD < 199506)) +extern int ifqmaxlen; +#endif + +/* + * Local functions + */ +static int atm_physif_ioctl __P((int, caddr_t, caddr_t)); +#if (defined(BSD) && (BSD >= 199306)) +static int atm_netif_rtdel __P((struct radix_node *, void *)); +#endif +static int atm_if_ioctl __P((struct ifnet *, u_long, caddr_t)); +static int atm_ifparse __P((char *, char *, int, int *)); + +/* + * Local variables + */ +static int (*atm_ifouttbl[AF_MAX+1]) + __P((struct ifnet *, KBuffer *, struct sockaddr *)) + = {NULL}; + + +/* + * Register an ATM physical interface + * + * Each ATM device interface must register itself here upon completing + * its internal initialization. This applies to both linked and loaded + * device drivers. The interface must be registered before a signalling + * manager can be attached. + * + * Arguments: + * cup pointer to interface's common unit structure + * name pointer to device name string + * sdp pointer to interface's stack services + * + * Returns: + * 0 registration successful + * errno registration failed - reason indicated + * + */ +int +atm_physif_register(cup, name, sdp) + Cmn_unit *cup; + char *name; + struct stack_defn *sdp; +{ + struct atm_pif *pip; + int s; + + /* + * See if we need to be initialized + */ + if (!atm_init) + atm_initialize(); + + /* + * Make sure we're not already registered + */ + if (cup->cu_flags & CUF_REGISTER) { + return (EALREADY); + } + + s = splnet(); + + /* + * Make sure an interface is only registered once + */ + for (pip = atm_interface_head; pip != NULL; pip = pip->pif_next) { + if ((cup->cu_unit == pip->pif_unit) && + (strcmp(name, pip->pif_name) == 0)) { + (void) splx(s); + return (EEXIST); + } + } + + /* + * Fill in physical interface parameters + */ + pip = &cup->cu_pif; + pip->pif_name = name; + pip->pif_unit = cup->cu_unit; + pip->pif_flags = PIF_UP; + pip->pif_services = sdp; + pip->pif_ioctl = atm_physif_ioctl; + + /* + * Link in the interface and mark us registered + */ + LINK2TAIL(pip, struct atm_pif, atm_interface_head, pif_next); + cup->cu_flags |= CUF_REGISTER; + + (void) splx(s); + return (0); +} + + +/* + * De-register an ATM physical interface + * + * Each ATM interface must de-register itself before downing the interface. + * The interface's signalling manager will be detached and any network + * interface and VCC control blocks will be freed. + * + * Arguments: + * cup pointer to interface's common unit structure + * + * Returns: + * 0 de-registration successful + * errno de-registration failed - reason indicated + * + */ +int +atm_physif_deregister(cup) + Cmn_unit *cup; +{ + struct atm_pif *pip = (struct atm_pif *)&cup->cu_pif; + Cmn_vcc *cvp; + int err; + int s = splnet(); + + /* + * Detach and deregister, if needed + */ + if ((cup->cu_flags & CUF_REGISTER)) { + + /* + * Detach from signalling manager + */ + if (pip->pif_sigmgr != NULL) { + err = atm_sigmgr_detach(pip); + if (err && (err != ENOENT)) { + (void) splx(s); + return (err); + } + } + + /* + * Make sure signalling manager is detached + */ + if (pip->pif_sigmgr != NULL) { + (void) splx(s); + return (EBUSY); + } + + /* + * Unlink interface + */ + UNLINK(pip, struct atm_pif, atm_interface_head, pif_next); + + cup->cu_flags &= ~CUF_REGISTER; + } + + /* + * Free all of our network interfaces + */ + atm_physif_freenifs(pip); + + /* + * Free unit's vcc information + */ + cvp = cup->cu_vcc; + while (cvp) { + atm_free(cvp); + cvp = cvp->cv_next; + } + cup->cu_vcc = (Cmn_vcc *)NULL; + + (void) splx(s); + + return (0); +} + + +/* + * Free all network interfaces on a physical interface + * + * Arguments + * pip pointer to physical interface structure + * + * Returns + * none + * + */ +void +atm_physif_freenifs(pip) + struct atm_pif *pip; +{ + struct atm_nif *nip = pip->pif_nif; + int s = splnet(); + + while ( nip ) + { + /* + * atm_nif_detach zeros pointers - save so we can + * walk the chain. + */ + struct atm_nif *nipp = nip->nif_pnext; + + /* + * Clean up network i/f trails + */ + atm_nif_detach ( nip ); + atm_free ((caddr_t)nip); + nip = nipp; + } + pip->pif_nif = (struct atm_nif *)NULL; + + (void) splx(s); + + return; +} + + +/* + * Handle physical interface ioctl's + * + * See <netatm/atm_ioctl.h> for definitions. + * + * Called at splnet. + * + * Arguments: + * code Ioctl function (sub)code + * data Data block. On input contains command, + * on output, contains results + * arg Optional code specific arguments + * + * Returns: + * 0 Request processed successfully + * errno Request failed - reason code + * + */ +static int +atm_physif_ioctl(code, data, arg) + int code; + caddr_t data; + caddr_t arg; +{ + struct atminfreq *aip = (struct atminfreq *)data; + struct atmsetreq *asr = (struct atmsetreq *)data; + struct atm_pif *pip; + struct atm_nif *nip; + struct sigmgr *smp; + struct siginst *sip; + struct ifnet *ifp; + Cmn_unit *cup; + Atm_config *acp; + caddr_t buf = aip->air_buf_addr; + struct air_phy_stat_rsp *apsp; + struct air_int_rsp apr; + struct air_netif_rsp anr; + struct air_cfg_rsp acr; + int count, len, buf_len = aip->air_buf_len; + int err = 0; + char ifname[2*IFNAMSIZ]; +#if (defined(BSD) && (BSD >= 199103)) + struct ifaddr *ifa; + struct in_ifaddr *ia; + struct sockaddr_dl *sdl; +#endif + + + switch ( aip->air_opcode ) { + + case AIOCS_INF_INT: + /* + * Get physical interface information + */ + aip = (struct atminfreq *)data; + pip = (struct atm_pif *)arg; + + /* + * Make sure there's room in user buffer + */ + if (aip->air_buf_len < sizeof(apr)) { + err = ENOSPC; + break; + } + + /* + * Fill in info to be returned + */ + KM_ZERO((caddr_t)&apr, sizeof(apr)); + smp = pip->pif_sigmgr; + sip = pip->pif_siginst; + (void) sprintf(apr.anp_intf, "%s%d", pip->pif_name, + pip->pif_unit ); + if ( pip->pif_nif ) + { + strcpy(apr.anp_nif_pref, pip->pif_nif->nif_if.if_name); + + nip = pip->pif_nif; + while ( nip ) { + apr.anp_nif_cnt++; + nip = nip->nif_pnext; + } + } + if (sip) { + ATM_ADDR_COPY(&sip->si_addr, &apr.anp_addr); + ATM_ADDR_COPY(&sip->si_subaddr, &apr.anp_subaddr); + apr.anp_sig_proto = smp->sm_proto; + apr.anp_sig_state = sip->si_state; + } + + /* + * Copy data to user buffer + */ + err = copyout((caddr_t)&apr, aip->air_buf_addr, sizeof(apr)); + if (err) + break; + + /* + * Update buffer pointer/count + */ + aip->air_buf_addr += sizeof(apr); + aip->air_buf_len -= sizeof(apr); + break; + + case AIOCS_INF_NIF: + /* + * Get network interface information + */ + aip = (struct atminfreq *)data; + nip = (struct atm_nif *)arg; + ifp = &nip->nif_if; + pip = nip->nif_pif; + + /* + * Make sure there's room in user buffer + */ + if (aip->air_buf_len < sizeof(anr)) { + err = ENOSPC; + break; + } + + /* + * Fill in info to be returned + */ + KM_ZERO((caddr_t)&anr, sizeof(anr)); + (void) sprintf(anr.anp_intf, "%s%d", ifp->if_name, + ifp->if_unit); + IFP_TO_IA(ifp, ia); + if (ia) { + anr.anp_proto_addr = *ia->ia_ifa.ifa_addr; + } + (void) sprintf(anr.anp_phy_intf, "%s%d", pip->pif_name, + pip->pif_unit); + + /* + * Copy data to user buffer + */ + err = copyout((caddr_t)&anr, aip->air_buf_addr, sizeof(anr)); + if (err) + break; + + /* + * Update buffer pointer/count + */ + aip->air_buf_addr += sizeof(anr); + aip->air_buf_len -= sizeof(anr); + break; + + case AIOCS_INF_PIS: + /* + * Get per interface statistics + */ + pip = (struct atm_pif *)arg; + if ( pip == NULL ) + return ( ENXIO ); + sprintf ( ifname, "%s%d", pip->pif_name, pip->pif_unit ); + + /* + * Cast response into users buffer + */ + apsp = (struct air_phy_stat_rsp *)buf; + + /* + * Sanity check + */ + len = sizeof ( struct air_phy_stat_rsp ); + if ( buf_len < len ) + return ( ENOSPC ); + + /* + * Copy interface name into response + */ + if ( err = copyout ( ifname, apsp->app_intf, IFNAMSIZ ) ) + break; + + /* + * Copy counters + */ + if ( err = copyout ( &pip->pif_ipdus, &apsp->app_ipdus, + len - sizeof ( apsp->app_intf ) ) ) + break; + + /* + * Adjust buffer elements + */ + buf += len; + buf_len -= len; + + aip->air_buf_addr = buf; + aip->air_buf_len = buf_len; + break; + + case AIOCS_SET_NIF: + /* + * Set NIF - allow user to configure 1 or more logical + * interfaces per physical interface. + */ + + /* + * Get pointer to physical interface structure from + * ioctl argument. + */ + pip = (struct atm_pif *)arg; + cup = (Cmn_unit *)pip; + + /* + * Sanity check - are we already connected to something? + */ + if ( pip->pif_sigmgr ) + { + err = EBUSY; + break; + } + + /* + * Free any previously allocated NIFs + */ + atm_physif_freenifs(pip); + + /* + * Add list of interfaces + */ + for ( count = 0; count < asr->asr_nif_cnt; count++ ) + { + nip = (struct atm_nif *)atm_allocate(cup->cu_nif_pool); + if ( nip == NULL ) + { + /* + * Destroy any successful nifs + */ + atm_physif_freenifs(pip); + err = ENOMEM; + break; + } + + nip->nif_pif = pip; + ifp = &nip->nif_if; + + strcpy ( nip->nif_name, asr->asr_nif_pref ); + nip->nif_sel = count; + + ifp->if_name = nip->nif_name; + ifp->if_unit = count; + ifp->if_mtu = ATM_NIF_MTU; + ifp->if_flags = IFF_UP | IFF_BROADCAST | IFF_RUNNING; + ifp->if_output = atm_ifoutput; + ifp->if_ioctl = atm_if_ioctl; + ifp->if_snd.ifq_maxlen = ifqmaxlen; +#if (defined(BSD) && (BSD >= 199103)) + /* + * Set if_type and if_baudrate + */ + ifp->if_type = IFT_ATM; + switch ( cup->cu_config.ac_media ) { + case MEDIA_TAXI_100: + ifp->if_baudrate = 100000000; + break; + case MEDIA_TAXI_140: + ifp->if_baudrate = 140000000; + break; + case MEDIA_OC3C: + case MEDIA_OC12C: + case MEDIA_UTP155: + ifp->if_baudrate = 155000000; + break; + } +#endif + + if ( err = atm_nif_attach ( nip ) ) + { + atm_free ( (caddr_t)nip ); + + /* + * Destroy any successful nifs + */ + atm_physif_freenifs(pip); + break; + } +#if (defined(BSD) && (BSD >= 199103)) + /* + * Set macaddr in <Link> address + */ + ifp->if_addrlen = 6; + ifa = ifnet_addrs[ifp->if_index - 1]; + if ( ifa ) { + sdl = (struct sockaddr_dl *) + ifa->ifa_addr; + sdl->sdl_type = IFT_ETHER; + sdl->sdl_alen = ifp->if_addrlen; + bcopy ( (caddr_t)&cup->cu_config.ac_macaddr, + LLADDR(sdl), ifp->if_addrlen ); + } +#endif + } + break; + + case AIOCS_INF_CFG: + /* + * Get adapter configuration information + */ + aip = (struct atminfreq *)data; + pip = (struct atm_pif *)arg; + cup = (Cmn_unit *)pip; + acp = &cup->cu_config; + + /* + * Make sure there's room in user buffer + */ + if (aip->air_buf_len < sizeof(acr)) { + err = ENOSPC; + break; + } + + /* + * Fill in info to be returned + */ + KM_ZERO((caddr_t)&acr, sizeof(acr)); + (void) sprintf(acr.acp_intf, "%s%d", pip->pif_name, + pip->pif_unit); + KM_COPY((caddr_t)acp, (caddr_t)&acr.acp_cfg, + sizeof(Atm_config)); + + /* + * Copy data to user buffer + */ + err = copyout((caddr_t)&acr, aip->air_buf_addr, + sizeof(acr)); + if (err) + break; + + /* + * Update buffer pointer/count + */ + aip->air_buf_addr += sizeof(acr); + aip->air_buf_len -= sizeof(acr); + break; + + case AIOCS_INF_VST: + /* + * Pass off to device-specific handler + */ + cup = (Cmn_unit *)arg; + if (cup == NULL) + err = ENXIO; + else + err = (*cup->cu_ioctl)(code, data, arg); + break; + + default: + err = ENOSYS; + } + + return ( err ); +} + + +/* + * Register a Network Convergence Module + * + * Each ATM network convergence module must register itself here before + * it will receive network interface status notifications. + * + * Arguments: + * ncp pointer to network convergence definition structure + * + * Returns: + * 0 registration successful + * errno registration failed - reason indicated + * + */ +int +atm_netconv_register(ncp) + struct atm_ncm *ncp; +{ + struct atm_ncm *tdp; + int s = splnet(); + + /* + * See if we need to be initialized + */ + if (!atm_init) + atm_initialize(); + + /* + * Validate protocol family + */ + if (ncp->ncm_family > AF_MAX) { + (void) splx(s); + return (EINVAL); + } + + /* + * Ensure no duplicates + */ + for (tdp = atm_netconv_head; tdp != NULL; tdp = tdp->ncm_next) { + if (tdp->ncm_family == ncp->ncm_family) { + (void) splx(s); + return (EEXIST); + } + } + + /* + * Add module to list + */ + LINK2TAIL(ncp, struct atm_ncm, atm_netconv_head, ncm_next); + + /* + * Add new interface output function + */ + atm_ifouttbl[ncp->ncm_family] = ncp->ncm_ifoutput; + + (void) splx(s); + return (0); +} + + +/* + * De-register an ATM Network Convergence Module + * + * Each ATM network convergence provider must de-register its registered + * service(s) before terminating. Specifically, loaded kernel modules + * must de-register their services before unloading themselves. + * + * Arguments: + * ncp pointer to network convergence definition structure + * + * Returns: + * 0 de-registration successful + * errno de-registration failed - reason indicated + * + */ +int +atm_netconv_deregister(ncp) + struct atm_ncm *ncp; +{ + int found, s = splnet(); + + /* + * Remove module from list + */ + UNLINKF(ncp, struct atm_ncm, atm_netconv_head, ncm_next, found); + + if (!found) { + (void) splx(s); + return (ENOENT); + } + + /* + * Remove module's interface output function + */ + atm_ifouttbl[ncp->ncm_family] = NULL; + + (void) splx(s); + return (0); +} + + +/* + * Attach an ATM Network Interface + * + * Before an ATM network interface can be used by the system, the owning + * device interface must attach the network interface using this function. + * The physical interface for this network interface must have been previously + * registered (using atm_interface_register). The network interface will be + * added to the kernel's interface list and to the physical interface's list. + * The caller is responsible for initializing the control block fields. + * + * Arguments: + * nip pointer to atm network interface control block + * + * Returns: + * 0 attach successful + * errno attach failed - reason indicated + * + */ +int +atm_nif_attach(nip) + struct atm_nif *nip; +{ + struct atm_pif *pip, *pip2; + struct ifnet *ifp; + struct atm_ncm *ncp; + int s; + + ifp = &nip->nif_if; + pip = nip->nif_pif; + + s = splimp(); + + /* + * Verify physical interface is registered + */ + for (pip2 = atm_interface_head; pip2 != NULL; pip2 = pip2->pif_next) { + if (pip == pip2) + break; + } + if ((pip == NULL) || (pip2 == NULL)) { + (void) splx(s); + return (EFAULT); + } + + /* + * Add to system interface list + */ + if_attach(ifp); + + /* + * Add to physical interface list + */ + LINK2TAIL(nip, struct atm_nif, pip->pif_nif, nif_pnext); + + /* + * Notify network convergence modules of new network i/f + */ + for (ncp = atm_netconv_head; ncp; ncp = ncp->ncm_next) { + int err; + + err = (*ncp->ncm_stat)(NCM_ATTACH, nip, 0); + if (err) { + atm_nif_detach(nip); + (void) splx(s); + return (err); + } + } + + (void) splx(s); + return (0); +} + + +/* + * Detach an ATM Network Interface + * + * Before an ATM network interface control block can be freed, all kernel + * references to/from this block must be released. This function will delete + * all routing references to the interface and free all interface addresses + * for the interface. The network interface will then be removed from the + * kernel's interface list and from the owning physical interface's list. + * The caller is responsible for free'ing the control block. + * + * Arguments: + * nip pointer to atm network interface control block + * + * Returns: + * none + * + */ +void +atm_nif_detach(nip) + struct atm_nif *nip; +{ + struct atm_ncm *ncp; + int s, i; + struct ifnet *ifp = &nip->nif_if; + struct ifaddr *ifa; + struct in_ifaddr *ia; + struct radix_node_head *rnh; + + + s = splimp(); + + /* + * Notify convergence modules of network i/f demise + */ + for (ncp = atm_netconv_head; ncp; ncp = ncp->ncm_next) { + (void) (*ncp->ncm_stat)(NCM_DETACH, nip, 0); + } + + /* + * Mark interface down + */ + if_down(ifp); + + /* + * Free all interface routes and addresses + */ + while (1) { + IFP_TO_IA(ifp, ia); + if (ia == NULL) + break; + + /* Delete interface route */ + in_ifscrub(ifp, ia); + + /* Remove interface address from queues */ + ifa = &ia->ia_ifa; + TAILQ_REMOVE(&ifp->if_addrhead, ifa, ifa_link); + TAILQ_REMOVE(&in_ifaddrhead, ia, ia_link); + + /* Free interface address */ + IFAFREE(ifa); + } + + /* + * Delete all remaining routes using this interface + * Unfortuneatly the only way to do this is to slog through + * the entire routing table looking for routes which point + * to this interface...oh well... + */ + for (i = 1; i <= AF_MAX; i++) { + if ((rnh = rt_tables[i]) == NULL) + continue; + (void) rnh->rnh_walktree(rnh, atm_netif_rtdel, ifp); + } + + /* + * Remove from system interface list (ie. if_detach()) + */ + TAILQ_REMOVE(&ifnet, ifp, if_link); + + /* + * Remove from physical interface list + */ + UNLINK(nip, struct atm_nif, nip->nif_pif->pif_nif, nif_pnext); + + (void) splx(s); +} + + +/* + * Delete Routes for a Network Interface + * + * Called for each routing entry via the rnh->rnh_walktree() call above + * to delete all route entries referencing a detaching network interface. + * + * Arguments: + * rn pointer to node in the routing table + * arg argument passed to rnh->rnh_walktree() - detaching interface + * + * Returns: + * 0 successful + * errno failed - reason indicated + * + */ +static int +atm_netif_rtdel(rn, arg) + struct radix_node *rn; + void *arg; +{ + struct rtentry *rt = (struct rtentry *)rn; + struct ifnet *ifp = arg; + int err; + + if (rt->rt_ifp == ifp) { + + /* + * Protect (sorta) against walktree recursion problems + * with cloned routes + */ + if ((rt->rt_flags & RTF_UP) == 0) + return (0); + + err = rtrequest(RTM_DELETE, rt_key(rt), rt->rt_gateway, + rt_mask(rt), rt->rt_flags, + (struct rtentry **) NULL); + if (err) { + log(LOG_WARNING, "atm_netif_rtdel: error %d\n", err); + } + } + + return (0); +} + + +/* + * Set an ATM Network Interface address + * + * This is called from a device interface when processing an SIOCSIFADDR + * ioctl request. We just notify all convergence modules of the new address + * and hope everyone has non-overlapping interests, since if someone reports + * an error we don't go back and tell everyone to undo the change. + * + * Arguments: + * nip pointer to atm network interface control block + * ifa pointer to new interface address + * + * Returns: + * 0 set successful + * errno set failed - reason indicated + * + */ +int +atm_nif_setaddr(nip, ifa) + struct atm_nif *nip; + struct ifaddr *ifa; +{ + struct atm_ncm *ncp; + int err = 0, s = splnet(); + + /* + * Notify convergence modules of network i/f change + */ + for (ncp = atm_netconv_head; ncp; ncp = ncp->ncm_next) { + err = (*ncp->ncm_stat)(NCM_SETADDR, nip, (int)ifa); + if (err) + break; + } + (void) splx(s); + + return (err); +} + + +/* + * ATM Interface Packet Output + * + * All ATM network interfaces must have their ifnet if_output address set to + * this function. Since no existing network layer code is to be modified + * for ATM support, this function serves as the hook to allow network output + * packets to be assigned to their proper outbound VCC. Each network address + * family which is to be supported over ATM must be assigned an output + * packet processing function via atm_netconv_register(). + * + * Arguments: + * ifp pointer to ifnet structure + * m pointer to packet buffer chain to be output + * dst pointer to packet's network destination address + * + * Returns: + * 0 packet queued to interface + * errno output failed - reason indicated + * + */ +int +#if (defined(BSD) && (BSD >= 199103)) +atm_ifoutput(ifp, m, dst, rt) +#else +atm_ifoutput(ifp, m, dst) +#endif + struct ifnet *ifp; + KBuffer *m; + struct sockaddr *dst; +#if (defined(BSD) && (BSD >= 199103)) + struct rtentry *rt; +#endif +{ + u_short fam = dst->sa_family; + int (*func)__P((struct ifnet *, KBuffer *, + struct sockaddr *)); + + /* + * Validate address family + */ + if (fam > AF_MAX) { + KB_FREEALL(m); + return (EAFNOSUPPORT); + } + + /* + * Hand packet off for dst-to-VCC mapping + */ + func = atm_ifouttbl[fam]; + if (func == NULL) { + KB_FREEALL(m); + return (EAFNOSUPPORT); + } + return ((*func)(ifp, m, dst)); +} + + +/* + * Handle interface ioctl requests. + * + * Arguments: + * ifp pointer to network interface structure + * cmd IOCTL cmd + * data arguments to/from ioctl + * + * Returns: + * error errno value + */ +static int +atm_if_ioctl(ifp, cmd, data) + struct ifnet *ifp; + u_long cmd; + caddr_t data; +{ + register struct ifreq *ifr = (struct ifreq *)data; + struct atm_nif *nip = (struct atm_nif *)ifp; + int error = 0; + int s = splnet(); + + switch ( cmd ) + { + case SIOCGIFADDR: + KM_COPY ( (caddr_t)&(nip->nif_pif->pif_macaddr), + (caddr_t)ifr->ifr_addr.sa_data, + sizeof(struct mac_addr) ); + break; + + case SIOCSIFADDR: + error = atm_nif_setaddr ( nip, (struct ifaddr *)data); + ifp->if_flags |= IFF_UP | IFF_RUNNING | IFF_BROADCAST; + break; + + case SIOCGIFFLAGS: + *(short *)data = ifp->if_flags; + break; + + case SIOCSIFFLAGS: + break; + + default: + error = EINVAL; + break; + } + + (void) splx(s); + return ( error ); +} + + +/* + * Parse interface name + * + * Parses an interface name string into a name and a unit component. + * + * Arguments: + * name pointer to interface name string + * namep address to store interface name + * size size available at namep + * unitp address to store interface unit number + * + * Returns: + * 0 name parsed + * else parse error + * + */ +static int +atm_ifparse(name, namep, size, unitp) + char *name; + char *namep; + int size; + int *unitp; +{ + char *cp, *np; + int len = 0, unit = 0; + + /* + * Separate supplied string into name and unit parts. + */ + cp = name; + np = namep; + while (*cp) { + if (*cp >= '0' && *cp <= '9') + break; + if (++len >= size) + return (-1); + *np++ = *cp++; + } + *np = '\0'; + while (*cp && *cp >= '0' && *cp <= '9') + unit = 10 * unit + *cp++ - '0'; + + *unitp = unit; + + return (0); +} + + +/* + * Locate ATM physical interface via name + * + * Uses the supplied interface name string to locate a registered + * ATM physical interface. + * + * Arguments: + * name pointer to interface name string + * + * Returns: + * 0 interface not found + * else pointer to atm physical interface structure + * + */ +struct atm_pif * +atm_pifname(name) + char *name; +{ + struct atm_pif *pip; + char n[IFNAMSIZ]; + int unit; + + /* + * Break down name + */ + if (atm_ifparse(name, n, sizeof(n), &unit)) + return ((struct atm_pif *)0); + + /* + * Look for the physical interface + */ + for (pip = atm_interface_head; pip; pip = pip->pif_next) { + if ((pip->pif_unit == unit) && (strcmp(pip->pif_name, n) == 0)) + break; + } + + return (pip); +} + + +/* + * Locate ATM network interface via name + * + * Uses the supplied interface name string to locate an ATM network interface. + * + * Arguments: + * name pointer to interface name string + * + * Returns: + * 0 interface not found + * else pointer to atm network interface structure + * + */ +struct atm_nif * +atm_nifname(name) + char *name; +{ + struct atm_pif *pip; + struct atm_nif *nip; + char n[IFNAMSIZ]; + int unit; + + /* + * Break down name + */ + if (atm_ifparse(name, n, sizeof(n), &unit)) + return ((struct atm_nif *)0); + + /* + * Search thru each physical interface + */ + for (pip = atm_interface_head; pip; pip = pip->pif_next) { + /* + * Looking for network interface + */ + for (nip = pip->pif_nif; nip; nip = nip->nif_pnext) { + struct ifnet *ifp = (struct ifnet *)nip; + if ((ifp->if_unit == unit) && + (strcmp(ifp->if_name, n) == 0)) + return (nip); + } + } + return (NULL); +} + diff --git a/sys/netatm/atm_if.h b/sys/netatm/atm_if.h new file mode 100644 index 0000000..ccf9d03 --- /dev/null +++ b/sys/netatm/atm_if.h @@ -0,0 +1,392 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_if.h,v 1.13 1998/08/07 22:10:37 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM Physical and Network Interface definitions + * + */ + +#ifndef _NETATM_ATM_IF_H +#define _NETATM_ATM_IF_H + +/* + * Handy constants + */ +#define ATM_NIF_MTU 9180 /* Default network interface MTU */ + +#define ATM_PCR_TAXI100 227273 /* Peak Cell Rate for 100 Mbs TAXI */ +#define ATM_PCR_TAXI140 318181 /* Peak Cell Rate for 140 Mbs TAXI */ +#define ATM_PCR_OC3C 353207 /* Peak Cell Rate for OC3c */ +#define ATM_PCR_OC12C 1416905 /* Peak Cell Rate for OC12c */ + + +/* + * Media Access Control (MAC) address + */ +struct mac_addr { + u_char ma_data[6]; /* MAC address */ +}; +typedef struct mac_addr Mac_addr; + + +/* + * Adapter vendor identifiers + */ +enum atm_vendor { + VENDOR_UNKNOWN, /* Unknown vendor */ + VENDOR_FORE, /* FORE Systems, Inc. */ + VENDOR_ENI /* Efficient Networks, Inc. */ +}; +typedef enum atm_vendor Atm_vendor; + + +/* + * Adapter vendor interface identifiers + */ +enum atm_vendapi { + VENDAPI_UNKNOWN, /* Unknown interface */ + VENDAPI_FORE_1, /* FORE - 200 Series */ + VENDAPI_ENI_1 /* ENI - Midway */ +}; +typedef enum atm_vendapi Atm_vendapi; + + +/* + * Adapter device model identifiers + */ +enum atm_device { + DEV_UNKNOWN, /* Unknown device */ + DEV_FORE_SBA200E, /* FORE SBA-200E */ + DEV_FORE_SBA200, /* FORE SBA-200 */ + DEV_FORE_PCA200E, /* FORE PCA-200E */ + DEV_ENI_155P /* ENI-155p */ +}; +typedef enum atm_device Atm_device; + + +/* + * Adapter media identifiers + */ +enum atm_media { + MEDIA_UNKNOWN, /* Unknown media type */ + MEDIA_TAXI_100, /* TAXI - 100 Mbps */ + MEDIA_TAXI_140, /* TAXI - 140 Mbps */ + MEDIA_OC3C, /* OC-3C */ + MEDIA_OC12C, /* OC-12C */ + MEDIA_UTP155 /* UTP-155 */ +}; +typedef enum atm_media Atm_media; + + +/* + * Bus type identifiers + */ +enum atm_bus { + BUS_UNKNOWN, /* Unknown bus type */ + BUS_SBUS_B16, /* SBus: 16 byte (4 word) max burst */ + BUS_SBUS_B32, /* SBus: 32 byte (8 word) max burst */ + BUS_PCI /* PCI */ +}; +typedef enum atm_bus Atm_bus; + + +#define VERSION_LEN 16 /* Length of version info string */ + + +/* + * ATM adapter configuration information structure + */ +struct atm_config { + Atm_vendor ac_vendor; /* Vendor */ + Atm_vendapi ac_vendapi; /* Vendor interface */ + Atm_device ac_device; /* Device model */ + Atm_media ac_media; /* Media type */ + u_long ac_serial; /* Serial number */ + Atm_bus ac_bustype; /* Bus type */ + u_long ac_busslot; /* Bus slot info (bus type dependent) */ + u_long ac_ram; /* Device ram offset */ + u_long ac_ramsize; /* Device ram size */ + Mac_addr ac_macaddr; /* MAC address */ + char ac_hard_vers[VERSION_LEN]; /* Hardware version */ + char ac_firm_vers[VERSION_LEN]; /* Firmware version */ +}; +typedef struct atm_config Atm_config; + + +#ifdef ATM_KERNEL +/* + * Common structure used to define each physical ATM device interface. + * This structure will (normally) be embedded at the top of each driver's + * device-specific interface structure. + */ +struct atm_pif { + struct atm_pif *pif_next; /* Next registered atm interface */ + char *pif_name; /* Device name */ + short pif_unit; /* Device unit number */ + u_char pif_flags; /* Interface flags (see below) */ + struct sigmgr *pif_sigmgr; /* Signalling Manager for interface */ + struct siginst *pif_siginst; /* Signalling protocol instance */ + struct stack_defn *pif_services; /* Interface's stack services */ + struct mac_addr pif_macaddr; /* Interface's MAC address */ + struct atm_nif *pif_nif; /* List of network interfaces */ + struct atm_pif *pif_grnext; /* Next atm device in group */ + +/* Exported functions */ + int (*pif_ioctl) /* Interface ioctl handler */ + __P((int, caddr_t, caddr_t)); + +/* Interface statistics */ + long pif_ipdus; /* PDUs received from interface */ + long pif_opdus; /* PDUs sent to interface */ + long pif_ibytes; /* Bytes received from interface */ + long pif_obytes; /* Bytes sent to interface */ + long pif_ierrors; /* Errors receiving from interface */ + long pif_oerrors; /* Errors sending to interface */ + long pif_cmderrors; /* Interface command errors */ + caddr_t pif_cardstats; /* Card specific statistics */ + +/* Interface capabilities */ + u_short pif_maxvpi; /* Maximum VPI value supported */ + u_short pif_maxvci; /* Maximum VCI value supported */ + u_int pif_pcr; /* Peak Cell Rate */ +}; + +/* + * Physical interface flags + */ +#define PIF_UP 0x01 /* Interface is up */ +#define PIF_LOOPBACK 0x02 /* Loopback local packets */ + + +/* + * Structure defining an ATM network interface. This structure is used as + * the hook between the standard BSD network layer interface mechanism and + * the ATM device layer. There may be one or more network interfaces for + * each physical ATM interface. + */ +struct atm_nif { + struct ifnet nif_if; /* Network interface */ + struct atm_pif *nif_pif; /* Our physical interface */ + char nif_name[IFNAMSIZ];/* Network interface name */ + u_char nif_sel; /* Interface's address selector */ + struct atm_nif *nif_pnext; /* Next net interface on phys i/f */ + +/* Interface statistics (in addition to ifnet stats) */ + long nif_ibytes; /* Bytes received from interface */ + long nif_obytes; /* Bytes sent to interface */ +}; + + +/* + * Common Device VCC Entry + * + * Contains the common information for each VCC which is opened + * through a particular device. + */ +struct cmn_vcc { + struct cmn_vcc *cv_next; /* Next in list */ + void *cv_toku; /* Upper layer's token */ + void (*cv_upper) /* Upper layer's interface */ + __P((int, void *, int, int)); + Atm_connvc *cv_connvc; /* Associated connection VCC */ + u_char cv_state; /* VCC state (see below) */ + u_char cv_flags; /* VCC flags (see below) */ +}; +typedef struct cmn_vcc Cmn_vcc; + +/* + * VCC States + */ +#define CVS_FREE 0 /* Not allocated */ +#define CVS_INST 1 /* Instantiated, waiting for INIT */ +#define CVS_INITED 2 /* Initialized, waiting for driver */ +#define CVS_ACTIVE 3 /* Device activated by driver */ +#define CVS_PTERM 4 /* Waiting for TERM */ +#define CVS_TERM 5 /* Terminated */ + +/* + * VCC Flags + */ +#define CVF_RSVD 0x0f /* Reserved for device-specific use */ + + +/* + * Common Device Unit Structure + * + * Contains the common information for a single device (adapter). + */ +struct cmn_unit { + struct atm_pif cu_pif; /* Physical interface */ + u_int cu_unit; /* Local unit number */ + u_char cu_flags; /* Device flags (see below) */ + u_int cu_mtu; /* Interface MTU */ + + u_int cu_open_vcc; /* Open VCC count */ + Cmn_vcc *cu_vcc; /* List of VCC's on interface */ + + u_int cu_intrpri; /* Highest unit interrupt priority */ + int cu_savepri; /* Saved priority for locking device */ + + struct sp_info *cu_vcc_pool; /* Device VCC pool */ + struct sp_info *cu_nif_pool; /* Device NIF pool */ + + int (*cu_ioctl) /* Interface ioctl handler */ + __P((int, caddr_t, caddr_t)); + int (*cu_instvcc) /* VCC stack instantion handler */ + __P((struct cmn_unit *, Cmn_vcc *)); + int (*cu_openvcc) /* Open VCC handler */ + __P((struct cmn_unit *, Cmn_vcc *)); + int (*cu_closevcc) /* Close VCC handler */ + __P((struct cmn_unit *, Cmn_vcc *)); + void (*cu_output) /* Data output handler */ + __P((struct cmn_unit *, Cmn_vcc *, KBuffer *)); + + Atm_config cu_config; /* Device configuration data */ +}; +typedef struct cmn_unit Cmn_unit; + +/* + * Device flags + */ +#define CUF_REGISTER 0x01 /* Device is registered */ +#define CUF_INITED 0x02 /* Device is initialized */ + + +/* + * Structure used to define a network convergence module and its associated + * entry points. A convergence module is used to provide the interface + * translations necessary between the ATM system and the BSD network layer + * interface mechanism. There will be one network convergence module for + * each protocol address family supporting ATM connections. + */ +struct atm_ncm { + struct atm_ncm *ncm_next; /* Next in registry list */ + u_short ncm_family; /* Protocol family */ +/* Exported functions */ + int (*ncm_ifoutput) /* Interface if_output handler */ + __P((struct ifnet *, KBuffer *, + struct sockaddr *)); + int (*ncm_stat) /* Network i/f status handler */ + __P((int, struct atm_nif *, int)); +}; + +/* + * ncm_stat() commands + */ +#define NCM_ATTACH 1 /* Attaching a new net i/f */ +#define NCM_DETACH 2 /* Detaching a current net i/f */ +#define NCM_SETADDR 3 /* Net i/f address change */ +#define NCM_SIGATTACH 4 /* Attaching a signalling manager */ +#define NCM_SIGDETACH 5 /* Detaching a signalling manager */ + + +/* + * atm_dev_alloc() parameters + */ +#define ATM_DEV_NONCACHE 1 /* Allocate non-cacheable memory */ + +/* + * atm_dev_compress() buffer allocation sizes + */ +#if defined(BSD) +#define ATM_DEV_CMPR_LG MCLBYTES /* Size of large buffers */ +#define ATM_DEV_CMPR_SM MLEN /* Size of small buffers */ +#endif + +/* + * Macros to manage DMA addresses + */ +#if defined(sun4c) +#define DMA_INIT() +#define DMA_GET_ADDR(addr,len,align,flags) ((void *)(addr)) +#define DMA_FREE_ADDR(addr,daddr,len,flags) +#define DMA_RELEASE() + +#elif defined(sun4m) +#define DMA_INIT() +#define DMA_GET_ADDR(addr,len,align,flags) \ + (void *)atm_dma_map((addr),(len),(flags)) +#define DMA_FREE_ADDR(addr,daddr,len,flags) \ + (void)atm_dma_free((daddr),(flags)) +#define DMA_RELEASE() + +#elif defined(BSD) && defined(__i386__) +#define DMA_INIT() +#define DMA_GET_ADDR(addr,len,align,flags) ((void *)vtophys(addr)) +#define DMA_FREE_ADDR(addr,daddr,len,flags) +#define DMA_RELEASE() + +#else + #error - Must define hardware-specific requirements here +#endif + + +/* + * Macros to lock out device interrupts + */ +#if defined(sun) +#define DEVICE_LOCK(u) ((u)->cu_savepri = splr((u)->cu_intrpri)) +#endif +#if defined(__FreeBSD__) +#define DEVICE_LOCK(u) ((u)->cu_savepri = splimp()) +#endif +#define DEVICE_UNLOCK(u) ((void) splx((u)->cu_savepri)) + + +/* + * SBus defines + */ +#if defined(sun) +#define SBUS_BURST32 0x20 /* Device supports 32-byte bursts */ +#endif + + +/* + * Macro to schedule the ATM interrupt queue handler + */ +typedef void (atm_intr_t) __P((void *, KBuffer *)); /* Callback function type */ +typedef atm_intr_t *atm_intr_func_t; /* Pointer to callback function */ + +#ifdef sun +#define SCHED_ATM schednetisr(atm_intr) +#endif +#ifdef __FreeBSD__ +#define NETISR_ATM AF_ATM +#define SCHED_ATM schednetisr(NETISR_ATM) +#endif +#ifdef sgi +extern int atm_intr_index; +#define SCHED_ATM schednetisr(atm_intr_index) +#endif +#endif /* ATM_KERNEL */ + +#endif /* _NETATM_ATM_IF_H */ diff --git a/sys/netatm/atm_ioctl.h b/sys/netatm/atm_ioctl.h new file mode 100644 index 0000000..a38d183 --- /dev/null +++ b/sys/netatm/atm_ioctl.h @@ -0,0 +1,432 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_ioctl.h,v 1.9 1998/08/26 23:29:01 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * PF_ATM socket ioctl definitions + * + */ + +#ifndef _NETATM_ATM_IOCTL_H +#define _NETATM_ATM_IOCTL_H + + +/* + * Structure for PF_ATM configure (AIOCCFG) socket ioctls + */ +struct atmcfgreq { + int acr_opcode; /* Sub-operation */ + union { + struct { + /* Configure - attach */ + char acru_att_intf[IFNAMSIZ];/* Interface name */ + u_char acru_att_proto; /* Signalling protocol */ + } acru_att; + struct { + /* Configure - detach */ + char acru_det_intf[IFNAMSIZ];/* Interface name */ + } acru_det; + } acr_u; +}; +#define acr_att_intf acr_u.acru_att.acru_att_intf +#define acr_att_proto acr_u.acru_att.acru_att_proto +#define acr_det_intf acr_u.acru_det.acru_det_intf + + +/* + * Structure for PF_ATM set (AIOCSET) socket ioctls + */ +struct atmsetreq { + int asr_opcode; /* Sub-operation */ + union { + /* ARP server */ + struct { + char asru_arp_intf[IFNAMSIZ];/* Interface name */ + Atm_addr asru_arp_addr; /* ARP srvr address */ + Atm_addr asru_arp_subaddr;/* ARP srvr subaddr */ + caddr_t asru_arp_pbuf; /* Prefix buffer addr */ + int asru_arp_plen; /* Prefix buffer len */ + } asru_asrvr; + /* MAC address */ + struct { + char asru_mac_intf[IFNAMSIZ];/* Interface name */ + struct mac_addr asru_mac_addr; /* MAC address */ + } asru_mac; + /* Network interface */ + struct { + char asru_nif_intf[IFNAMSIZ];/* Interface name */ + char asru_nif_pref[IFNAMSIZ];/* I/f prefix name */ + int asru_nif_cnt; /* Number of i/fs */ + } asru_nif; + /* NSAP prefix */ + struct { + char asru_prf_intf[IFNAMSIZ];/* Interface name */ + u_char asru_prf_pref[13]; /* NSAP prefix */ + } asru_prf; + } asr_u; +}; +#define asr_arp_intf asr_u.asru_asrvr.asru_arp_intf +#define asr_arp_addr asr_u.asru_asrvr.asru_arp_addr +#define asr_arp_pbuf asr_u.asru_asrvr.asru_arp_pbuf +#define asr_arp_plen asr_u.asru_asrvr.asru_arp_plen +#define asr_arp_subaddr asr_u.asru_asrvr.asru_arp_subaddr +#define asr_mac_intf asr_u.asru_mac.asru_mac_intf +#define asr_mac_addr asr_u.asru_mac.asru_mac_addr +#define asr_nif_intf asr_u.asru_nif.asru_nif_intf +#define asr_nif_pref asr_u.asru_nif.asru_nif_pref +#define asr_nif_cnt asr_u.asru_nif.asru_nif_cnt +#define asr_prf_intf asr_u.asru_prf.asru_prf_intf +#define asr_prf_pref asr_u.asru_prf.asru_prf_pref + + +/* + * Structure for PF_ATM add (AIOCADD) socket ioctls + */ +struct atmaddreq { + int aar_opcode; /* Sub-operation */ + union { + /* Add PVC */ + struct { + char aaru_pvc_intf[IFNAMSIZ];/* Interface name */ + u_short aaru_pvc_vpi; /* VPI value */ + u_short aaru_pvc_vci; /* VCI value */ + struct sockaddr aaru_pvc_dst; /* Destination addr */ + Sap_t aaru_pvc_sap; /* Endpoint SAP */ + Aal_t aaru_pvc_aal; /* AAL */ + Encaps_t aaru_pvc_encaps; /* Encapsulation */ + u_char aaru_pvc_flags; /* Flags (see below) */ + } aaru_add_pvc; + + /* Add ARP table entry */ + struct { + char aaru_arp_intf[IFNAMSIZ];/* Interface name */ + struct sockaddr aaru_arp_dst; /* IP addr */ + Atm_addr aaru_arp_addr; /* ATM addr */ + u_char aaru_arp_origin; /* Entry origin */ + } aaru_add_arp; + } aar_u; +}; +#define aar_pvc_intf aar_u.aaru_add_pvc.aaru_pvc_intf +#define aar_pvc_vpi aar_u.aaru_add_pvc.aaru_pvc_vpi +#define aar_pvc_vci aar_u.aaru_add_pvc.aaru_pvc_vci +#define aar_pvc_dst aar_u.aaru_add_pvc.aaru_pvc_dst +#define aar_pvc_sap aar_u.aaru_add_pvc.aaru_pvc_sap +#define aar_pvc_aal aar_u.aaru_add_pvc.aaru_pvc_aal +#define aar_pvc_encaps aar_u.aaru_add_pvc.aaru_pvc_encaps +#define aar_pvc_flags aar_u.aaru_add_pvc.aaru_pvc_flags +#define aar_arp_intf aar_u.aaru_add_arp.aaru_arp_intf +#define aar_arp_dst aar_u.aaru_add_arp.aaru_arp_dst +#define aar_arp_addr aar_u.aaru_add_arp.aaru_arp_addr +#define aar_arp_origin aar_u.aaru_add_arp.aaru_arp_origin + +/* PVC flags */ +#define PVC_DYN 0x01 /* Dest addr is dynamic */ + + +/* + * Structure for PF_ATM delete (AIOCDEL) socket ioctls + */ +struct atmdelreq { + int adr_opcode; /* Sub-operation */ + union { + /* Delete PVC */ + struct { + char adru_pvc_intf[IFNAMSIZ];/* Interface name */ + u_short adru_pvc_vpi; /* VPI value */ + u_short adru_pvc_vci; /* VCI value */ + } adru_del_pvc; + + /* Delete SVC */ + struct { + char adru_svc_intf[IFNAMSIZ];/* Interface name */ + u_short adru_svc_vpi; /* VPI value */ + u_short adru_svc_vci; /* VCI value */ + } adru_del_svc; + + /* Delete ARP table entry */ + struct { + char adru_arp_intf[IFNAMSIZ];/* Interface name */ + struct sockaddr adru_arp_dst; /* IP addr */ + } adru_del_arp; + } adr_u; +}; +#define adr_pvc_intf adr_u.adru_del_pvc.adru_pvc_intf +#define adr_pvc_vpi adr_u.adru_del_pvc.adru_pvc_vpi +#define adr_pvc_vci adr_u.adru_del_pvc.adru_pvc_vci +#define adr_svc_intf adr_u.adru_del_svc.adru_svc_intf +#define adr_svc_vpi adr_u.adru_del_svc.adru_svc_vpi +#define adr_svc_vci adr_u.adru_del_svc.adru_svc_vci +#define adr_arp_intf adr_u.adru_del_arp.adru_arp_intf +#define adr_arp_dst adr_u.adru_del_arp.adru_arp_dst + + +/* + * Structure for PF_ATM information (AIOCINFO) socket ioctls + */ +struct atminfreq { + int air_opcode; /* Sub-operation */ + caddr_t air_buf_addr; /* Buffer for returned info */ + int air_buf_len; /* Buffer length */ + union { + /* Vendor info */ + char airu_vinfo_intf[IFNAMSIZ];/* Interface name */ + /* IP VCC */ + struct sockaddr airu_ip_addr; /* Destination host */ + /* ARP table */ + struct { + struct sockaddr airu_arp_addr; /* Destination host */ + u_char airu_arp_flags; /* Flags (see below) */ + } airu_arp; + /* ARP server */ + char airu_asrv_intf[IFNAMSIZ];/* Interface name */ + /* Interface */ + char airu_int_intf[IFNAMSIZ];/* Interface name */ + /* VCC */ + char airu_vcc_intf[IFNAMSIZ];/* Interface name */ + /* Configuration */ + char airu_cfg_intf[IFNAMSIZ];/* Interface name */ + /* Network interface */ + char airu_netif_intf[IFNAMSIZ];/* Interface name */ + /* Physical interface statistics */ + char airu_physt_intf[IFNAMSIZ];/* Interface name */ + } air_u; +}; +#define air_vinfo_intf air_u.airu_vinfo_intf +#define air_ip_addr air_u.airu_ip_addr +#define air_arp_addr air_u.airu_arp.airu_arp_addr +#define air_arp_flags air_u.airu_arp.airu_arp_flags +#define air_asrv_intf air_u.airu_asrv_intf +#define air_int_intf air_u.airu_int_intf +#define air_vcc_intf air_u.airu_vcc_intf +#define air_cfg_intf air_u.airu_cfg_intf +#define air_netif_intf air_u.airu_netif_intf +#define air_physt_intf air_u.airu_physt_intf + +/* ARP table info flags */ +#define ARP_RESET_REF 0x01 /* Reset refresh status */ + + +/* + * Structures returned by information requests + */ + +/* + * Vendor-specific interface information + */ +struct air_vinfo_rsp { + char avsp_intf[IFNAMSIZ]; /* Interface name */ + int avsp_len; /* Length of returned + Vendor Info block */ + /* Vendor info ... */ +}; + + +/* + * ARP table information + */ +struct air_arp_rsp { + struct sockaddr aap_arp_addr; /* Destination host */ + char aap_intf[IFNAMSIZ]; /* Interface name */ + u_char aap_flags; /* Flags (see below) */ + u_char aap_origin; /* Entry origin (see below) */ + u_char aap_age; /* Aging timeout (minutes) */ + Atm_addr aap_addr; /* ATM address */ + Atm_addr aap_subaddr; /* ATM subaddress */ +}; + +/* + * ARP entry flags + */ +#define ARPF_VALID 0x01 /* Entry is valid */ +#define ARPF_REFRESH 0x02 /* Entry has been refreshed */ + +/* + * ARP entry origin + */ +#define ARP_ORIG_PERM 50 /* Permanent entry */ + +/* + * IP VCC information + */ +struct air_ip_vcc_rsp { + struct sockaddr aip_dst_addr; /* Destination host */ + char aip_intf[IFNAMSIZ]; /* Interface name */ + u_short aip_vpi; /* VPI value */ + u_short aip_vci; /* VCI value */ + u_char aip_sig_proto; /* Signalling protocol */ + u_char aip_flags; /* Flags (IVF_*) */ + u_char aip_state; /* IP VCC state */ +}; + +/* + * ARP server information + */ +struct air_asrv_rsp { + char asp_intf[IFNAMSIZ]; /* Interface name */ + Atm_addr asp_addr; /* Server ATM address */ + Atm_addr asp_subaddr; /* Server ATM subaddress */ + int asp_state; /* Server state */ + int asp_nprefix; /* Number of prefix entries */ +}; + +/* + * Interface information + */ +struct air_int_rsp { + char anp_intf[IFNAMSIZ]; /* Interface name */ + Atm_addr anp_addr; /* ATM address */ + Atm_addr anp_subaddr; /* ATM subaddress */ + u_char anp_sig_proto; /* Signalling protocol */ + u_char anp_sig_state; /* Signalling protocol state */ + char anp_nif_pref[IFNAMSIZ]; /* Netif prefix */ + u_char anp_nif_cnt; /* No. of netifs */ +}; + +/* + * Network interface information + */ +struct air_netif_rsp { + char anp_intf[IFNAMSIZ]; /* Interface name */ + struct sockaddr anp_proto_addr; /* Protocol address */ + char anp_phy_intf[IFNAMSIZ]; /* Interface name */ +}; + +/* + * VCC information + */ +#define O_CNT 8 +struct air_vcc_rsp { + char avp_intf[IFNAMSIZ]; /* Interface name */ + u_short avp_vpi; /* VPI value */ + u_short avp_vci; /* VCI value */ + u_char avp_type; /* Type (SVC or PVC) */ + u_char avp_aal; /* AAL */ + u_char avp_sig_proto; /* Signalling protocol */ + Encaps_t avp_encaps; /* Encapsulation */ + u_char avp_state; /* State (sig mgr specific) */ + char avp_owners[(T_ATM_APP_NAME_LEN+1)*O_CNT];/* VCC users */ + Atm_addr avp_daddr; /* Address of far end */ + Atm_addr avp_dsubaddr; /* Subaddress of far end */ + long avp_ipdus; /* PDUs received from VCC */ + long avp_opdus; /* PDUs sent to VCC */ + long avp_ibytes; /* Bytes received from VCC */ + long avp_obytes; /* Bytes sent to VCC */ + long avp_ierrors; /* Errors receiving from VCC */ + long avp_oerrors; /* Errors sending to VCC */ + time_t avp_tstamp; /* State transition timestamp */ +}; + +/* + * Adapter configuration information + */ +struct air_cfg_rsp { + char acp_intf[IFNAMSIZ]; /* Interface name */ + Atm_config acp_cfg; /* Config info */ +}; +#define acp_vendor acp_cfg.ac_vendor +#define acp_vendapi acp_cfg.ac_vendapi +#define acp_device acp_cfg.ac_device +#define acp_media acp_cfg.ac_media +#define acp_serial acp_cfg.ac_serial +#define acp_bustype acp_cfg.ac_bustype +#define acp_busslot acp_cfg.ac_busslot +#define acp_ram acp_cfg.ac_ram +#define acp_ramsize acp_cfg.ac_ramsize +#define acp_macaddr acp_cfg.ac_macaddr +#define acp_hard_vers acp_cfg.ac_hard_vers +#define acp_firm_vers acp_cfg.ac_firm_vers + +/* + * Version information + */ +struct air_version_rsp { + int avp_version; /* Software version */ +}; + +/* + * Physical interface statistics + */ +struct air_phy_stat_rsp { + char app_intf[IFNAMSIZ]; /* Interface name */ + long app_ipdus; /* PDUs received from I/F */ + long app_opdus; /* PDUs sent to I/F */ + long app_ibytes; /* Bytes received from I/F */ + long app_obytes; /* Bytes sent to I/F */ + long app_ierrors; /* Errors receiving from I/F */ + long app_oerrors; /* Errors sending to I/F */ + long app_cmderrors; /* I/F command errors */ +}; + + +/* + * PF_ATM sub-operation codes + */ +#define AIOCS_CFG_ATT 1 +#define AIOCS_CFG_DET 2 +#define AIOCS_ADD_PVC 32 +#define AIOCS_ADD_ARP 33 +#define AIOCS_DEL_PVC 64 +#define AIOCS_DEL_SVC 65 +#define AIOCS_DEL_ARP 66 +#define AIOCS_SET_ASV 96 +#define AIOCS_SET_NIF 97 +#define AIOCS_SET_PRF 98 +#define AIOCS_SET_MAC 99 +#define AIOCS_INF_VST 160 +#define AIOCS_INF_IPM 161 +#define AIOCS_INF_ARP 162 +#define AIOCS_INF_ASV 163 +#define AIOCS_INF_INT 164 +#define AIOCS_INF_VCC 165 +#define AIOCS_INF_CFG 166 +#define AIOCS_INF_NIF 167 +#define AIOCS_INF_PIS 168 +#define AIOCS_INF_VER 169 + + +/* + * PF_ATM ioctls + */ +#if defined(sun) && !defined(__GNUC__) +#define AIOCCFG _IOW(A, 128, struct atmcfgreq) /* Configure i/f */ +#define AIOCADD _IOW(A, 129, struct atmaddreq) /* Add (e.g. PVC) */ +#define AIOCDEL _IOW(A, 130, struct atmdelreq) /* Delete */ +#define AIOCSET _IOW(A, 132, struct atmsetreq) /* Set (e.g. net i/f) */ +#define AIOCINFO _IOWR(A, 133, struct atminfreq) /* Show kernel info */ +#else +#define AIOCCFG _IOW('A', 128, struct atmcfgreq)/* Configure i/f */ +#define AIOCADD _IOW('A', 129, struct atmaddreq)/* Add (e.g. PVC) */ +#define AIOCDEL _IOW('A', 130, struct atmdelreq)/* Delete */ +#define AIOCSET _IOW('A', 132, struct atmsetreq)/* Set (e.g. net i/f) */ +#define AIOCINFO _IOWR('A', 133, struct atminfreq)/* Show kernel info */ +#endif + +#endif /* _NETATM_ATM_IOCTL_H */ diff --git a/sys/netatm/atm_pcb.h b/sys/netatm/atm_pcb.h new file mode 100644 index 0000000..12ac5d0 --- /dev/null +++ b/sys/netatm/atm_pcb.h @@ -0,0 +1,92 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_pcb.h,v 1.2 1998/07/30 22:30:51 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM socket protocol definitions + * + */ + +#ifndef _NETATM_ATM_PCB_H +#define _NETATM_ATM_PCB_H + + +#ifdef ATM_KERNEL +/* + * ATM Socket PCB + * + * Common structure for all ATM protocol sockets. This control block + * will be used for all ATM socket types. + */ +struct atm_pcb { + struct socket *atp_socket; /* Socket */ + Atm_connection *atp_conn; /* Connection manager token */ + u_char atp_type; /* Protocol type (see below) */ + u_char atp_flags; /* Protocol flags (see below) */ + Atm_attributes atp_attr; /* Socket's call attributes */ + char atp_name[T_ATM_APP_NAME_LEN]; /* Owner's name */ +}; +typedef struct atm_pcb Atm_pcb; + +/* + * Protocol Types + */ +#define ATPT_AAL5 0 /* AAL type 5 protocol */ +#define ATPT_SSCOP 1 /* SSCOP protocol */ +#define ATPT_NUM 2 /* Number of protocols */ + +/* + * PCB Flags + */ + + +/* + * Handy macros + */ +#define sotoatmpcb(so) ((Atm_pcb *)(so)->so_pcb) + + +/* + * ATM Socket Statistics + */ +struct atm_sock_stat { + u_long as_connreq[ATPT_NUM]; /* Connection requests */ + u_long as_inconn[ATPT_NUM]; /* Incoming connection requests */ + u_long as_conncomp[ATPT_NUM]; /* Connections completed */ + u_long as_connfail[ATPT_NUM]; /* Connections failed */ + u_long as_connrel[ATPT_NUM]; /* Connections released */ + u_long as_connclr[ATPT_NUM]; /* Connections cleared */ + u_long as_indrop[ATPT_NUM]; /* Input packets dropped */ + u_long as_outdrop[ATPT_NUM]; /* Output packets dropped */ +}; +#endif /* ATM_KERNEL */ + +#endif /* _NETATM_ATM_PCB_H */ diff --git a/sys/netatm/atm_proto.c b/sys/netatm/atm_proto.c new file mode 100644 index 0000000..ddd1a88 --- /dev/null +++ b/sys/netatm/atm_proto.c @@ -0,0 +1,205 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_proto.c,v 1.6 1998/02/19 19:52:06 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM socket protocol family support definitions + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: atm_proto.c,v 1.6 1998/02/19 19:52:06 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + + +struct protosw atmsw[] = { +{ SOCK_DGRAM, /* ioctl()-only */ + &atmdomain, + 0, + 0, + 0, /* pr_input */ + 0, /* pr_output */ + 0, /* pr_ctlinput */ + 0, /* pr_ctloutput */ + 0, /* pr_ousrreq */ + 0, /* pr_init */ + 0, /* pr_fasttimo */ + 0, /* pr_slowtimo */ + 0, /* pr_drain */ + &atm_dgram_usrreqs, /* pr_usrreqs */ +}, + +{ SOCK_SEQPACKET, /* AAL-5 */ + &atmdomain, + ATM_PROTO_AAL5, + PR_ATOMIC|PR_CONNREQUIRED, + 0, /* pr_input */ + 0, /* pr_output */ + 0, /* pr_ctlinput */ + atm_aal5_ctloutput, /* pr_ctloutput */ + 0, /* pr_ousrreq */ + 0, /* pr_init */ + 0, /* pr_fasttimo */ + 0, /* pr_slowtimo */ + 0, /* pr_drain */ + &atm_aal5_usrreqs, /* pr_usrreqs */ +}, + +#ifdef XXX +{ SOCK_SEQPACKET, /* SSCOP */ + &atmdomain, + ATM_PROTO_SSCOP, + PR_ATOMIC|PR_CONNREQUIRED|PR_WANTRCVD, + x, /* pr_input */ + x, /* pr_output */ + x, /* pr_ctlinput */ + x, /* pr_ctloutput */ + 0, /* pr_ousrreq */ + 0, /* pr_init */ + 0, /* pr_fasttimo */ + 0, /* pr_slowtimo */ + x, /* pr_drain */ + x, /* pr_usrreqs */ +}, +#endif +}; + +struct domain atmdomain = { + AF_ATM, + "atm", +#if defined(__FreeBSD__) + atm_initialize, +#else + 0, +#endif + 0, + 0, + atmsw, + &atmsw[sizeof(atmsw) / sizeof(atmsw[0])] +}; + +#ifdef __FreeBSD__ +DOMAIN_SET(atm); +#endif + + +#if (defined(__FreeBSD__) && (BSD >= 199506)) +/* + * Protocol request not supported + * + * Arguments: + * so pointer to socket + * + * Returns: + * errno error - operation not supported + * + */ +int +atm_proto_notsupp1(so) + struct socket *so; +{ + return (EOPNOTSUPP); +} + + +/* + * Protocol request not supported + * + * Arguments: + * so pointer to socket + * addr pointer to protocol address + * p pointer to process + * + * Returns: + * errno error - operation not supported + * + */ +int +atm_proto_notsupp2(so, addr, p) + struct socket *so; + struct sockaddr *addr; + struct proc *p; +{ + return (EOPNOTSUPP); +} + + +/* + * Protocol request not supported + * + * Arguments: + * so pointer to socket + * addr pointer to pointer to protocol address + * + * Returns: + * errno error - operation not supported + * + */ +int +atm_proto_notsupp3(so, addr) + struct socket *so; + struct sockaddr **addr; +{ + return (EOPNOTSUPP); +} + + +/* + * Protocol request not supported + * + * Arguments: + * so pointer to socket + * i integer + * m pointer to kernel buffer + * addr pointer to protocol address + * m2 pointer to kernel buffer + * p pointer to process + * + * Returns: + * errno error - operation not supported + * + */ +int +atm_proto_notsupp4(so, i, m, addr, m2, p) + struct socket *so; + int i; + KBuffer *m; + struct sockaddr *addr; + KBuffer *m2; + struct proc *p; +{ + return (EOPNOTSUPP); +} + +#endif /* (defined(__FreeBSD__) && (BSD >= 199506)) */ + diff --git a/sys/netatm/atm_sap.h b/sys/netatm/atm_sap.h new file mode 100644 index 0000000..1386516 --- /dev/null +++ b/sys/netatm/atm_sap.h @@ -0,0 +1,81 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_sap.h,v 1.3 1998/02/19 19:59:38 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM Services definitions + * + */ + +#ifndef _NETATM_ATM_SAP_H +#define _NETATM_ATM_SAP_H + +/* + * Service Access Point (SAP) + * + * A SAP specifies the definition of an interface used between two adjacent + * layers. The SAP is named for the services the lower layer provides to + * the upper layer. + * + * The types of SAPs used are: + * Stack - defines the interfaces between stack service entities. + * These are further divided into: + * + * Stack class SAP - which identifies the type of interface + * used. All SAPs of a particular class will provide + * the same interface services to the higher layer. + * All stack command codes are constructed using class + * SAP values. + * + * Stack instance SAP - which identifies the specific identity + * of the layer providing the class interface. + */ +typedef u_short Sap_t; + +#define SAP_TYPE_MASK 0xc000 +#define SAP_TYPE_STACK 0x8000 +#define SAP_CLASS_MASK 0xff80 + +#define SAP_STACK(c, i) (SAP_TYPE_STACK | ((c) << 7) | (i)) + +/* Stack SAPs */ +#define SAP_ATM SAP_STACK(1, 0) /* ATM cell */ +#define SAP_SAR SAP_STACK(2, 0) /* AAL SAR */ +#define SAP_SAR_AAL3_4 SAP_STACK(2, 3) /* AAL3/4 SAR */ +#define SAP_SAR_AAL5 SAP_STACK(2, 5) /* AAL5 SAR */ +#define SAP_CPCS SAP_STACK(3, 0) /* AAL CPCS */ +#define SAP_CPCS_AAL3_4 SAP_STACK(3, 3) /* AAL3/4 CPCS */ +#define SAP_CPCS_AAL5 SAP_STACK(3, 5) /* AAL5 CPCS */ +#define SAP_SSCOP SAP_STACK(4, 0) /* ITU Q.2110 */ +#define SAP_SSCF_UNI SAP_STACK(5, 0) /* ITU Q.2130 */ +#define SAP_SSCF_NNI SAP_STACK(6, 0) /* ITU Q.2140 */ + +#endif /* _NETATM_ATM_SAP_H */ diff --git a/sys/netatm/atm_sigmgr.h b/sys/netatm/atm_sigmgr.h new file mode 100644 index 0000000..1b9388e --- /dev/null +++ b/sys/netatm/atm_sigmgr.h @@ -0,0 +1,109 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_sigmgr.h,v 1.7 1998/03/24 20:43:59 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM Signalling Manager definitions + * + */ + +#ifndef _NETATM_ATM_SIGMGR_H +#define _NETATM_ATM_SIGMGR_H + +#ifdef ATM_KERNEL +/* + * Structure common to all ATM Signalling Managers. Each Signalling + * Manager must create one of these and use it to register itself + * with the system. + */ +struct sigmgr { + struct sigmgr *sm_next; /* Next registered sigmgr */ + u_char sm_proto; /* Signalling protocol (see below) */ + struct siginst *sm_prinst; /* List of protocol instances */ +/* Exported functions */ + int (*sm_attach) /* Attach interface */ + __P((struct sigmgr *, struct atm_pif *)); + int (*sm_detach) /* Detach interface */ + __P((struct atm_pif *)); + int (*sm_setup) /* Connection setup */ + __P((Atm_connvc *, int *)); + int (*sm_accept) /* Call accepted */ + __P((struct vccb *, int *)); + int (*sm_reject) /* Call rejected */ + __P((struct vccb *, int *)); + int (*sm_release) /* Connection release */ + __P((struct vccb *, int *)); + int (*sm_free) /* Free connection resources */ + __P((struct vccb *)); + int (*sm_ioctl) /* Ioctl handler */ + __P((int, caddr_t, caddr_t)); +}; +#endif /* ATM_KERNEL */ + +/* + * ATM Signalling Protocols + */ +#define ATM_SIG_PVC 1 /* PVC-only */ +#define ATM_SIG_SPANS 2 /* Fore Systems SPANS */ +#define ATM_SIG_UNI30 3 /* ATM Forum UNI 3.0 */ +#define ATM_SIG_UNI31 4 /* ATM Forum UNI 3.1 */ +#define ATM_SIG_UNI40 5 /* ATM Forum UNI 4.0 */ + + +#ifdef ATM_KERNEL +/* + * Signalling Protocol Instance control block header. Common header for + * every signalling protocol instance control block. + */ +struct siginst { + struct siginst *si_next; /* Next sigmgr protocol instance */ + struct atm_pif *si_pif; /* Device interface */ + Atm_addr si_addr; /* Interface ATM address */ + Atm_addr si_subaddr; /* Interface ATM subaddress */ + Queue_t si_vccq; /* VCCB queue */ + u_short si_state; /* Protocol state (sigmgr specific) */ + +/* Exported protocol services */ + struct ip_serv *si_ipserv; /* IP/ATM services */ +}; + + +/* + * Sigmgr function return codes + */ +#define CALL_PROCEEDING 1 /* Connection request is in progress */ +#define CALL_FAILED 2 /* Connection request failed */ +#define CALL_CONNECTED 3 /* Connection setup successful */ +#define CALL_CLEARED 4 /* Connection has been terminated */ + +#endif /* ATM_KERNEL */ + +#endif /* _NETATM_ATM_SIGMGR_H */ diff --git a/sys/netatm/atm_signal.c b/sys/netatm/atm_signal.c new file mode 100644 index 0000000..8acbf7a --- /dev/null +++ b/sys/netatm/atm_signal.c @@ -0,0 +1,512 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_signal.c,v 1.8 1998/03/24 20:45:37 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * General ATM signalling management + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: atm_signal.c,v 1.8 1998/03/24 20:45:37 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + + +/* + * Local variables + */ +static struct sigmgr *atm_sigmgr_head = NULL; +static struct stack_defn *atm_stack_head = NULL; + + +/* + * Register a new Signalling Manager + * + * Each Signalling Manager must register itself here upon completing + * its internal initialization. This applies to both linked and loaded + * managers. + * + * Arguments: + * smp pointer to Signalling Manager description + * + * Returns: + * 0 registration was successful + * errno registration failed - reason indicated + * + */ +int +atm_sigmgr_register(smp) + struct sigmgr *smp; +{ + struct sigmgr *smp2; + int s = splnet(); + + /* + * See if we need to be initialized + */ + if (!atm_init) + atm_initialize(); + + /* + * Make sure there's only one instance of each protocol + */ + for (smp2 = atm_sigmgr_head; smp2 != NULL; smp2 = smp2->sm_next) { + if (smp->sm_proto == smp2->sm_proto) { + (void) splx(s); + return (EEXIST); + } + } + + /* + * Looks okay, link it in + */ + LINK2TAIL(smp, struct sigmgr, atm_sigmgr_head, sm_next); + + (void) splx(s); + return (0); +} + + +/* + * De-register a Signalling Manager + * + * Each Signalling Manager must de-register (is this really a word?) + * itself before removing itself from the system. This really only + * applies to managers about to be modunload'ed. It is the signal + * manager's responsibility to ensure that all its protocol instances + * have been successfully terminated before de-registering itself. + * + * Arguments: + * smp pointer to Signalling Manager description + * + * Returns: + * 0 deregistration was successful + * errno deregistration failed - reason indicated + * + */ +int +atm_sigmgr_deregister(smp) + struct sigmgr *smp; +{ + int found, s = splnet(); + + /* + * Unlink descriptor + */ + UNLINKF(smp, struct sigmgr, atm_sigmgr_head, sm_next, found); + + (void) splx(s); + + if (!found) + return (ENOENT); + + return (0); +} + + +/* + * Attach a Signalling Manager to an ATM physical interface + * + * Each ATM physical interface must have a signalling manager attached to + * itself for the signalling protocol to be run across this interface. The + * interface must be registered and completely initialized before the attach, + * since the signalling manager may initiate virtual circuit activity as part + * its response to this call. + * + * Called at splnet. + * + * Arguments: + * pip pointer to atm physical interface control block + * proto requested signalling protocol + * + * Returns: + * 0 attach successful + * errno attach failed - reason indicated + * + */ +int +atm_sigmgr_attach(pip, proto) + struct atm_pif *pip; + u_char proto; +{ + struct atm_pif *tp; + struct sigmgr *smp; + int err; + + /* + * Make sure interface is registered + */ + for (tp = atm_interface_head; tp != NULL; tp = tp->pif_next) { + if (tp == pip) + break; + } + if (tp == NULL) { + return (ENOENT); + } + + /* + * Make sure no signalling manager is already attached + */ + if (pip->pif_sigmgr != NULL) { + return (EEXIST); + } + + /* + * Must have at least one network interface defined + */ + if (pip->pif_nif == NULL) + return (ETOOMANYREFS); + + /* + * Find requested protocol + */ + for (smp = atm_sigmgr_head; smp != NULL; smp = smp->sm_next) { + if (smp->sm_proto == proto) + break; + } + if (smp == NULL) { + return (EPROTONOSUPPORT); + } + + /* + * Tell the signal manager about it + */ + err = (*smp->sm_attach)(smp, pip); + + /* + * Tell all registered convergence modules about this + */ + if (!err) { + struct atm_nif *nip; + struct atm_ncm *ncp; + + for (nip = pip->pif_nif; nip; nip = nip->nif_pnext) { + for (ncp = atm_netconv_head; ncp; ncp = ncp->ncm_next) { + if (err = (*ncp->ncm_stat) + (NCM_SIGATTACH, nip, 0)) + break; + } + if (err) + break; + } + + if (err) { + /* + * Someone's unhappy, so back all this out + */ + (void) atm_sigmgr_detach(pip); + } + } + + return (err); +} + + +/* + * Detach an ATM physical interface from a Signalling Manager + * + * The ATM interface must be detached from the signalling manager + * before the interface can be de-registered. + * + * Called at splnet. + * + * Arguments: + * pip pointer to atm physical interface control block + * + * Returns: + * 0 detach successful + * errno detach failed - reason indicated + * + */ +int +atm_sigmgr_detach(pip) + struct atm_pif *pip; +{ + struct atm_pif *tp; + struct atm_nif *nip; + struct atm_ncm *ncp; + int err; + + + /* + * Make sure interface is registered + */ + for (tp = atm_interface_head; tp != NULL; tp = tp->pif_next) { + if (tp == pip) + break; + } + if (tp == NULL) { + return (ENOENT); + } + + /* + * Make sure a signalling manager is attached + */ + if (pip->pif_sigmgr == NULL) { + return (ENOENT); + } + + /* + * Tell all registered convergence modules about this + */ + for (nip = pip->pif_nif; nip; nip = nip->nif_pnext) { + for (ncp = atm_netconv_head; ncp; ncp = ncp->ncm_next) { + (void) (*ncp->ncm_stat)(NCM_SIGDETACH, nip, 0); + } + } + + /* + * Tell the signal manager about it + * + * NOTE: + * The only reason this should ever fail is if things are really + * hosed up somewhere, in which case doing a bunch of NCM_SIGATTACH's + * here just doesn't seem to help much. + */ + err = (*pip->pif_sigmgr->sm_detach)(pip); + + return (err); +} + + +/* + * Register an ATM Stack Service + * + * Each ATM stack service provider must register its provided service(s) here. + * Each service must be registered separately. Service providers include + * both loaded and linked kernel modules. Device driver services are NOT + * registered here - their service registry is performed implicitly through + * the device interface structure stack services list (pif_services). + * + * Arguments: + * sdp pointer to stack service definition block + * + * Returns: + * 0 registration successful + * errno registration failed - reason indicated + * + */ +int +atm_stack_register(sdp) + struct stack_defn *sdp; +{ + struct stack_defn *tdp; + int s = splnet(); + + /* + * See if we need to be initialized + */ + if (!atm_init) + atm_initialize(); + + /* + * Ensure no duplicates + */ + for (tdp = atm_stack_head; tdp != NULL; tdp = tdp->sd_next) { + if (tdp->sd_sap == sdp->sd_sap) + break; + } + if (tdp != NULL) { + (void) splx(s); + return (EEXIST); + } + + /* + * Add stack to list + */ + LINK2TAIL(sdp, struct stack_defn, atm_stack_head, sd_next); + + (void) splx(s); + return (0); +} + + +/* + * De-register an ATM Stack Service + * + * Each ATM stack service provider must de-register its registered service(s) + * before terminating the service. Specifically, loaded kernel modules + * must de-register their services before unloading themselves. + * + * Arguments: + * sdp pointer to stack service definition block + * + * Returns: + * 0 de-registration successful + * errno de-registration failed - reason indicated + * + */ +int +atm_stack_deregister(sdp) + struct stack_defn *sdp; +{ + int found, s = splnet(); + + /* + * Remove service from list + */ + UNLINKF(sdp, struct stack_defn, atm_stack_head, sd_next, found); + (void) splx(s); + + if (!found) + return (ENOENT); + + return (0); +} + + +/* + * Create and Instantiate a Stack + * + * For the requested stack list, locate the stack service definitions + * necessary to build the stack to implement the listed services. + * The stack service definitions provided by the interface device-driver + * are always preferred, since they are (hopefully) done with + * hardware assistance from the interface card. + * + * After the stack has been built, the selected services are called to + * notify them of the new stack instantiation. Each service should then + * allocate all the resources it requires for this new stack instance. + * The service should then wait for subsequent protocol notification + * via its stack command handlers. + * + * Must be called at splnet. + * + * Arguments: + * cvp pointer to connection vcc block for the created stack + * tlp pointer to stack list + * upf top-of-stack CM upper command handler + * + * Returns: + * 0 stack successfully created + * errno failed - reason indicated + * + */ +int +atm_create_stack(cvp, tlp, upf) + Atm_connvc *cvp; + struct stack_list *tlp; + void (*upf)__P((int, void *, int, int)); +{ + struct stack_defn *sdp, usd; + struct stack_inst svs; + struct atm_pif *pip = cvp->cvc_attr.nif->nif_pif; + int i, err; + + + /* + * Initialize stack (element 0 is for owner's services) + */ + svs.si_srvc[1] = sdp = NULL; + + /* + * Locate service provider for each service in the + * stack list. We prefer interface driver providers + * over kernel module providers. + */ + for (i = 0; i < STACK_CNT; i++) { + Sap_t sap; + + /* Stack list is 0-terminated */ + if ((sap = tlp->sl_sap[i]) == 0) + break; + + /* + * Search interface's services + */ + for (sdp = pip->pif_services; sdp; sdp = sdp->sd_next) + if (sdp->sd_sap == sap) + break; + if (sdp == NULL) { + + /* + * Search kernel services + */ + for (sdp = atm_stack_head; sdp; + sdp = sdp->sd_next) + if (sdp->sd_sap == sap) + break; + } + if (sdp == NULL) { + + /* + * Requested service id not found + */ + return (ENOENT); + } + + /* + * Save stack definition for this service + */ + svs.si_srvc[i+1] = sdp; + + /* + * Quit loop if this service is terminal, ie. if + * it takes care of the rest of the stack. + */ + if (sdp->sd_flag & SDF_TERM) + break; + } + + /* + * Ensure stack instance array is located and terminated + */ + if ((svs.si_srvc[1] == NULL) || !(sdp->sd_flag & SDF_TERM)) { + return (ENOENT); + } + + /* + * Setup owner service definition + */ + KM_ZERO((caddr_t)&usd, sizeof(struct stack_defn)); + usd.sd_upper = upf; + usd.sd_toku = cvp; + svs.si_srvc[0] = &usd; + + /* + * Instantiate the stack + */ + err = (*svs.si_srvc[1]->sd_inst)(&svs.si_srvc[0], cvp); + if (err) { + return (err); + } + + /* + * Save top 'o stack info + */ + cvp->cvc_lower = svs.si_srvc[1]->sd_lower; + cvp->cvc_tokl = svs.si_srvc[1]->sd_toku; + + return (0); +} + diff --git a/sys/netatm/atm_socket.c b/sys/netatm/atm_socket.c new file mode 100644 index 0000000..2370a15 --- /dev/null +++ b/sys/netatm/atm_socket.c @@ -0,0 +1,1311 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_socket.c,v 1.3 1998/07/30 22:30:53 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM common socket protocol processing + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: atm_socket.c,v 1.3 1998/07/30 22:30:53 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + + +/* + * Local functions + */ + + +/* + * Local variables + */ +static struct sp_info atm_pcb_pool = { + "atm pcb pool", /* si_name */ + sizeof(Atm_pcb), /* si_blksiz */ + 10, /* si_blkcnt */ + 100 /* si_maxallow */ +}; + +static struct t_atm_cause atm_sock_cause = { + T_ATM_ITU_CODING, + T_ATM_LOC_USER, + T_ATM_CAUSE_UNSPECIFIED_NORMAL, + {0, 0, 0, 0} +}; + + +/* + * Allocate resources for a new ATM socket + * + * Called at splnet. + * + * Arguments: + * so pointer to socket + * send socket send buffer maximum + * recv socket receive buffer maximum + * + * Returns: + * 0 attach successful + * errno attach failed - reason indicated + * + */ +int +atm_sock_attach(so, send, recv) + struct socket *so; + u_long send; + u_long recv; +{ + Atm_pcb *atp = sotoatmpcb(so); + int err; + + /* + * Make sure initialization has happened + */ + if (!atm_init) + atm_initialize(); + + /* + * Make sure we're not already attached + */ + if (atp) + return (EISCONN); + + /* + * Reserve socket buffer space, if not already done + */ + if ((so->so_snd.sb_hiwat == 0) || (so->so_rcv.sb_hiwat == 0)) { + err = soreserve(so, send, recv); + if (err) + return (err); + } + + /* + * Allocate and initialize our control block + */ + atp = (Atm_pcb *)atm_allocate(&atm_pcb_pool); + if (atp == NULL) + return (ENOMEM); + + atp->atp_socket = so; + so->so_pcb = (caddr_t)atp; + return (0); +} + + +/* + * Detach from socket and free resources + * + * Called at splnet. + * + * Arguments: + * so pointer to socket + * + * Returns: + * 0 detach successful + * errno detach failed - reason indicated + * + */ +int +atm_sock_detach(so) + struct socket *so; +{ + Atm_pcb *atp = sotoatmpcb(so); + + /* + * Make sure we're still attached + */ + if (atp == NULL) + return (ENOTCONN); + + /* + * Terminate any (possibly pending) connection + */ + if (atp->atp_conn) { + (void) atm_sock_disconnect(so); + } + + /* + * Break links and free control blocks + */ + so->so_pcb = NULL; + sofree(so); + + atm_free((caddr_t)atp); + + return (0); +} + + +/* + * Bind local address to socket + * + * Called at splnet. + * + * Arguments: + * so pointer to socket + * addr pointer to protocol address + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +int +atm_sock_bind(so, addr) + struct socket *so; + struct sockaddr *addr; +{ + Atm_pcb *atp = sotoatmpcb(so); + Atm_attributes attr; + struct sockaddr_atm *satm; + struct t_atm_sap_addr *sapadr; + struct t_atm_sap_layer2 *sapl2; + struct t_atm_sap_layer3 *sapl3; + struct t_atm_sap_appl *sapapl; + + /* + * Make sure we're still attached + */ + if (atp == NULL) + return (ENOTCONN); + + /* + * Can't change local address once we've started connection process + */ + if (atp->atp_conn != NULL) + return (EADDRNOTAVAIL); + + /* + * Validate requested local address + */ + satm = (struct sockaddr_atm *)addr; + if (satm->satm_family != AF_ATM) + return (EAFNOSUPPORT); + + sapadr = &satm->satm_addr.t_atm_sap_addr; + if (sapadr->SVE_tag_addr == T_ATM_PRESENT) { + if (sapadr->address_format == T_ATM_ENDSYS_ADDR) { + if (sapadr->SVE_tag_selector != T_ATM_PRESENT) + return (EINVAL); + } else if (sapadr->address_format == T_ATM_E164_ADDR) { + if (sapadr->SVE_tag_selector != T_ATM_ABSENT) + return (EINVAL); + } else + return (EINVAL); + } else if ((sapadr->SVE_tag_addr != T_ATM_ABSENT) && + (sapadr->SVE_tag_addr != T_ATM_ANY)) + return (EINVAL); + if (sapadr->address_length > ATM_ADDR_LEN) + return (EINVAL); + + sapl2 = &satm->satm_addr.t_atm_sap_layer2; + if (sapl2->SVE_tag == T_ATM_PRESENT) { + if ((sapl2->ID_type != T_ATM_SIMPLE_ID) && + (sapl2->ID_type != T_ATM_USER_ID)) + return (EINVAL); + } else if ((sapl2->SVE_tag != T_ATM_ABSENT) && + (sapl2->SVE_tag != T_ATM_ANY)) + return (EINVAL); + + sapl3 = &satm->satm_addr.t_atm_sap_layer3; + if (sapl3->SVE_tag == T_ATM_PRESENT) { + if ((sapl3->ID_type != T_ATM_SIMPLE_ID) && + (sapl3->ID_type != T_ATM_IPI_ID) && + (sapl3->ID_type != T_ATM_SNAP_ID) && + (sapl3->ID_type != T_ATM_USER_ID)) + return (EINVAL); + } else if ((sapl3->SVE_tag != T_ATM_ABSENT) && + (sapl3->SVE_tag != T_ATM_ANY)) + return (EINVAL); + + sapapl = &satm->satm_addr.t_atm_sap_appl; + if (sapapl->SVE_tag == T_ATM_PRESENT) { + if ((sapapl->ID_type != T_ATM_ISO_APP_ID) && + (sapapl->ID_type != T_ATM_USER_APP_ID) && + (sapapl->ID_type != T_ATM_VENDOR_APP_ID)) + return (EINVAL); + } else if ((sapapl->SVE_tag != T_ATM_ABSENT) && + (sapapl->SVE_tag != T_ATM_ANY)) + return (EINVAL); + + /* + * Create temporary attributes list so that we can check out the + * new bind parameters before we modify the socket's values; + */ + attr = atp->atp_attr; + attr.called.tag = sapadr->SVE_tag_addr; + KM_COPY(&sapadr->address_format, &attr.called.addr, sizeof(Atm_addr)); + + attr.blli.tag_l2 = sapl2->SVE_tag; + if (sapl2->SVE_tag == T_ATM_PRESENT) { + attr.blli.v.layer_2_protocol.ID_type = sapl2->ID_type; + KM_COPY(&sapl2->ID, &attr.blli.v.layer_2_protocol.ID, + sizeof(attr.blli.v.layer_2_protocol.ID)); + } + + attr.blli.tag_l3 = sapl3->SVE_tag; + if (sapl3->SVE_tag == T_ATM_PRESENT) { + attr.blli.v.layer_3_protocol.ID_type = sapl3->ID_type; + KM_COPY(&sapl3->ID, &attr.blli.v.layer_3_protocol.ID, + sizeof(attr.blli.v.layer_3_protocol.ID)); + } + + attr.bhli.tag = sapapl->SVE_tag; + if (sapapl->SVE_tag == T_ATM_PRESENT) { + attr.bhli.v.ID_type = sapapl->ID_type; + KM_COPY(&sapapl->ID, &attr.bhli.v.ID, + sizeof(attr.bhli.v.ID)); + } + + /* + * Make sure we have unique listening attributes + */ + if (atm_cm_match(&attr, NULL) != NULL) + return (EADDRINUSE); + + /* + * Looks good, save new attributes + */ + atp->atp_attr = attr; + + return (0); +} + + +/* + * Listen for incoming connections + * + * Called at splnet. + * + * Arguments: + * so pointer to socket + * epp pointer to endpoint definition structure + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +int +atm_sock_listen(so, epp) + struct socket *so; + Atm_endpoint *epp; +{ + Atm_pcb *atp = sotoatmpcb(so); + + /* + * Make sure we're still attached + */ + if (atp == NULL) + return (ENOTCONN); + + /* + * Start listening for incoming calls + */ + return (atm_cm_listen(epp, atp, &atp->atp_attr, &atp->atp_conn)); +} + + +/* + * Connect socket to peer + * + * Called at splnet. + * + * Arguments: + * so pointer to socket + * addr pointer to protocol address + * epp pointer to endpoint definition structure + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +int +atm_sock_connect(so, addr, epp) + struct socket *so; + struct sockaddr *addr; + Atm_endpoint *epp; +{ + Atm_pcb *atp = sotoatmpcb(so); + struct sockaddr_atm *satm; + struct t_atm_sap_addr *sapadr; + struct t_atm_sap_layer2 *sapl2; + struct t_atm_sap_layer3 *sapl3; + struct t_atm_sap_appl *sapapl; + int err; + + /* + * Make sure we're still attached + */ + if (atp == NULL) + return (ENOTCONN); + + /* + * Validate requested peer address + */ + satm = (struct sockaddr_atm *)addr; + if (satm->satm_family != AF_ATM) + return (EAFNOSUPPORT); + + sapadr = &satm->satm_addr.t_atm_sap_addr; + if (sapadr->SVE_tag_addr != T_ATM_PRESENT) + return (EINVAL); + if (sapadr->address_format == T_ATM_ENDSYS_ADDR) { + if (sapadr->SVE_tag_selector != T_ATM_PRESENT) + return (EINVAL); + } else if (sapadr->address_format == T_ATM_E164_ADDR) { + if (sapadr->SVE_tag_selector != T_ATM_ABSENT) + return (EINVAL); + } else if (sapadr->address_format == T_ATM_PVC_ADDR) { + if (sapadr->SVE_tag_selector != T_ATM_ABSENT) + return (EINVAL); + } else + return (EINVAL); + if (sapadr->address_length > ATM_ADDR_LEN) + return (EINVAL); + + sapl2 = &satm->satm_addr.t_atm_sap_layer2; + if (sapl2->SVE_tag == T_ATM_PRESENT) { + if ((sapl2->ID_type != T_ATM_SIMPLE_ID) && + (sapl2->ID_type != T_ATM_USER_ID)) + return (EINVAL); + } else if (sapl2->SVE_tag != T_ATM_ABSENT) + return (EINVAL); + + sapl3 = &satm->satm_addr.t_atm_sap_layer3; + if (sapl3->SVE_tag == T_ATM_PRESENT) { + if ((sapl3->ID_type != T_ATM_SIMPLE_ID) && + (sapl3->ID_type != T_ATM_IPI_ID) && + (sapl3->ID_type != T_ATM_SNAP_ID) && + (sapl3->ID_type != T_ATM_USER_ID)) + return (EINVAL); + } else if (sapl3->SVE_tag != T_ATM_ABSENT) + return (EINVAL); + + sapapl = &satm->satm_addr.t_atm_sap_appl; + if (sapapl->SVE_tag == T_ATM_PRESENT) { + if ((sapapl->ID_type != T_ATM_ISO_APP_ID) && + (sapapl->ID_type != T_ATM_USER_APP_ID) && + (sapapl->ID_type != T_ATM_VENDOR_APP_ID)) + return (EINVAL); + } else if (sapapl->SVE_tag != T_ATM_ABSENT) + return (EINVAL); + + /* + * Select an outgoing network interface + */ + if (atp->atp_attr.nif == NULL) { + struct atm_pif *pip; + + for (pip = atm_interface_head; pip != NULL; + pip = pip->pif_next) { + if (pip->pif_nif != NULL) { + atp->atp_attr.nif = pip->pif_nif; + break; + } + } + if (atp->atp_attr.nif == NULL) + return (ENXIO); + } + + /* + * Set supplied connection attributes + */ + atp->atp_attr.called.tag = T_ATM_PRESENT; + KM_COPY(&sapadr->address_format, &atp->atp_attr.called.addr, + sizeof(Atm_addr)); + + atp->atp_attr.blli.tag_l2 = sapl2->SVE_tag; + if (sapl2->SVE_tag == T_ATM_PRESENT) { + atp->atp_attr.blli.v.layer_2_protocol.ID_type = sapl2->ID_type; + KM_COPY(&sapl2->ID, &atp->atp_attr.blli.v.layer_2_protocol.ID, + sizeof(atp->atp_attr.blli.v.layer_2_protocol.ID)); + } + + atp->atp_attr.blli.tag_l3 = sapl3->SVE_tag; + if (sapl3->SVE_tag == T_ATM_PRESENT) { + atp->atp_attr.blli.v.layer_3_protocol.ID_type = sapl3->ID_type; + KM_COPY(&sapl3->ID, &atp->atp_attr.blli.v.layer_3_protocol.ID, + sizeof(atp->atp_attr.blli.v.layer_3_protocol.ID)); + } + + atp->atp_attr.bhli.tag = sapapl->SVE_tag; + if (sapapl->SVE_tag == T_ATM_PRESENT) { + atp->atp_attr.bhli.v.ID_type = sapapl->ID_type; + KM_COPY(&sapapl->ID, &atp->atp_attr.bhli.v.ID, + sizeof(atp->atp_attr.bhli.v.ID)); + } + + /* + * We're finally ready to initiate the ATM connection + */ + soisconnecting(so); + atm_sock_stat.as_connreq[atp->atp_type]++; + err = atm_cm_connect(epp, atp, &atp->atp_attr, &atp->atp_conn); + if (err == 0) { + /* + * Connection is setup + */ + atm_sock_stat.as_conncomp[atp->atp_type]++; + soisconnected(so); + + } else if (err == EINPROGRESS) { + /* + * We've got to wait for a connected event + */ + err = 0; + + } else { + /* + * Call failed... + */ + atm_sock_stat.as_connfail[atp->atp_type]++; + soisdisconnected(so); + } + + return (err); +} + + +/* + * Disconnect connected socket + * + * Called at splnet. + * + * Arguments: + * so pointer to socket + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +int +atm_sock_disconnect(so) + struct socket *so; +{ + Atm_pcb *atp = sotoatmpcb(so); + struct t_atm_cause *cause; + int err; + + /* + * Make sure we're still attached + */ + if (atp == NULL) + return (ENOTCONN); + + /* + * Release the ATM connection + */ + if (atp->atp_conn) { + if (atp->atp_attr.cause.tag == T_ATM_PRESENT) + cause = &atp->atp_attr.cause.v; + else + cause = &atm_sock_cause; + err = atm_cm_release(atp->atp_conn, cause); + if (err) + log(LOG_ERR, "atm_sock_disconnect: release fail (%d)\n", + err); + atm_sock_stat.as_connrel[atp->atp_type]++; + atp->atp_conn = NULL; + } + + soisdisconnected(so); + + return (0); +} + + +/* + * Retrieve local socket address + * + * Called at splnet. + * + * Arguments: + * so pointer to socket + * addr pointer to pointer to contain protocol address + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +int +atm_sock_sockaddr(so, addr) + struct socket *so; + struct sockaddr **addr; +{ + struct sockaddr_atm *satm; + struct t_atm_sap_addr *saddr; + Atm_pcb *atp = sotoatmpcb(so); + + /* + * Return local interface address, if known + */ + satm = KM_ALLOC(sizeof *satm, M_SONAME, M_WAITOK); + if (satm == NULL) + return (ENOMEM); + + KM_ZERO(satm, sizeof(*satm)); + satm->satm_family = AF_ATM; +#if (defined(BSD) && (BSD >= 199103)) + satm->satm_len = sizeof(*satm); +#endif + + saddr = &satm->satm_addr.t_atm_sap_addr; + if (atp->atp_attr.nif && atp->atp_attr.nif->nif_pif->pif_siginst) { + saddr->SVE_tag_addr = T_ATM_PRESENT; + ATM_ADDR_SEL_COPY( + &atp->atp_attr.nif->nif_pif->pif_siginst->si_addr, + atp->atp_attr.nif->nif_sel, saddr); + if (saddr->address_format == T_ATM_ENDSYS_ADDR) + saddr->SVE_tag_selector = T_ATM_PRESENT; + else + saddr->SVE_tag_selector = T_ATM_ABSENT; + } else { + saddr->SVE_tag_addr = T_ATM_ABSENT; + saddr->SVE_tag_selector = T_ATM_ABSENT; + saddr->address_format = T_ATM_ABSENT; + } + satm->satm_addr.t_atm_sap_layer2.SVE_tag = T_ATM_ABSENT; + satm->satm_addr.t_atm_sap_layer3.SVE_tag = T_ATM_ABSENT; + satm->satm_addr.t_atm_sap_appl.SVE_tag = T_ATM_ABSENT; + + *addr = (struct sockaddr *)satm; + return (0); +} + + +/* + * Retrieve peer socket address + * + * Called at splnet. + * + * Arguments: + * so pointer to socket + * addr pointer to pointer to contain protocol address + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +int +atm_sock_peeraddr(so, addr) + struct socket *so; + struct sockaddr **addr; +{ + struct sockaddr_atm *satm; + struct t_atm_sap_addr *saddr; + Atm_pcb *atp = sotoatmpcb(so); + Atm_connvc *cvp; + + /* + * Return remote address, if known + */ + satm = KM_ALLOC(sizeof *satm, M_SONAME, M_WAITOK); + if (satm == NULL) + return (ENOMEM); + + KM_ZERO(satm, sizeof(*satm)); + satm->satm_family = AF_ATM; +#if (defined(BSD) && (BSD >= 199103)) + satm->satm_len = sizeof(*satm); +#endif + + saddr = &satm->satm_addr.t_atm_sap_addr; + if (so->so_state & SS_ISCONNECTED) { + cvp = atp->atp_conn->co_connvc; + saddr->SVE_tag_addr = T_ATM_PRESENT; + if (cvp->cvc_flags & CVCF_CALLER) { + ATM_ADDR_COPY(&cvp->cvc_attr.called.addr, saddr); + } else { + if (cvp->cvc_attr.calling.tag == T_ATM_PRESENT) { + ATM_ADDR_COPY(&cvp->cvc_attr.calling.addr, + saddr); + } else { + saddr->SVE_tag_addr = T_ATM_ABSENT; + saddr->address_format = T_ATM_ABSENT; + } + } + if (saddr->address_format == T_ATM_ENDSYS_ADDR) + saddr->SVE_tag_selector = T_ATM_PRESENT; + else + saddr->SVE_tag_selector = T_ATM_ABSENT; + } else { + saddr->SVE_tag_addr = T_ATM_ABSENT; + saddr->SVE_tag_selector = T_ATM_ABSENT; + saddr->address_format = T_ATM_ABSENT; + } + satm->satm_addr.t_atm_sap_layer2.SVE_tag = T_ATM_ABSENT; + satm->satm_addr.t_atm_sap_layer3.SVE_tag = T_ATM_ABSENT; + satm->satm_addr.t_atm_sap_appl.SVE_tag = T_ATM_ABSENT; + + *addr = (struct sockaddr *)satm; + return (0); +} + + +/* + * Common setsockopt processing + * + * Called at splnet. + * + * Arguments: + * so pointer to socket + * sopt pointer to socket option info + * atp pointer to ATM PCB + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +int +atm_sock_setopt(so, sopt, atp) + struct socket *so; + struct sockopt *sopt; + Atm_pcb *atp; +{ + int err = 0; + union { + struct t_atm_aal5 aal5; + struct t_atm_traffic trf; + struct t_atm_bearer brr; + struct t_atm_bhli bhl; + struct t_atm_blli bll; + Atm_addr addr; + struct t_atm_cause cau; + struct t_atm_qos qos; + struct t_atm_transit trn; + struct t_atm_net_intf nif; + struct t_atm_llc llc; + struct t_atm_app_name appn; + } p; + +#define MAXVAL(bits) ((1 << bits) - 1) +#define MAXMASK(bits) (~MAXVAL(bits)) + + switch (sopt->sopt_name) { + + case T_ATM_AAL5: + err = sooptcopyin(sopt, &p.aal5, sizeof p.aal5, sizeof p.aal5); + if (err) + break; + if ((p.aal5.forward_max_SDU_size != T_ATM_ABSENT) && + (p.aal5.forward_max_SDU_size & MAXMASK(16))) + return (EINVAL); + if ((p.aal5.backward_max_SDU_size != T_ATM_ABSENT) && + (p.aal5.backward_max_SDU_size & MAXMASK(16))) + return (EINVAL); + if ((p.aal5.SSCS_type != T_ATM_ABSENT) && + (p.aal5.SSCS_type != T_ATM_NULL) && + (p.aal5.SSCS_type != T_ATM_SSCS_SSCOP_REL) && + (p.aal5.SSCS_type != T_ATM_SSCS_SSCOP_UNREL) && + (p.aal5.SSCS_type != T_ATM_SSCS_FR)) + return (EINVAL); + + if ((p.aal5.forward_max_SDU_size == T_ATM_ABSENT) && + (p.aal5.backward_max_SDU_size == T_ATM_ABSENT) && + (p.aal5.SSCS_type == T_ATM_ABSENT)) + atp->atp_attr.aal.tag = T_ATM_ABSENT; + else { + atp->atp_attr.aal.tag = T_ATM_PRESENT; + atp->atp_attr.aal.type = ATM_AAL5; + atp->atp_attr.aal.v.aal5 = p.aal5; + } + break; + + case T_ATM_TRAFFIC: + err = sooptcopyin(sopt, &p.trf, sizeof p.trf, sizeof p.trf); + if (err) + break; + if ((p.trf.forward.PCR_high_priority != T_ATM_ABSENT) && + (p.trf.forward.PCR_high_priority & MAXMASK(24))) + return (EINVAL); + if (p.trf.forward.PCR_all_traffic & MAXMASK(24)) + return (EINVAL); + if ((p.trf.forward.SCR_high_priority != T_ATM_ABSENT) && + (p.trf.forward.SCR_high_priority & MAXMASK(24))) + return (EINVAL); + if ((p.trf.forward.SCR_all_traffic != T_ATM_ABSENT) && + (p.trf.forward.SCR_all_traffic & MAXMASK(24))) + return (EINVAL); + if ((p.trf.forward.MBS_high_priority != T_ATM_ABSENT) && + (p.trf.forward.MBS_high_priority & MAXMASK(24))) + return (EINVAL); + if ((p.trf.forward.MBS_all_traffic != T_ATM_ABSENT) && + (p.trf.forward.MBS_all_traffic & MAXMASK(24))) + return (EINVAL); + if ((p.trf.forward.tagging != T_YES) && + (p.trf.forward.tagging != T_NO)) + return (EINVAL); + + if ((p.trf.backward.PCR_high_priority != T_ATM_ABSENT) && + (p.trf.backward.PCR_high_priority & MAXMASK(24))) + return (EINVAL); + if (p.trf.backward.PCR_all_traffic & MAXMASK(24)) + return (EINVAL); + if ((p.trf.backward.SCR_high_priority != T_ATM_ABSENT) && + (p.trf.backward.SCR_high_priority & MAXMASK(24))) + return (EINVAL); + if ((p.trf.backward.SCR_all_traffic != T_ATM_ABSENT) && + (p.trf.backward.SCR_all_traffic & MAXMASK(24))) + return (EINVAL); + if ((p.trf.backward.MBS_high_priority != T_ATM_ABSENT) && + (p.trf.backward.MBS_high_priority & MAXMASK(24))) + return (EINVAL); + if ((p.trf.backward.MBS_all_traffic != T_ATM_ABSENT) && + (p.trf.backward.MBS_all_traffic & MAXMASK(24))) + return (EINVAL); + if ((p.trf.backward.tagging != T_YES) && + (p.trf.backward.tagging != T_NO)) + return (EINVAL); + if ((p.trf.best_effort != T_YES) && + (p.trf.best_effort != T_NO)) + return (EINVAL); + + atp->atp_attr.traffic.tag = T_ATM_PRESENT; + atp->atp_attr.traffic.v = p.trf; + break; + + case T_ATM_BEARER_CAP: + err = sooptcopyin(sopt, &p.brr, sizeof p.brr, sizeof p.brr); + if (err) + break; + if ((p.brr.bearer_class != T_ATM_CLASS_A) && + (p.brr.bearer_class != T_ATM_CLASS_C) && + (p.brr.bearer_class != T_ATM_CLASS_X)) + return (EINVAL); + if ((p.brr.traffic_type != T_ATM_NULL) && + (p.brr.traffic_type != T_ATM_CBR) && + (p.brr.traffic_type != T_ATM_VBR)) + return (EINVAL); + if ((p.brr.timing_requirements != T_ATM_NULL) && + (p.brr.timing_requirements != T_ATM_END_TO_END) && + (p.brr.timing_requirements != T_ATM_NO_END_TO_END)) + return (EINVAL); + if ((p.brr.clipping_susceptibility != T_NO) && + (p.brr.clipping_susceptibility != T_YES)) + return (EINVAL); + if ((p.brr.connection_configuration != T_ATM_1_TO_1) && + (p.brr.connection_configuration != T_ATM_1_TO_MANY)) + return (EINVAL); + + atp->atp_attr.bearer.tag = T_ATM_PRESENT; + atp->atp_attr.bearer.v = p.brr; + break; + + case T_ATM_BHLI: + err = sooptcopyin(sopt, &p.bhl, sizeof p.bhl, sizeof p.bhl); + if (err) + break; + if ((p.bhl.ID_type != T_ATM_ABSENT) && + (p.bhl.ID_type != T_ATM_ISO_APP_ID) && + (p.bhl.ID_type != T_ATM_USER_APP_ID) && + (p.bhl.ID_type != T_ATM_VENDOR_APP_ID)) + return (EINVAL); + + if (p.bhl.ID_type == T_ATM_ABSENT) + atp->atp_attr.bhli.tag = T_ATM_ABSENT; + else { + atp->atp_attr.bhli.tag = T_ATM_PRESENT; + atp->atp_attr.bhli.v = p.bhl; + } + break; + + case T_ATM_BLLI: + err = sooptcopyin(sopt, &p.bll, sizeof p.bll, sizeof p.bll); + if (err) + break; + if ((p.bll.layer_2_protocol.ID_type != T_ATM_ABSENT) && + (p.bll.layer_2_protocol.ID_type != T_ATM_SIMPLE_ID) && + (p.bll.layer_2_protocol.ID_type != T_ATM_USER_ID)) + return (EINVAL); + if ((p.bll.layer_2_protocol.mode != T_ATM_ABSENT) && + (p.bll.layer_2_protocol.mode != T_ATM_BLLI_NORMAL_MODE) && + (p.bll.layer_2_protocol.mode != T_ATM_BLLI_EXTENDED_MODE)) + return (EINVAL); + if ((p.bll.layer_2_protocol.window_size != T_ATM_ABSENT) && + (p.bll.layer_2_protocol.window_size < 1)) + return (EINVAL); + + if ((p.bll.layer_3_protocol.ID_type != T_ATM_ABSENT) && + (p.bll.layer_3_protocol.ID_type != T_ATM_SIMPLE_ID) && + (p.bll.layer_3_protocol.ID_type != T_ATM_IPI_ID) && + (p.bll.layer_3_protocol.ID_type != T_ATM_SNAP_ID) && + (p.bll.layer_3_protocol.ID_type != T_ATM_USER_ID)) + return (EINVAL); + if ((p.bll.layer_3_protocol.mode != T_ATM_ABSENT) && + (p.bll.layer_3_protocol.mode != T_ATM_BLLI_NORMAL_MODE) && + (p.bll.layer_3_protocol.mode != T_ATM_BLLI_EXTENDED_MODE)) + return (EINVAL); + if ((p.bll.layer_3_protocol.packet_size != T_ATM_ABSENT) && + (p.bll.layer_3_protocol.packet_size & MAXMASK(4))) + return (EINVAL); + if ((p.bll.layer_3_protocol.window_size != T_ATM_ABSENT) && + (p.bll.layer_3_protocol.window_size < 1)) + return (EINVAL); + + if (p.bll.layer_2_protocol.ID_type == T_ATM_ABSENT) + atp->atp_attr.blli.tag_l2 = T_ATM_ABSENT; + else + atp->atp_attr.blli.tag_l2 = T_ATM_PRESENT; + + if (p.bll.layer_3_protocol.ID_type == T_ATM_ABSENT) + atp->atp_attr.blli.tag_l3 = T_ATM_ABSENT; + else + atp->atp_attr.blli.tag_l3 = T_ATM_PRESENT; + + if ((atp->atp_attr.blli.tag_l2 == T_ATM_PRESENT) || + (atp->atp_attr.blli.tag_l3 == T_ATM_PRESENT)) + atp->atp_attr.blli.v = p.bll; + break; + + case T_ATM_DEST_ADDR: + err = sooptcopyin(sopt, &p.addr, sizeof p.addr, sizeof p.addr); + if (err) + break; + if ((p.addr.address_format != T_ATM_ENDSYS_ADDR) && + (p.addr.address_format != T_ATM_E164_ADDR)) + return (EINVAL); + if (p.addr.address_length > ATM_ADDR_LEN) + return (EINVAL); + + atp->atp_attr.called.tag = T_ATM_PRESENT; + atp->atp_attr.called.addr = p.addr; + break; + + case T_ATM_DEST_SUB: + err = sooptcopyin(sopt, &p.addr, sizeof p.addr, sizeof p.addr); + if (err) + break; + if ((p.addr.address_format != T_ATM_ABSENT) && + (p.addr.address_format != T_ATM_NSAP_ADDR)) + return (EINVAL); + if (p.addr.address_length > ATM_ADDR_LEN) + return (EINVAL); + + /* T_ATM_DEST_ADDR controls tag */ + atp->atp_attr.called.subaddr = p.addr; + break; + + case T_ATM_ORIG_ADDR: + return (EACCES); + + case T_ATM_ORIG_SUB: + return (EACCES); + + case T_ATM_CALLER_ID: + return (EACCES); + + case T_ATM_CAUSE: + err = sooptcopyin(sopt, &p.cau, sizeof p.cau, sizeof p.cau); + if (err) + break; + if ((p.cau.coding_standard != T_ATM_ABSENT) && + (p.cau.coding_standard != T_ATM_ITU_CODING) && + (p.cau.coding_standard != T_ATM_NETWORK_CODING)) + return (EINVAL); + if ((p.cau.location != T_ATM_LOC_USER) && + (p.cau.location != T_ATM_LOC_LOCAL_PRIVATE_NET) && + (p.cau.location != T_ATM_LOC_LOCAL_PUBLIC_NET) && + (p.cau.location != T_ATM_LOC_TRANSIT_NET) && + (p.cau.location != T_ATM_LOC_REMOTE_PUBLIC_NET) && + (p.cau.location != T_ATM_LOC_REMOTE_PRIVATE_NET) && + (p.cau.location != T_ATM_LOC_INTERNATIONAL_NET) && + (p.cau.location != T_ATM_LOC_BEYOND_INTERWORKING)) + return (EINVAL); + + if (p.cau.coding_standard == T_ATM_ABSENT) + atp->atp_attr.cause.tag = T_ATM_ABSENT; + else { + atp->atp_attr.cause.tag = T_ATM_PRESENT; + atp->atp_attr.cause.v = p.cau; + } + break; + + case T_ATM_QOS: + err = sooptcopyin(sopt, &p.qos, sizeof p.qos, sizeof p.qos); + if (err) + break; + if ((p.qos.coding_standard != T_ATM_ABSENT) && + (p.qos.coding_standard != T_ATM_ITU_CODING) && + (p.qos.coding_standard != T_ATM_NETWORK_CODING)) + return (EINVAL); + if ((p.qos.forward.qos_class != T_ATM_QOS_CLASS_0) && + (p.qos.forward.qos_class != T_ATM_QOS_CLASS_1) && + (p.qos.forward.qos_class != T_ATM_QOS_CLASS_2) && + (p.qos.forward.qos_class != T_ATM_QOS_CLASS_3) && + (p.qos.forward.qos_class != T_ATM_QOS_CLASS_4)) + return (EINVAL); + if ((p.qos.backward.qos_class != T_ATM_QOS_CLASS_0) && + (p.qos.backward.qos_class != T_ATM_QOS_CLASS_1) && + (p.qos.backward.qos_class != T_ATM_QOS_CLASS_2) && + (p.qos.backward.qos_class != T_ATM_QOS_CLASS_3) && + (p.qos.backward.qos_class != T_ATM_QOS_CLASS_4)) + return (EINVAL); + + if (p.qos.coding_standard == T_ATM_ABSENT) + atp->atp_attr.qos.tag = T_ATM_ABSENT; + else { + atp->atp_attr.qos.tag = T_ATM_PRESENT; + atp->atp_attr.qos.v = p.qos; + } + break; + + case T_ATM_TRANSIT: + err = sooptcopyin(sopt, &p.trn, sizeof p.trn, sizeof p.trn); + if (err) + break; + if (p.trn.length > T_ATM_MAX_NET_ID) + return (EINVAL); + + if (p.trn.length == 0) + atp->atp_attr.transit.tag = T_ATM_ABSENT; + else { + atp->atp_attr.transit.tag = T_ATM_PRESENT; + atp->atp_attr.transit.v = p.trn; + } + break; + + case T_ATM_ADD_LEAF: + return (EPROTONOSUPPORT); /* XXX */ + + case T_ATM_DROP_LEAF: + return (EPROTONOSUPPORT); /* XXX */ + + case T_ATM_NET_INTF: + err = sooptcopyin(sopt, &p.nif, sizeof p.nif, sizeof p.nif); + if (err) + break; + + atp->atp_attr.nif = atm_nifname(p.nif.net_intf); + if (atp->atp_attr.nif == NULL) + return (ENXIO); + break; + + case T_ATM_LLC: + err = sooptcopyin(sopt, &p.llc, sizeof p.llc, sizeof p.llc); + if (err) + break; + if ((p.llc.llc_len < T_ATM_LLC_MIN_LEN) || + (p.llc.llc_len > T_ATM_LLC_MAX_LEN)) + return (EINVAL); + + atp->atp_attr.llc.tag = T_ATM_PRESENT; + atp->atp_attr.llc.v = p.llc; + break; + + case T_ATM_APP_NAME: + err = sooptcopyin(sopt, &p.appn, sizeof p.appn, sizeof p.appn); + if (err) + break; + + strncpy(atp->atp_name, p.appn.app_name, T_ATM_APP_NAME_LEN); + break; + + default: + return (ENOPROTOOPT); + } + + return (err); +} + + +/* + * Common getsockopt processing + * + * Called at splnet. + * + * Arguments: + * so pointer to socket + * sopt pointer to socket option info + * atp pointer to ATM PCB + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +int +atm_sock_getopt(so, sopt, atp) + struct socket *so; + struct sockopt *sopt; + Atm_pcb *atp; +{ + Atm_attributes *ap; + + /* + * If socket is connected, return attributes for the VCC in use, + * otherwise just return what the user has setup so far. + */ + if (so->so_state & SS_ISCONNECTED) + ap = &atp->atp_conn->co_connvc->cvc_attr; + else + ap = &atp->atp_attr; + + switch (sopt->sopt_name) { + + case T_ATM_AAL5: + if ((ap->aal.tag == T_ATM_PRESENT) && + (ap->aal.type == ATM_AAL5)) { + return (sooptcopyout(sopt, &ap->aal.v.aal5, + sizeof ap->aal.v.aal5)); + } else { + return (ENOENT); + } + break; + + case T_ATM_TRAFFIC: + if (ap->traffic.tag == T_ATM_PRESENT) { + return (sooptcopyout(sopt, &ap->traffic.v, + sizeof ap->traffic.v)); + } else { + return (ENOENT); + } + break; + + case T_ATM_BEARER_CAP: + if (ap->bearer.tag == T_ATM_PRESENT) { + return (sooptcopyout(sopt, &ap->bearer.v, + sizeof ap->bearer.v)); + } else { + return (ENOENT); + } + break; + + case T_ATM_BHLI: + if (ap->bhli.tag == T_ATM_PRESENT) { + return (sooptcopyout(sopt, &ap->bhli.v, + sizeof ap->bhli.v)); + } else { + return (ENOENT); + } + break; + + case T_ATM_BLLI: + if ((ap->blli.tag_l2 == T_ATM_PRESENT) || + (ap->blli.tag_l3 == T_ATM_PRESENT)) { + return (sooptcopyout(sopt, &ap->blli.v, + sizeof ap->blli.v)); + } else { + return (ENOENT); + } + break; + + case T_ATM_DEST_ADDR: + if (ap->called.tag == T_ATM_PRESENT) { + return (sooptcopyout(sopt, &ap->called.addr, + sizeof ap->called.addr)); + } else { + return (ENOENT); + } + break; + + case T_ATM_DEST_SUB: + if (ap->called.tag == T_ATM_PRESENT) { + return (sooptcopyout(sopt, &ap->called.subaddr, + sizeof ap->called.subaddr)); + } else { + return (ENOENT); + } + break; + + case T_ATM_ORIG_ADDR: + if (ap->calling.tag == T_ATM_PRESENT) { + return (sooptcopyout(sopt, &ap->calling.addr, + sizeof ap->calling.addr)); + } else { + return (ENOENT); + } + break; + + case T_ATM_ORIG_SUB: + if (ap->calling.tag == T_ATM_PRESENT) { + return (sooptcopyout(sopt, &ap->calling.subaddr, + sizeof ap->calling.subaddr)); + } else { + return (ENOENT); + } + break; + + case T_ATM_CALLER_ID: + if (ap->calling.tag == T_ATM_PRESENT) { + return (sooptcopyout(sopt, &ap->calling.cid, + sizeof ap->calling.cid)); + } else { + return (ENOENT); + } + break; + + case T_ATM_CAUSE: + if (ap->cause.tag == T_ATM_PRESENT) { + return (sooptcopyout(sopt, &ap->cause.v, + sizeof ap->cause.v)); + } else { + return (ENOENT); + } + break; + + case T_ATM_QOS: + if (ap->qos.tag == T_ATM_PRESENT) { + return (sooptcopyout(sopt, &ap->qos.v, + sizeof ap->qos.v)); + } else { + return (ENOENT); + } + break; + + case T_ATM_TRANSIT: + if (ap->transit.tag == T_ATM_PRESENT) { + return (sooptcopyout(sopt, &ap->transit.v, + sizeof ap->transit.v)); + } else { + return (ENOENT); + } + break; + + case T_ATM_LEAF_IND: + return (EPROTONOSUPPORT); /* XXX */ + + case T_ATM_NET_INTF: + if (ap->nif) { + struct t_atm_net_intf netif; + struct ifnet *ifp; + + ifp = &ap->nif->nif_if; + (void) sprintf(netif.net_intf, "%s%d", + ifp->if_name, ifp->if_unit); + return (sooptcopyout(sopt, &netif, + sizeof netif)); + } else { + return (ENOENT); + } + break; + + case T_ATM_LLC: + if (ap->llc.tag == T_ATM_PRESENT) { + return (sooptcopyout(sopt, &ap->llc.v, + sizeof ap->llc.v)); + } else { + return (ENOENT); + } + break; + + default: + return (ENOPROTOOPT); + } + + return (0); +} + + +/* + * Process Socket VCC Connected Notification + * + * Arguments: + * toku owner's connection token (atm_pcb protocol block) + * + * Returns: + * none + * + */ +void +atm_sock_connected(toku) + void *toku; +{ + Atm_pcb *atp = (Atm_pcb *)toku; + + /* + * Connection is setup + */ + atm_sock_stat.as_conncomp[atp->atp_type]++; + soisconnected(atp->atp_socket); +} + + +/* + * Process Socket VCC Cleared Notification + * + * Arguments: + * toku owner's connection token (atm_pcb protocol block) + * cause pointer to cause code + * + * Returns: + * none + * + */ +void +atm_sock_cleared(toku, cause) + void *toku; + struct t_atm_cause *cause; +{ + Atm_pcb *atp = (Atm_pcb *)toku; + struct socket *so; + + so = atp->atp_socket; + + /* + * Save call clearing cause + */ + atp->atp_attr.cause.tag = T_ATM_PRESENT; + atp->atp_attr.cause.v = *cause; + + /* + * Set user error code + */ + if (so->so_state & SS_ISCONNECTED) { + so->so_error = ECONNRESET; + atm_sock_stat.as_connclr[atp->atp_type]++; + } else { + so->so_error = ECONNREFUSED; + atm_sock_stat.as_connfail[atp->atp_type]++; + } + + /* + * Connection is gone + */ + atp->atp_conn = NULL; + soisdisconnected(so); + + /* + * Cleanup failed incoming connection setup + */ + if (so->so_state & SS_NOFDREF) { + (void) atm_sock_detach(so); + } +} + diff --git a/sys/netatm/atm_stack.h b/sys/netatm/atm_stack.h new file mode 100644 index 0000000..abd32c4 --- /dev/null +++ b/sys/netatm/atm_stack.h @@ -0,0 +1,287 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_stack.h,v 1.5 1998/02/19 19:59:59 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM Stack definitions + * + */ + +#ifndef _NETATM_ATM_STACK_H +#define _NETATM_ATM_STACK_H + +#ifdef ATM_KERNEL +/* + * Structure used to define a kernel-provided ATM stack service and its + * associated entry points. Each stack service provider must register + * themselves before they will be used. ATM stack service providers include + * kernel modules (both linked and loaded) and device drivers, which must list + * (via its atm_pif) any of its available hardware-supplied stack services + * (such as on-card AAL processing). + */ +struct stack_defn { + struct stack_defn *sd_next; /* Next in registry list */ + Sap_t sd_sap; /* Stack instance SAP */ + u_char sd_flag; /* Flags (see below) */ +/* Exported functions */ + int (*sd_inst) /* Stack instantiation */ + __P((struct stack_defn **, Atm_connvc *)); + void (*sd_lower) /* Lower (from above) command handler */ + __P((int, void *, int, int)); + void (*sd_upper) /* Upper (from below) command handler */ + __P((int, void *, int, int)); +/* Variables used during stack instantiation */ + void *sd_toku; /* Stack service instance token */ +}; + +/* + * Stack Service Flags + */ +#define SDF_TERM 0x01 /* Terminal (to lowest layer) service */ + + +/* + * Stack Specification List + * + * The list names the stack services and their layering relationships in + * order to construct a stack to provide the protocol services defined + * by the list. The list is ordered starting from the stack service + * interfacing with the user "down" to the ATM cell service. + */ +#define STACK_CNT 8 /* Max services in a stack list */ +struct stack_list { + Sap_t sl_sap[STACK_CNT]; /* Stack service SAP list */ +}; + + +/* + * Structure used during the construction and instantiation of a stack + * instance from a supplied stack list. It contains pointers to the stack + * service definitions which will be used to implement the stack. The first + * element in the array is reserved for the user's "stack service". + */ +struct stack_inst { + struct stack_defn *si_srvc[STACK_CNT+1]; /* Assigned services */ +}; + + +/* + * Macros to update buffer headroom values during stack instantiation. + * + * These values are advisory, i.e. every service must verify the amount + * of available space in input/output messages and allocate new buffers + * if needed. + * + * The 'maximum' and 'minimum' values used below may be chosen by a + * service to reflect the typical, expected message traffic pattern + * for a specific connection. + * + * The macro arguments are: + * cvp = pointer to connection vcc; + * hi = maximum amount of buffer headroom required by the current + * service during input message processing; + * si = minimum amount of buffer data stripped off the front + * of an input message by the current service; + * ho = maximum amount of buffer headroom required by the current + * service during output message processing; + * ao = maximum amount of buffer data added to the front + * of an output message by the current service; + */ +#define HEADIN(cvp, hi, si) \ +{ \ + short t = (cvp)->cvc_attr.headin - (si); \ + t = (t >= (hi)) ? t : (hi); \ + (cvp)->cvc_attr.headin = roundup(t, sizeof(long)); \ +} + +#define HEADOUT(cvp, ho, ao) \ +{ \ + short t = (cvp)->cvc_attr.headout + (ao); \ + t = (t >= (ho)) ? t : (ho); \ + (cvp)->cvc_attr.headout = roundup(t, sizeof(long)); \ +} + + +/* + * Stack command codes - All stack command codes are specific to the + * defined stack SAP across which the command is used. Command values 0-15 + * are reserved for any common codes, which all stack SAPs must support. + */ +#define STKCMD(s, d, v) (((s) << 16) | (d) | (v)) +#define STKCMD_DOWN 0 +#define STKCMD_UP 0x00008000 +#define STKCMD_SAP_MASK 0xffff0000 +#define STKCMD_VAL_MASK 0x00007fff + +/* Common command values (0-15) */ +#define CCV_INIT 1 /* DOWN */ +#define CCV_TERM 2 /* DOWN */ + +/* SAP_ATM */ +#define ATM_INIT STKCMD(SAP_ATM, STKCMD_DOWN, CCV_INIT) +#define ATM_TERM STKCMD(SAP_ATM, STKCMD_DOWN, CCV_TERM) +#define ATM_DATA_REQ STKCMD(SAP_ATM, STKCMD_DOWN, 16) +#define ATM_DATA_IND STKCMD(SAP_ATM, STKCMD_UP, 17) + +/* SAP_SAR */ +#define SAR_INIT STKCMD(SAP_SAR, STKCMD_DOWN, CCV_INIT) +#define SAR_TERM STKCMD(SAP_SAR, STKCMD_DOWN, CCV_TERM) +#define SAR_UNITDATA_INV STKCMD(SAP_SAR, STKCMD_DOWN, 16) +#define SAR_UNITDATA_SIG STKCMD(SAP_SAR, STKCMD_UP, 17) +#define SAR_UABORT_INV STKCMD(SAP_SAR, STKCMD_DOWN, 18) +#define SAR_UABORT_SIG STKCMD(SAP_SAR, STKCMD_UP, 19) +#define SAR_PABORT_SIG STKCMD(SAP_SAR, STKCMD_UP, 20) + +/* SAP_CPCS */ +#define CPCS_INIT STKCMD(SAP_CPCS, STKCMD_DOWN, CCV_INIT) +#define CPCS_TERM STKCMD(SAP_CPCS, STKCMD_DOWN, CCV_TERM) +#define CPCS_UNITDATA_INV STKCMD(SAP_CPCS, STKCMD_DOWN, 16) +#define CPCS_UNITDATA_SIG STKCMD(SAP_CPCS, STKCMD_UP, 17) +#define CPCS_UABORT_INV STKCMD(SAP_CPCS, STKCMD_DOWN, 18) +#define CPCS_UABORT_SIG STKCMD(SAP_CPCS, STKCMD_UP, 19) +#define CPCS_PABORT_SIG STKCMD(SAP_CPCS, STKCMD_UP, 20) + +/* SAP_SSCOP */ +#define SSCOP_INIT STKCMD(SAP_SSCOP, STKCMD_DOWN, CCV_INIT) +#define SSCOP_TERM STKCMD(SAP_SSCOP, STKCMD_DOWN, CCV_TERM) +#define SSCOP_ESTABLISH_REQ STKCMD(SAP_SSCOP, STKCMD_DOWN, 16) +#define SSCOP_ESTABLISH_IND STKCMD(SAP_SSCOP, STKCMD_UP, 17) +#define SSCOP_ESTABLISH_RSP STKCMD(SAP_SSCOP, STKCMD_DOWN, 18) +#define SSCOP_ESTABLISH_CNF STKCMD(SAP_SSCOP, STKCMD_UP, 19) +#define SSCOP_RELEASE_REQ STKCMD(SAP_SSCOP, STKCMD_DOWN, 20) +#define SSCOP_RELEASE_IND STKCMD(SAP_SSCOP, STKCMD_UP, 21) +#define SSCOP_RELEASE_CNF STKCMD(SAP_SSCOP, STKCMD_UP, 22) +#define SSCOP_DATA_REQ STKCMD(SAP_SSCOP, STKCMD_DOWN, 23) +#define SSCOP_DATA_IND STKCMD(SAP_SSCOP, STKCMD_UP, 24) +#define SSCOP_RESYNC_REQ STKCMD(SAP_SSCOP, STKCMD_DOWN, 25) +#define SSCOP_RESYNC_IND STKCMD(SAP_SSCOP, STKCMD_UP, 26) +#define SSCOP_RESYNC_RSP STKCMD(SAP_SSCOP, STKCMD_DOWN, 27) +#define SSCOP_RESYNC_CNF STKCMD(SAP_SSCOP, STKCMD_UP, 28) +#define SSCOP_RECOVER_IND STKCMD(SAP_SSCOP, STKCMD_UP, 29) +#define SSCOP_RECOVER_RSP STKCMD(SAP_SSCOP, STKCMD_DOWN, 30) +#define SSCOP_UNITDATA_REQ STKCMD(SAP_SSCOP, STKCMD_DOWN, 31) +#define SSCOP_UNITDATA_IND STKCMD(SAP_SSCOP, STKCMD_UP, 32) +#define SSCOP_RETRIEVE_REQ STKCMD(SAP_SSCOP, STKCMD_DOWN, 33) +#define SSCOP_RETRIEVE_IND STKCMD(SAP_SSCOP, STKCMD_UP, 34) +#define SSCOP_RETRIEVECMP_IND STKCMD(SAP_SSCOP, STKCMD_UP, 35) + +/* SAP_SSCF_UNI */ +#define SSCF_UNI_INIT STKCMD(SAP_SSCF_UNI, STKCMD_DOWN, CCV_INIT) +#define SSCF_UNI_TERM STKCMD(SAP_SSCF_UNI, STKCMD_DOWN, CCV_TERM) +#define SSCF_UNI_ESTABLISH_REQ STKCMD(SAP_SSCF_UNI, STKCMD_DOWN, 16) +#define SSCF_UNI_ESTABLISH_IND STKCMD(SAP_SSCF_UNI, STKCMD_UP, 17) +#define SSCF_UNI_ESTABLISH_CNF STKCMD(SAP_SSCF_UNI, STKCMD_UP, 18) +#define SSCF_UNI_RELEASE_REQ STKCMD(SAP_SSCF_UNI, STKCMD_DOWN, 19) +#define SSCF_UNI_RELEASE_IND STKCMD(SAP_SSCF_UNI, STKCMD_UP, 20) +#define SSCF_UNI_RELEASE_CNF STKCMD(SAP_SSCF_UNI, STKCMD_UP, 21) +#define SSCF_UNI_DATA_REQ STKCMD(SAP_SSCF_UNI, STKCMD_DOWN, 22) +#define SSCF_UNI_DATA_IND STKCMD(SAP_SSCF_UNI, STKCMD_UP, 23) +#define SSCF_UNI_UNITDATA_REQ STKCMD(SAP_SSCF_UNI, STKCMD_DOWN, 24) +#define SSCF_UNI_UNITDATA_IND STKCMD(SAP_SSCF_UNI, STKCMD_UP, 25) + + +/* + * The STACK_CALL macro must be used for all stack calls between adjacent + * entities. In order to avoid the problem with recursive stack calls + * modifying protocol state, this macro will only allow calls to proceed if + * they are not "against the flow" of any currently pending calls for a + * stack instance. If the requested call can't be processed now, it will + * be deferred and queued until a later, safe time (but before control is + * returned back to the kernel scheduler) when it will be dispatched. + * + * The STACK_CALL macro arguments are: + * cmd = command code; + * fn = Destination entity processing function + * tok = Destination layer's session token; + * cvp = Connection VCC address; + * a1 = command specific argument; + * a2 = command specific argument; + * ret = call result value (0 => success) + * + * The receiving entity command processing function prototype is: + * + * void (fn)(int cmd, int tok, int arg1, int arg2) + * + */ +#define STACK_CALL(cmd, fn, tok, cvp, a1, a2, ret) \ +{ \ + if ((cmd) & STKCMD_UP) { \ + if ((cvp)->cvc_downcnt) { \ + (ret) = atm_stack_enq((cmd), (fn), (tok), \ + (cvp), (a1), (a2)); \ + } else { \ + (cvp)->cvc_upcnt++; \ + (*fn)(cmd, tok, a1, a2); \ + (cvp)->cvc_upcnt--; \ + (ret) = 0; \ + } \ + } else { \ + if ((cvp)->cvc_upcnt) { \ + (ret) = atm_stack_enq((cmd), (fn), (tok), \ + (cvp), (a1), (a2)); \ + } else { \ + (cvp)->cvc_downcnt++; \ + (*fn)(cmd, tok, a1, a2); \ + (cvp)->cvc_downcnt--; \ + (ret) = 0; \ + } \ + } \ +} + + +/* + * Stack queue entry - The stack queue will contain stack calls which have + * been deferred in order to avoid recursive calls to a single protocol + * control block. The queue entries are allocated from its own storage pool. + */ +struct stackq_entry { + struct stackq_entry *sq_next; /* Next entry in queue */ + int sq_cmd; /* Stack command */ + void (*sq_func) /* Destination function */ + __P((int, void *, int, int)); + void *sq_token; /* Destination token */ + int sq_arg1; /* Command-specific argument */ + int sq_arg2; /* Command-specific argument */ + Atm_connvc *sq_connvc; /* Connection VCC */ +}; + + +/* + * Macro to avoid unnecessary function call when draining the stack queue. + */ +#define STACK_DRAIN() \ +{ \ + if (atm_stackq_head) \ + atm_stack_drain(); \ +} +#endif /* ATM_KERNEL */ + +#endif /* _NETATM_ATM_STACK_H */ diff --git a/sys/netatm/atm_subr.c b/sys/netatm/atm_subr.c new file mode 100644 index 0000000..40fc433 --- /dev/null +++ b/sys/netatm/atm_subr.c @@ -0,0 +1,970 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_subr.c,v 1.10 1998/05/18 19:06:02 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * Miscellaneous ATM subroutines + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: atm_subr.c,v 1.10 1998/05/18 19:06:02 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + + +/* + * Global variables + */ +struct atm_pif *atm_interface_head = NULL; +struct atm_ncm *atm_netconv_head = NULL; +Atm_endpoint *atm_endpoints[ENDPT_MAX+1] = {NULL}; +struct sp_info *atm_pool_head = NULL; +struct stackq_entry *atm_stackq_head = NULL, *atm_stackq_tail; +struct ifqueue atm_intrq; +#ifdef sgi +int atm_intr_index; +#endif +struct atm_sock_stat atm_sock_stat = {0}; +int atm_init = 0; +int atm_debug = 0; +int atm_dev_print = 0; +int atm_print_data = 0; +int atm_version = ATM_VERSION; +struct timeval atm_debugtime = {0, 0}; + +struct sp_info atm_attributes_pool = { + "atm attributes pool", /* si_name */ + sizeof(Atm_attributes), /* si_blksiz */ + 10, /* si_blkcnt */ + 100 /* si_maxallow */ +}; + + +/* + * Local functions + */ +static void atm_compact __P((struct atm_time *)); +static KTimeout_ret atm_timexp __P((void *)); + +/* + * Local variables + */ +static struct atm_time *atm_timeq = NULL; +static struct atm_time atm_compactimer = {0, 0}; + +static struct sp_info atm_stackq_pool = { + "Service stack queue pool", /* si_name */ + sizeof(struct stackq_entry), /* si_blksiz */ + 10, /* si_blkcnt */ + 10 /* si_maxallow */ +}; + + +/* + * Initialize ATM kernel + * + * Performs any initialization required before things really get underway. + * Called from ATM domain initialization or from first registration function + * which gets called. + * + * Arguments: + * none + * + * Returns: + * none + * + */ +void +atm_initialize() +{ + /* + * Never called from interrupts, so no locking needed + */ + if (atm_init) + return; + atm_init = 1; + +#ifndef __FreeBSD__ + /* + * Add ATM protocol family + */ + (void) protocol_family(&atmdomain, NULL, NULL); +#endif + + atm_intrq.ifq_maxlen = ATM_INTRQ_MAX; +#ifdef sgi + atm_intr_index = register_isr(atm_intr); +#endif + + /* + * Initialize subsystems + */ + atm_aal5_init(); + + /* + * Prime the timer + */ + (void) timeout(atm_timexp, (void *)0, hz/ATM_HZ); + + /* + * Start the compaction timer + */ + atm_timeout(&atm_compactimer, SPOOL_COMPACT, atm_compact); +} + + +/* + * Allocate a Control Block + * + * Gets a new control block allocated from the specified storage pool, + * acquiring memory for new pool chunks if required. The returned control + * block's contents will be cleared. + * + * Arguments: + * sip pointer to sp_info for storage pool + * + * Returns: + * addr pointer to allocated control block + * 0 allocation failed + * + */ +void * +atm_allocate(sip) + struct sp_info *sip; +{ + void *bp; + struct sp_chunk *scp; + struct sp_link *slp; + int s = splnet(); + + /* + * Count calls + */ + sip->si_allocs++; + + /* + * Are there any free in the pool? + */ + if (sip->si_free) { + + /* + * Find first chunk with a free block + */ + for (scp = sip->si_poolh; scp; scp = scp->sc_next) { + if (scp->sc_freeh != NULL) + break; + } + + } else { + + /* + * No free blocks - have to allocate a new + * chunk (but put a limit to this) + */ + struct sp_link *slp_next; + int i; + + /* + * First time for this pool?? + */ + if (sip->si_chunksiz == 0) { + size_t n; + + /* + * Initialize pool information + */ + n = sizeof(struct sp_chunk) + + sip->si_blkcnt * + (sip->si_blksiz + sizeof(struct sp_link)); + sip->si_chunksiz = roundup(n, SPOOL_ROUNDUP); + + /* + * Place pool on kernel chain + */ + LINK2TAIL(sip, struct sp_info, atm_pool_head, si_next); + } + + if (sip->si_chunks >= sip->si_maxallow) { + sip->si_fails++; + (void) splx(s); + return (NULL); + } + + scp = (struct sp_chunk *) + KM_ALLOC(sip->si_chunksiz, M_DEVBUF, M_NOWAIT); + if (scp == NULL) { + sip->si_fails++; + (void) splx(s); + return (NULL); + } + scp->sc_next = NULL; + scp->sc_info = sip; + scp->sc_magic = SPOOL_MAGIC; + scp->sc_used = 0; + + /* + * Divy up chunk into free blocks + */ + slp = (struct sp_link *)(scp + 1); + scp->sc_freeh = slp; + + for (i = sip->si_blkcnt; i > 1; i--) { + slp_next = (struct sp_link *)((caddr_t)(slp + 1) + + sip->si_blksiz); + slp->sl_u.slu_next = slp_next; + slp = slp_next; + } + slp->sl_u.slu_next = NULL; + scp->sc_freet = slp; + + /* + * Add new chunk to end of pool + */ + if (sip->si_poolh) + sip->si_poolt->sc_next = scp; + else + sip->si_poolh = scp; + sip->si_poolt = scp; + + sip->si_chunks++; + sip->si_total += sip->si_blkcnt; + sip->si_free += sip->si_blkcnt; + if (sip->si_chunks > sip->si_maxused) + sip->si_maxused = sip->si_chunks; + } + + /* + * Allocate the first free block in chunk + */ + slp = scp->sc_freeh; + scp->sc_freeh = slp->sl_u.slu_next; + scp->sc_used++; + sip->si_free--; + bp = (slp + 1); + + /* + * Save link back to pool chunk + */ + slp->sl_u.slu_chunk = scp; + + /* + * Clear out block + */ + KM_ZERO(bp, sip->si_blksiz); + + (void) splx(s); + return (bp); +} + + +/* + * Free a Control Block + * + * Returns a previously allocated control block back to the owners + * storage pool. + * + * Arguments: + * bp pointer to block to be freed + * + * Returns: + * none + * + */ +void +atm_free(bp) + void *bp; +{ + struct sp_info *sip; + struct sp_chunk *scp; + struct sp_link *slp; + int s = splnet(); + + /* + * Get containing chunk and pool info + */ + slp = (struct sp_link *)bp; + slp--; + scp = slp->sl_u.slu_chunk; + if (scp->sc_magic != SPOOL_MAGIC) + panic("atm_free: chunk magic missing"); + sip = scp->sc_info; + + /* + * Add block to free chain + */ + if (scp->sc_freeh) { + scp->sc_freet->sl_u.slu_next = slp; + scp->sc_freet = slp; + } else + scp->sc_freeh = scp->sc_freet = slp; + slp->sl_u.slu_next = NULL; + sip->si_free++; + scp->sc_used--; + + (void) splx(s); + return; +} + + +/* + * Storage Pool Compaction + * + * Called periodically in order to perform compaction of the + * storage pools. Each pool will be checked to see if any chunks + * can be freed, taking some care to avoid freeing too many chunks + * in order to avoid memory thrashing. + * + * Called at splnet. + * + * Arguments: + * tip pointer to timer control block (atm_compactimer) + * + * Returns: + * none + * + */ +static void +atm_compact(tip) + struct atm_time *tip; +{ + struct sp_info *sip; + struct sp_chunk *scp; + int i; + struct sp_chunk *scp_prev; + + /* + * Check out all storage pools + */ + for (sip = atm_pool_head; sip; sip = sip->si_next) { + + /* + * Always keep a minimum number of chunks around + */ + if (sip->si_chunks <= SPOOL_MIN_CHUNK) + continue; + + /* + * Maximum chunks to free at one time will leave + * pool with at least 50% utilization, but never + * go below minimum chunk count. + */ + i = ((sip->si_free * 2) - sip->si_total) / sip->si_blkcnt; + i = MIN(i, sip->si_chunks - SPOOL_MIN_CHUNK); + + /* + * Look for chunks to free + */ + scp_prev = NULL; + for (scp = sip->si_poolh; scp && i > 0; ) { + + if (scp->sc_used == 0) { + + /* + * Found a chunk to free, so do it + */ + if (scp_prev) { + scp_prev->sc_next = scp->sc_next; + if (sip->si_poolt == scp) + sip->si_poolt = scp_prev; + } else + sip->si_poolh = scp->sc_next; + + KM_FREE((caddr_t)scp, sip->si_chunksiz, + M_DEVBUF); + + /* + * Update pool controls + */ + sip->si_chunks--; + sip->si_total -= sip->si_blkcnt; + sip->si_free -= sip->si_blkcnt; + i--; + if (scp_prev) + scp = scp_prev->sc_next; + else + scp = sip->si_poolh; + } else { + scp_prev = scp; + scp = scp->sc_next; + } + } + } + + /* + * Restart the compaction timer + */ + atm_timeout(&atm_compactimer, SPOOL_COMPACT, atm_compact); + + return; +} + + +/* + * Release a Storage Pool + * + * Frees all dynamic storage acquired for a storage pool. + * This function is normally called just prior to a module's unloading. + * + * Arguments: + * sip pointer to sp_info for storage pool + * + * Returns: + * none + * + */ +void +atm_release_pool(sip) + struct sp_info *sip; +{ + struct sp_chunk *scp, *scp_next; + int s = splnet(); + + /* + * Free each chunk in pool + */ + for (scp = sip->si_poolh; scp; scp = scp_next) { + + /* + * Check for memory leaks + */ + if (scp->sc_used) + panic("atm_release_pool: unfreed blocks"); + + scp_next = scp->sc_next; + + KM_FREE((caddr_t)scp, sip->si_chunksiz, M_DEVBUF); + } + + /* + * Update pool controls + */ + sip->si_poolh = NULL; + sip->si_chunks = 0; + sip->si_total = 0; + sip->si_free = 0; + + /* + * Unlink pool from active chain + */ + sip->si_chunksiz = 0; + UNLINK(sip, struct sp_info, atm_pool_head, si_next); + + (void) splx(s); + return; +} + + +/* + * Handle timer tick expiration + * + * Decrement tick count in first block on timer queue. If there + * are blocks with expired timers, call their timeout function. + * This function is called ATM_HZ times per second. + * + * Arguments: + * arg argument passed on timeout() call + * + * Returns: + * none + * + */ +static KTimeout_ret +atm_timexp(arg) + void *arg; +{ + struct atm_time *tip; + int s = splimp(); + + + /* + * Decrement tick count + */ + if (((tip = atm_timeq) == NULL) || (--tip->ti_ticks > 0)) { + goto restart; + } + + /* + * Stack queue should have been drained + */ +#ifdef DIAGNOSTIC + if (atm_stackq_head != NULL) + panic("atm_timexp: stack queue not empty"); +#endif + + /* + * Dispatch expired timers + */ + while (((tip = atm_timeq) != NULL) && (tip->ti_ticks == 0)) { + void (*func)__P((struct atm_time *)); + + /* + * Remove expired block from queue + */ + atm_timeq = tip->ti_next; + tip->ti_flag &= ~TIF_QUEUED; + + /* + * Call timeout handler (with network interrupts locked out) + */ + func = tip->ti_func; + (void) splx(s); + s = splnet(); + (*func)(tip); + (void) splx(s); + s = splimp(); + + /* + * Drain any deferred calls + */ + STACK_DRAIN(); + } + +restart: + /* + * Restart the timer + */ + (void) splx(s); + (void) timeout(atm_timexp, (void *)0, hz/ATM_HZ); + + return; +} + + +/* + * Schedule a control block timeout + * + * Place the supplied timer control block on the timer queue. The + * function (func) will be called in 't' timer ticks with the + * control block address as its only argument. There are ATM_HZ + * timer ticks per second. The ticks value stored in each block is + * a delta of the number of ticks from the previous block in the queue. + * Thus, for each tick interval, only the first block in the queue + * needs to have its tick value decremented. + * + * Arguments: + * tip pointer to timer control block + * t number of timer ticks until expiration + * func pointer to function to call at expiration + * + * Returns: + * none + * + */ +void +atm_timeout(tip, t, func) + struct atm_time *tip; + int t; + void (*func)__P((struct atm_time *)); +{ + struct atm_time *tip1, *tip2; + int s; + + + /* + * Check for double queueing error + */ + if (tip->ti_flag & TIF_QUEUED) + panic("atm_timeout: double queueing"); + + /* + * Make sure we delay at least a little bit + */ + if (t <= 0) + t = 1; + + /* + * Find out where we belong on the queue + */ + s = splimp(); + for (tip1 = NULL, tip2 = atm_timeq; tip2 && (tip2->ti_ticks <= t); + tip1 = tip2, tip2 = tip1->ti_next) { + t -= tip2->ti_ticks; + } + + /* + * Place ourselves on queue and update timer deltas + */ + if (tip1 == NULL) + atm_timeq = tip; + else + tip1->ti_next = tip; + tip->ti_next = tip2; + + if (tip2) + tip2->ti_ticks -= t; + + /* + * Setup timer block + */ + tip->ti_flag |= TIF_QUEUED; + tip->ti_ticks = t; + tip->ti_func = func; + + (void) splx(s); + return; +} + + +/* + * Cancel a timeout + * + * Remove the supplied timer control block from the timer queue. + * + * Arguments: + * tip pointer to timer control block + * + * Returns: + * 0 control block successfully dequeued + * 1 control block not on timer queue + * + */ +int +atm_untimeout(tip) + struct atm_time *tip; +{ + struct atm_time *tip1, *tip2; + int s; + + /* + * Is control block queued? + */ + if ((tip->ti_flag & TIF_QUEUED) == 0) + return(1); + + /* + * Find control block on the queue + */ + s = splimp(); + for (tip1 = NULL, tip2 = atm_timeq; tip2 && (tip2 != tip); + tip1 = tip2, tip2 = tip1->ti_next) { + } + + if (tip2 == NULL) { + (void) splx(s); + return (1); + } + + /* + * Remove block from queue and update timer deltas + */ + tip2 = tip->ti_next; + if (tip1 == NULL) + atm_timeq = tip2; + else + tip1->ti_next = tip2; + + if (tip2) + tip2->ti_ticks += tip->ti_ticks; + + /* + * Reset timer block + */ + tip->ti_flag &= ~TIF_QUEUED; + + (void) splx(s); + return (0); +} + + +/* + * Queue a Stack Call + * + * Queues a stack call which must be deferred to the global stack queue. + * The call parameters are stored in entries which are allocated from the + * stack queue storage pool. + * + * Arguments: + * cmd stack command + * func destination function + * token destination layer's token + * cvp pointer to connection vcc + * arg1 command argument + * arg2 command argument + * + * Returns: + * 0 call queued + * errno call not queued - reason indicated + * + */ +int +atm_stack_enq(cmd, func, token, cvp, arg1, arg2) + int cmd; + void (*func)__P((int, void *, int, int)); + void *token; + Atm_connvc *cvp; + int arg1; + int arg2; +{ + struct stackq_entry *sqp; + int s = splnet(); + + /* + * Get a new queue entry for this call + */ + sqp = (struct stackq_entry *)atm_allocate(&atm_stackq_pool); + if (sqp == NULL) { + (void) splx(s); + return (ENOMEM); + } + + /* + * Fill in new entry + */ + sqp->sq_next = NULL; + sqp->sq_cmd = cmd; + sqp->sq_func = func; + sqp->sq_token = token; + sqp->sq_arg1 = arg1; + sqp->sq_arg2 = arg2; + sqp->sq_connvc = cvp; + + /* + * Put new entry at end of queue + */ + if (atm_stackq_head == NULL) + atm_stackq_head = sqp; + else + atm_stackq_tail->sq_next = sqp; + atm_stackq_tail = sqp; + + (void) splx(s); + return (0); +} + + +/* + * Drain the Stack Queue + * + * Dequeues and processes entries from the global stack queue. + * + * Arguments: + * none + * + * Returns: + * none + * + */ +void +atm_stack_drain() +{ + struct stackq_entry *sqp, *qprev, *qnext; + int s = splnet(); + int cnt; + + /* + * Loop thru entire queue until queue is empty + * (but panic rather loop forever) + */ + do { + cnt = 0; + qprev = NULL; + for (sqp = atm_stackq_head; sqp; ) { + + /* + * Got an eligible entry, do STACK_CALL stuff + */ + if (sqp->sq_cmd & STKCMD_UP) { + if (sqp->sq_connvc->cvc_downcnt) { + + /* + * Cant process now, skip it + */ + qprev = sqp; + sqp = sqp->sq_next; + continue; + } + + /* + * OK, dispatch the call + */ + sqp->sq_connvc->cvc_upcnt++; + (*sqp->sq_func)(sqp->sq_cmd, + sqp->sq_token, + sqp->sq_arg1, + sqp->sq_arg2); + sqp->sq_connvc->cvc_upcnt--; + } else { + if (sqp->sq_connvc->cvc_upcnt) { + + /* + * Cant process now, skip it + */ + qprev = sqp; + sqp = sqp->sq_next; + continue; + } + + /* + * OK, dispatch the call + */ + sqp->sq_connvc->cvc_downcnt++; + (*sqp->sq_func)(sqp->sq_cmd, + sqp->sq_token, + sqp->sq_arg1, + sqp->sq_arg2); + sqp->sq_connvc->cvc_downcnt--; + } + + /* + * Dequeue processed entry and free it + */ + cnt++; + qnext = sqp->sq_next; + if (qprev) + qprev->sq_next = qnext; + else + atm_stackq_head = qnext; + if (qnext == NULL) + atm_stackq_tail = qprev; + atm_free((caddr_t)sqp); + sqp = qnext; + } + } while (cnt > 0); + + /* + * Make sure entire queue was drained + */ + if (atm_stackq_head != NULL) + panic("atm_stack_drain: Queue not emptied"); + + (void) splx(s); +} + + +/* + * Process Interrupt Queue + * + * Processes entries on the ATM interrupt queue. This queue is used by + * device interface drivers in order to schedule events from the driver's + * lower (interrupt) half to the driver's stack services. + * + * The interrupt routines must store the stack processing function to call + * and a token (typically a driver/stack control block) at the front of the + * queued buffer. We assume that the function pointer and token values are + * both contained (and properly aligned) in the first buffer of the chain. + * + * Arguments: + * none + * + * Returns: + * none + * + */ +void +atm_intr() +{ + KBuffer *m; + caddr_t cp; + atm_intr_func_t func; + void *token; + int s; + + for (; ; ) { + /* + * Get next buffer from queue + */ + s = splimp(); + IF_DEQUEUE(&atm_intrq, m); + (void) splx(s); + if (m == NULL) + break; + + /* + * Get function to call and token value + */ + KB_DATASTART(m, cp, caddr_t); + func = *(atm_intr_func_t *)cp; + cp += sizeof(func); + token = *(void **)cp; + KB_HEADADJ(m, -(sizeof(func) + sizeof(token))); + if (KB_LEN(m) == 0) { + KBuffer *m1; + KB_UNLINKHEAD(m, m1); + m = m1; + } + + /* + * Call processing function + */ + (*func)(token, m); + + /* + * Drain any deferred calls + */ + STACK_DRAIN(); + } +} + +#ifdef __FreeBSD__ +NETISR_SET(NETISR_ATM, atm_intr); +#endif + + +/* + * Print a pdu buffer chain + * + * Arguments: + * m pointer to pdu buffer chain + * msg pointer to message header string + * + * Returns: + * none + * + */ +void +atm_pdu_print(m, msg) + KBuffer *m; + char *msg; +{ + caddr_t cp; + int i; + char c = ' '; + + printf("%s:", msg); + while (m) { + KB_DATASTART(m, cp, caddr_t); + printf("%cbfr=0x%x data=0x%x len=%d: ", + c, (int)m, (int)cp, KB_LEN(m)); + c = '\t'; + if (atm_print_data) { + for (i = 0; i < KB_LEN(m); i++) { + printf("%2x ", (u_char)*cp++); + } + printf("<end_bfr>\n"); + } else { + printf("\n"); + } + m = KB_NEXT(m); + } +} + diff --git a/sys/netatm/atm_sys.h b/sys/netatm/atm_sys.h new file mode 100644 index 0000000..4cfb031 --- /dev/null +++ b/sys/netatm/atm_sys.h @@ -0,0 +1,275 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_sys.h,v 1.12 1998/05/18 19:05:57 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * General system definitions + * + */ + +#ifndef _NETATM_ATM_SYS_H +#define _NETATM_ATM_SYS_H + +/* + * Software Version + */ +#define ATM_VERSION 0x00030000 /* Version 3.0 */ +#define ATM_VERS_MAJ(v) ((v) >> 16) +#define ATM_VERS_MIN(v) ((v) & 0xffff) + + +/* + * Misc system defines + */ +#define ATM_CALLQ_MAX 100 /* Maximum length of call queue */ +#define ATM_INTRQ_MAX 1000 /* Maximum length of interrupt queue */ + + +/* + * ATM address manipulation macros + */ +#define ATM_ADDR_EQUAL(a1, a2) \ + (((a1)->address_format == (a2)->address_format) && \ + ((a1)->address_length == (a2)->address_length) && \ + (bcmp((caddr_t)(a1)->address, (caddr_t)(a2)->address, \ + (a1)->address_length) == 0)) + +#define ATM_ADDR_SEL_EQUAL(a1, s1, a2) \ + (((a1)->address_format == (a2)->address_format) && \ + ((a1)->address_length == (a2)->address_length) && \ + (((((a1)->address_format == T_ATM_ENDSYS_ADDR) || \ + ((a1)->address_format == T_ATM_NSAP_ADDR)) && \ + (bcmp((caddr_t)(a1)->address, (caddr_t)(a2)->address, \ + (a1)->address_length - 1) == 0) && \ + ((s1) == ((struct atm_addr_nsap *)(a2)->address)->aan_sel)) || \ + (((a1)->address_format != T_ATM_ENDSYS_ADDR) && \ + ((a1)->address_format != T_ATM_NSAP_ADDR) && \ + (bcmp((caddr_t)(a1)->address, (caddr_t)(a2)->address, \ + (a1)->address_length) == 0)))) + +#define ATM_ADDR_COPY(a1, a2) \ +{ \ + (a2)->address_format = (a1)->address_format; \ + (a2)->address_length = (a1)->address_length; \ + XM_COPY((caddr_t)(a1)->address, (caddr_t)(a2)->address, \ + (a1)->address_length); \ +} + +#define ATM_ADDR_SEL_COPY(a1, s1, a2) \ +{ \ + (a2)->address_format = (a1)->address_format; \ + (a2)->address_length = (a1)->address_length; \ + if (((a1)->address_format == T_ATM_ENDSYS_ADDR) || \ + ((a1)->address_format == T_ATM_NSAP_ADDR)) { \ + XM_COPY((caddr_t)(a1)->address, (caddr_t)(a2)->address, \ + (a1)->address_length - 1); \ + ((struct atm_addr_nsap *)(a2)->address)->aan_sel = (s1);\ + } else { \ + XM_COPY((caddr_t)(a1)->address, (caddr_t)(a2)->address, \ + (a1)->address_length); \ + } \ +} + + +/* + * ATM Cell Header definitions + */ + +/* + * These macros assume that the cell header (minus the HEC) + * is contained in the least-significant 32-bits of a word + */ +#define ATM_HDR_SET_VPI(vpi) (((vpi) & 0xff) << 20) +#define ATM_HDR_SET_VCI(vci) (((vci) & 0xffff) << 4) +#define ATM_HDR_SET_PT(pt) (((pt) & 0x7) << 1) +#define ATM_HDR_SET_CLP(clp) ((clp) & 0x1) +#define ATM_HDR_SET(vpi,vci,pt,clp) (ATM_HDR_SET_VPI(vpi) | \ + ATM_HDR_SET_VCI(vci) | \ + ATM_HDR_SET_PT(pt) | \ + ATM_HDR_SET_CLP(clp)) +#define ATM_HDR_GET_VPI(hdr) (((hdr) >> 20) & 0xff) +#define ATM_HDR_GET_VCI(hdr) (((hdr) >> 4) & 0xffff) +#define ATM_HDR_GET_PT(hdr) (((hdr) >> 1) & 0x7) +#define ATM_HDR_GET_CLP(hdr) ((hdr) & 0x1) + +/* + * Payload Type Identifier (3 bits) + */ +#define ATM_PT_USER_SDU0 0x0 /* User, no congestion, sdu type 0 */ +#define ATM_PT_USER_SDU1 0x1 /* User, no congestion, sdu type 1 */ +#define ATM_PT_USER_CONG_SDU0 0x2 /* User, congestion, sdu type 0 */ +#define ATM_PT_USER_CONG_SDU1 0x3 /* User, congestion, sdu type 1 */ +#define ATM_PT_NONUSER 0x4 /* User/non-user differentiator */ +#define ATM_PT_OAMF5_SEG 0x4 /* OAM F5 segment flow */ +#define ATM_PT_OAMF5_E2E 0x5 /* OAM F5 end-to-end flow */ + + +/* + * AAL (ATM Adaptation Layer) codes + */ +typedef u_char Aal_t; +#define ATM_AAL0 0 /* AAL0 - Cell service */ +#define ATM_AAL1 1 /* AAL1 */ +#define ATM_AAL2 2 /* AAL2 */ +#define ATM_AAL3_4 3 /* AAL3/4 */ +#define ATM_AAL5 5 /* AAL5 */ + + +/* + * VCC Encapsulation codes + */ +typedef u_char Encaps_t; +#define ATM_ENC_NULL 1 /* Null encapsulation */ +#define ATM_ENC_LLC 2 /* LLC encapsulation */ + + +#ifdef ATM_KERNEL +/* + * ATM timer control block. Used to schedule a timeout via atm_timeout(). + * This control block will typically be embedded in a processing-specific + * control block. + */ +struct atm_time { + u_short ti_ticks; /* Delta of ticks until timeout */ + u_char ti_flag; /* Timer flag bits (see below) */ + void (*ti_func) /* Call at timeout expiration */ + __P((struct atm_time *)); + struct atm_time *ti_next; /* Next on queue */ +}; + +/* + * Timer Flags + */ +#define TIF_QUEUED 0x01 /* Control block on timer queue */ + +#define ATM_HZ 2 /* Time ticks per second */ + + +/* + * To avoid heavy use of kmem_alloc, memory for protocol control blocks may + * be allocated from storage pools. Each control block type will have + * its own pool. Each storage pool will consist of individually allocated + * memory chunks, which will then be sub-divided into the separate control + * blocks. Each chunk will contain a header (sp_chunk) and 'n' blocks of the + * same type, plus a link field for each block. Each chunk will also contain + * a list of all free control blocks in the chunk. + * + * Each protocol must define an sp_info structure for each of its storage + * pools. This structure serves as the "root" for its particular pool. + * Protocols must not modify this structure after its first use. + */ +struct sp_info { + /* Values supplied by pool owner */ + char *si_name; /* Name of pool */ + size_t si_blksiz; /* Size of each block */ + int si_blkcnt; /* Blocks per chunk */ + int si_maxallow; /* Maximum allowable chunks */ + + /* Used by allocate/free functions - do not touch */ + struct sp_info *si_next; /* Next active storage pool */ + struct sp_chunk *si_poolh; /* Storage pool chunk head */ + struct sp_chunk *si_poolt; /* Storage pool chunk tail */ + size_t si_chunksiz; /* Size of chunk */ + int si_chunks; /* Current allocated chunks */ + int si_total; /* Total number of blocks */ + int si_free; /* Free blocks */ + int si_maxused; /* Maximum allocated chunks */ + int si_allocs; /* Total allocate calls */ + int si_fails; /* Allocate failures */ +}; + +struct sp_chunk { + struct sp_chunk *sc_next; /* Next chunk in pool */ + struct sp_info *sc_info; /* Storage pool info */ + u_int sc_magic; /* Chunk magic number */ + int sc_used; /* Allocated blocks in chunk */ + struct sp_link *sc_freeh; /* Head of free blocks in chunk */ + struct sp_link *sc_freet; /* Tail of free blocks in chunk */ +}; + +struct sp_link { + union { + struct sp_link *slu_next; /* Next block in free list */ + struct sp_chunk *slu_chunk; /* Link back to our chunk */ + } sl_u; +}; + +#define SPOOL_MAGIC 0x73d4b69c /* Storage pool magic number */ +#define SPOOL_MIN_CHUNK 2 /* Minimum number of chunks */ +#define SPOOL_ROUNDUP 16 /* Roundup for allocated chunks */ +#define SPOOL_COMPACT (300 * ATM_HZ) /* Compaction timeout value */ + +/* + * Debugging + */ +#ifdef DIAGNOSTIC +#define ATM_TIME \ + struct timeval now, delta; \ + KT_TIME(now); \ + delta.tv_sec = now.tv_sec - atm_debugtime.tv_sec; \ + delta.tv_usec = now.tv_usec - atm_debugtime.tv_usec; \ + atm_debugtime = now; \ + if (delta.tv_usec < 0) { \ + delta.tv_sec--; \ + delta.tv_usec += 1000000; \ + } \ + printf("%3d.%6d: ", delta.tv_sec, delta.tv_usec); + +#define ATM_DEBUG0(f) if (atm_debug) {ATM_TIME; printf(f);} +#define ATM_DEBUGN0(f) if (atm_debug) {printf(f);} +#define ATM_DEBUG1(f,a1) if (atm_debug) {ATM_TIME; printf(f, a1);} +#define ATM_DEBUGN1(f,a1) if (atm_debug) {printf(f, a1);} +#define ATM_DEBUG2(f,a1,a2) if (atm_debug) {ATM_TIME; printf(f, a1, a2);} +#define ATM_DEBUGN2(f,a1,a2) if (atm_debug) {printf(f, a1, a2);} +#define ATM_DEBUG3(f,a1,a2,a3) if (atm_debug) {ATM_TIME; printf(f, a1, a2, a3);} +#define ATM_DEBUGN3(f,a1,a2,a3) if (atm_debug) {printf(f, a1, a2, a3);} +#define ATM_DEBUG4(f,a1,a2,a3,a4) if (atm_debug) {ATM_TIME; printf(f, a1, a2, a3, a4);} +#define ATM_DEBUGN4(f,a1,a2,a3,a4) if (atm_debug) {printf(f, a1, a2, a3, a4);} +#define ATM_DEBUG5(f,a1,a2,a3,a4,a5) if (atm_debug) {ATM_TIME; printf(f, a1, a2, a3, a4, a5);} +#define ATM_DEBUGN5(f,a1,a2,a3,a4,a5) if (atm_debug) {printf(f, a1, a2, a3, a4, a5);} +#else +#define ATM_DEBUG0(f) +#define ATM_DEBUGN0(f) +#define ATM_DEBUG1(f,a1) +#define ATM_DEBUGN1(f,a1) +#define ATM_DEBUG2(f,a1,a2) +#define ATM_DEBUGN2(f,a1,a2) +#define ATM_DEBUG3(f,a1,a2,a3) +#define ATM_DEBUGN3(f,a1,a2,a3) +#define ATM_DEBUG4(f,a1,a2,a3,a4) +#define ATM_DEBUGN4(f,a1,a2,a3,a4) +#define ATM_DEBUG5(f,a1,a2,a3,a4,a5) +#define ATM_DEBUGN5(f,a1,a2,a3,a4,a5) +#endif + +#endif /* ATM_KERNEL */ + +#endif /* _NETATM_ATM_SYS_H */ diff --git a/sys/netatm/atm_usrreq.c b/sys/netatm/atm_usrreq.c new file mode 100644 index 0000000..4231d1c --- /dev/null +++ b/sys/netatm/atm_usrreq.c @@ -0,0 +1,711 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_usrreq.c,v 1.7 1998/06/29 21:51:29 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM DGRAM socket protocol processing + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: atm_usrreq.c,v 1.7 1998/06/29 21:51:29 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + + +/* + * Local functions + */ +static int atm_dgram_attach __P((struct socket *, int, struct proc *)); +static int atm_dgram_control __P((struct socket *, u_long, caddr_t, + struct ifnet *, struct proc *)); +static int atm_dgram_info __P((caddr_t)); + + +/* + * New-style socket request routines + */ +#if (defined(__FreeBSD__) && (BSD >= 199506)) +struct pr_usrreqs atm_dgram_usrreqs = { + atm_proto_notsupp1, /* pru_abort */ + pru_accept_notsupp, /* pru_accept */ + atm_dgram_attach, /* pru_attach */ + atm_proto_notsupp2, /* pru_bind */ + pru_connect_notsupp, /* pru_connect */ + pru_connect2_notsupp, /* pru_connect2 */ + atm_dgram_control, /* pru_control */ + atm_proto_notsupp1, /* pru_detach */ + atm_proto_notsupp1, /* pru_disconnect */ + pru_listen_notsupp, /* pru_listen */ + atm_proto_notsupp3, /* pru_peeraddr */ + pru_rcvd_notsupp, /* pru_rcvd */ + pru_rcvoob_notsupp, /* pru_rcvoob */ + atm_proto_notsupp4, /* pru_send */ + pru_sense_null, /* pru_sense */ + atm_proto_notsupp1, /* pru_shutdown */ + atm_proto_notsupp3, /* pru_sockaddr */ +}; +#endif + + +/* + * Handy common code macros + */ +#ifdef DIAGNOSTIC +#define ATM_INTRO() \ + int s, err = 0; \ + s = splnet(); \ + /* \ + * Stack queue should have been drained \ + */ \ + if (atm_stackq_head != NULL) \ + panic("atm_usrreq: stack queue not empty"); \ + ; +#else +#define ATM_INTRO() \ + int s, err = 0; \ + s = splnet(); \ + ; +#endif + +#define ATM_OUTRO() \ +done: \ + /* \ + * Drain any deferred calls \ + */ \ + STACK_DRAIN(); \ + (void) splx(s); \ + return (err); \ + ; + +#define ATM_RETERR(errno) { \ + err = errno; \ + goto done; \ +} + + +/* + * Attach protocol to socket + * + * Arguments: + * so pointer to socket + * proto protocol identifier + * p pointer to process + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_dgram_attach(so, proto, p) + struct socket *so; + int proto; + struct proc *p; +{ + ATM_INTRO(); + + /* + * Nothing to do here for ioctl()-only sockets + */ + ATM_OUTRO(); +} + + +/* + * Process ioctl system calls + * + * Arguments: + * so pointer to socket + * cmd ioctl code + * data pointer to code specific parameter data area + * ifp pointer to ifnet structure if it's an interface ioctl + * p pointer to process + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_dgram_control(so, cmd, data, ifp, p) + struct socket *so; + u_long cmd; + caddr_t data; + struct ifnet *ifp; + struct proc *p; +{ + ATM_INTRO(); + + /* + * First, figure out which ioctl we're dealing with and + * then process it based on the sub-op code + */ + switch (cmd) { + + case AIOCCFG: { + struct atmcfgreq *acp = (struct atmcfgreq *)data; + struct atm_pif *pip; + + if (p && (suser(p->p_ucred, &p->p_acflag) != 0)) + ATM_RETERR(EPERM); + + switch (acp->acr_opcode) { + + case AIOCS_CFG_ATT: + /* + * Attach signalling manager + */ + if ((pip = atm_pifname(acp->acr_att_intf)) == NULL) + ATM_RETERR(ENXIO); + err = atm_sigmgr_attach(pip, acp->acr_att_proto); + break; + + case AIOCS_CFG_DET: + /* + * Detach signalling manager + */ + if ((pip = atm_pifname(acp->acr_det_intf)) == NULL) + ATM_RETERR(ENXIO); + err = atm_sigmgr_detach(pip); + break; + + default: + err = EOPNOTSUPP; + } + break; + } + + case AIOCADD: { + struct atmaddreq *aap = (struct atmaddreq *)data; + Atm_endpoint *epp; + + if (p && (suser(p->p_ucred, &p->p_acflag) != 0)) + ATM_RETERR(EPERM); + + switch (aap->aar_opcode) { + + case AIOCS_ADD_PVC: + /* + * Add a PVC definition + */ + + /* + * Locate requested endpoint service + */ + epp = aap->aar_pvc_sap > ENDPT_MAX ? NULL : + atm_endpoints[aap->aar_pvc_sap]; + if (epp == NULL) + ATM_RETERR(ENOPROTOOPT); + + /* + * Let endpoint service handle it from here + */ + err = (*epp->ep_ioctl)(AIOCS_ADD_PVC, data, NULL); + break; + + case AIOCS_ADD_ARP: + /* + * Add an ARP mapping + */ + epp = atm_endpoints[ENDPT_IP]; + if (epp == NULL) + ATM_RETERR(ENOPROTOOPT); + + /* + * Let IP/ATM endpoint handle this + */ + err = (*epp->ep_ioctl) (AIOCS_ADD_ARP, data, NULL); + break; + + default: + err = EOPNOTSUPP; + } + break; + } + + case AIOCDEL: { + struct atmdelreq *adp = (struct atmdelreq *)data; + struct atm_pif *pip; + struct sigmgr *smp; + Atm_endpoint *epp; + + if (p && (suser(p->p_ucred, &p->p_acflag) != 0)) + ATM_RETERR(EPERM); + + switch (adp->adr_opcode) { + + case AIOCS_DEL_PVC: + case AIOCS_DEL_SVC: + /* + * Delete a PVC or SVC + */ + + /* + * Locate appropriate sigmgr + */ + if ((pip = atm_pifname(adp->adr_pvc_intf)) == NULL) + ATM_RETERR(ENXIO); + if ((smp = pip->pif_sigmgr) == NULL) + ATM_RETERR(ENOENT); + + /* + * Let sigmgr handle it from here + */ + err = (*smp->sm_ioctl)(adp->adr_opcode, data, + (caddr_t)pip->pif_siginst); + break; + + case AIOCS_DEL_ARP: + /* + * Delete an ARP mapping + */ + epp = atm_endpoints[ENDPT_IP]; + if (epp == NULL) + ATM_RETERR(ENOPROTOOPT); + + /* + * Let IP/ATM endpoint handle this + */ + err = (*epp->ep_ioctl) (AIOCS_DEL_ARP, data, NULL); + break; + + default: + err = EOPNOTSUPP; + } + break; + } + + case AIOCSET: { + struct atmsetreq *asp = (struct atmsetreq *)data; + struct atm_pif *pip; + struct atm_nif *nip; + struct sigmgr *smp; + struct ifnet *ifp2; + + if (p && (suser(p->p_ucred, &p->p_acflag) != 0)) + ATM_RETERR(EPERM); + + switch (asp->asr_opcode) { + + case AIOCS_SET_ASV: + /* + * Set an ARP server address + */ + + /* + * Locate appropriate sigmgr + */ + if ((nip = atm_nifname(asp->asr_arp_intf)) == NULL) + ATM_RETERR(ENXIO); + pip = nip->nif_pif; + if ((smp = pip->pif_sigmgr) == NULL) + ATM_RETERR(ENOENT); + + /* + * Let sigmgr handle it from here + */ + err = (*smp->sm_ioctl)(AIOCS_SET_ASV, data, + (caddr_t)nip); + break; + + case AIOCS_SET_MAC: + /* + * Set physical interface MAC/ESI address + */ + + /* + * Locate physical interface + */ + if ((pip = atm_pifname(asp->asr_mac_intf)) == NULL) + ATM_RETERR(ENXIO); + + /* + * Interface must be detached + */ + if (pip->pif_sigmgr != NULL) + ATM_RETERR(EADDRINUSE); + + /* + * Just plunk the address into the pif + */ + KM_COPY((caddr_t)&asp->asr_mac_addr, + (caddr_t)&pip->pif_macaddr, + sizeof(struct mac_addr)); + break; + + case AIOCS_SET_NIF: + /* + * Define network interfaces + */ + if ((pip = atm_pifname(asp->asr_nif_intf)) == NULL) + ATM_RETERR(ENXIO); + + /* + * Validate interface count - logical interfaces + * are differentiated by the atm address selector. + */ + if ((asp->asr_nif_cnt <= 0) || (asp->asr_nif_cnt > 256)) + ATM_RETERR(EINVAL); + + /* + * Make sure prefix name is unique + */ + TAILQ_FOREACH(ifp2, &ifnet, if_link) { + if (!strcmp(ifp2->if_name, asp->asr_nif_pref)) { + /* + * If this is for the interface we're + * (re-)defining, let it through + */ + for (nip = pip->pif_nif; nip; + nip = nip->nif_pnext) { + if (&nip->nif_if == ifp2) + break; + } + if (nip) + continue; + ATM_RETERR(EEXIST); + } + } + + /* + * Let interface handle it from here + */ + err = (*pip->pif_ioctl)(AIOCS_SET_NIF, data, + (caddr_t)pip); + break; + + case AIOCS_SET_PRF: + /* + * Set interface NSAP Prefix + */ + + /* + * Locate appropriate sigmgr + */ + if ((pip = atm_pifname(asp->asr_prf_intf)) == NULL) + ATM_RETERR(ENXIO); + if ((smp = pip->pif_sigmgr) == NULL) + ATM_RETERR(ENOENT); + + /* + * Let sigmgr handle it from here + */ + err = (*smp->sm_ioctl)(AIOCS_SET_PRF, data, + (caddr_t)pip->pif_siginst); + break; + + default: + err = EOPNOTSUPP; + } + break; + } + + case AIOCINFO: + err = atm_dgram_info(data); + break; + + default: + err = EOPNOTSUPP; + } + + ATM_OUTRO(); +} + + +/* + * Process AIOCINFO ioctl system calls + * + * Called at splnet. + * + * Arguments: + * data pointer to AIOCINFO parameter structure + * + * Returns: + * 0 request processed + * errno error processing request - reason indicated + * + */ +static int +atm_dgram_info(data) + caddr_t data; +{ + struct atminfreq *aip = (struct atminfreq *)data; + struct atm_pif *pip; + struct atm_nif *nip; + struct sigmgr *smp; + Atm_endpoint *epp; + int len = aip->air_buf_len; + int err = 0; + + switch (aip->air_opcode) { + + case AIOCS_INF_VST: + case AIOCS_INF_CFG: + /* + * Get vendor interface information + */ + if (aip->air_vinfo_intf[0] != '\0') { + /* + * Interface specified + */ + if ((pip = atm_pifname(aip->air_vinfo_intf))) { + err = (*pip->pif_ioctl)(aip->air_opcode, data, + (caddr_t)pip); + } else { + err = ENXIO; + } + } else { + /* + * Want info for every interface + */ + for (pip = atm_interface_head; pip; + pip = pip->pif_next) { + err = (*pip->pif_ioctl)(aip->air_opcode, data, + (caddr_t)pip); + if (err) + break; + } + } + break; + + case AIOCS_INF_IPM: + /* + * Get IP Map information + */ + epp = atm_endpoints[ENDPT_IP]; + if (epp) { + err = (*epp->ep_ioctl) (AIOCS_INF_IPM, data, NULL); + } else { + err = ENOPROTOOPT; + } + break; + + case AIOCS_INF_ARP: + /* + * Get ARP table information + */ + for (pip = atm_interface_head; pip; pip = pip->pif_next) { + if (smp = pip->pif_sigmgr) { + err = (*smp->sm_ioctl)(AIOCS_INF_ARP, + data, (caddr_t)pip->pif_siginst); + } + if (err) + break; + } + break; + + case AIOCS_INF_ASV: + /* + * Get ARP server information + */ + if (aip->air_asrv_intf[0] != '\0') { + /* + * Interface specified + */ + if ((nip = atm_nifname(aip->air_asrv_intf))) { + if (smp = nip->nif_pif->pif_sigmgr) { + err = (*smp->sm_ioctl)(AIOCS_INF_ASV, + data, (caddr_t)nip); + } + } else { + err = ENXIO; + } + } else { + /* + * Want info for all arp servers + */ + for (pip = atm_interface_head; pip; + pip = pip->pif_next) { + if (smp = pip->pif_sigmgr) { + err = (*smp->sm_ioctl)(AIOCS_INF_ASV, + data, NULL); + } + if (err) + break; + } + } + break; + + case AIOCS_INF_INT: + /* + * Get physical interface info + */ + if (aip->air_int_intf[0] != '\0') { + /* + * Interface specified + */ + if ((pip = atm_pifname(aip->air_int_intf))) { + err = (*pip->pif_ioctl)(AIOCS_INF_INT, + data, (caddr_t)pip); + } else { + err = ENXIO; + } + } else { + /* + * Want info for every physical interface + */ + for (pip = atm_interface_head; pip; + pip = pip->pif_next) { + err = (*pip->pif_ioctl)(AIOCS_INF_INT, + data, (caddr_t)pip); + if (err) + break; + } + } + break; + + case AIOCS_INF_VCC: + /* + * Get VCC information + */ + if (aip->air_vcc_intf[0] != '\0') { + /* + * Interface specified + */ + if ((pip = atm_pifname(aip->air_vcc_intf))) { + if (smp = pip->pif_sigmgr) { + err = (*smp->sm_ioctl)(AIOCS_INF_VCC, + data, + (caddr_t)pip->pif_siginst); + } + } else { + err = ENXIO; + } + } else { + /* + * Want info for every interface + */ + for (pip = atm_interface_head; pip; + pip = pip->pif_next) { + if (smp = pip->pif_sigmgr) { + err = (*smp->sm_ioctl)(AIOCS_INF_VCC, + data, + (caddr_t)pip->pif_siginst); + } + if (err) + break; + } + } + break; + + case AIOCS_INF_NIF: + /* + * Get network interface info + */ + if (aip->air_int_intf[0] != '\0') { + /* + * Interface specified + */ + if ((nip = atm_nifname(aip->air_int_intf))) { + pip = nip->nif_pif; + err = (*pip->pif_ioctl)(AIOCS_INF_NIF, + data, (caddr_t)nip); + } else { + err = ENXIO; + } + } else { + /* + * Want info for every network interface + */ + for (pip = atm_interface_head; pip; + pip = pip->pif_next) { + for (nip = pip->pif_nif; nip; + nip = nip->nif_pnext) { + err = (*pip->pif_ioctl)(AIOCS_INF_NIF, + data, (caddr_t)nip); + if (err) + break; + } + if (err) + break; + } + } + break; + + case AIOCS_INF_PIS: + /* + * Get physical interface statistics + */ + if (aip->air_physt_intf[0] != '\0') { + /* + * Interface specified + */ + if ((pip = atm_pifname(aip->air_physt_intf))) { + err = (*pip->pif_ioctl)(AIOCS_INF_PIS, + data, (caddr_t)pip); + } else { + err = ENXIO; + } + } else { + /* + * Want statistics for every physical interface + */ + for (pip = atm_interface_head; pip; + pip = pip->pif_next) { + err = (*pip->pif_ioctl)(AIOCS_INF_PIS, + data, (caddr_t)pip); + if (err) + break; + } + } + break; + + case AIOCS_INF_VER: + /* + * Get ATM software version + */ + if (len < sizeof(atm_version)) { + err = ENOSPC; + break; + } + if (err = copyout((caddr_t)&atm_version, + aip->air_buf_addr, + sizeof(atm_version))) { + break; + } + aip->air_buf_addr += sizeof(atm_version); + aip->air_buf_len -= sizeof(atm_version); + break; + + default: + err = EOPNOTSUPP; + } + + /* + * Calculate returned buffer length + */ + aip->air_buf_len = len - aip->air_buf_len; + + return (err); +} + diff --git a/sys/netatm/atm_var.h b/sys/netatm/atm_var.h new file mode 100644 index 0000000..ab5f856 --- /dev/null +++ b/sys/netatm/atm_var.h @@ -0,0 +1,208 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_var.h,v 1.9 1998/05/18 19:05:52 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM system variables + * + */ + +#ifndef _NETATM_ATM_VAR_H +#define _NETATM_ATM_VAR_H + + +#ifdef ATM_KERNEL +/* + * Global variable declarations + */ + /* atm_aal5.c */ +#if (defined(__FreeBSD__) && (BSD >= 199506)) +extern struct pr_usrreqs atm_aal5_usrreqs; +#endif + + /* atm_proto.c */ +extern struct domain atmdomain; + + /* atm_subr.c */ +extern struct atm_pif *atm_interface_head; +extern struct atm_ncm *atm_netconv_head; +extern Atm_endpoint *atm_endpoints[]; +extern struct sp_info *atm_pool_head; +extern struct stackq_entry *atm_stackq_head; +extern struct stackq_entry *atm_stackq_tail; +extern struct ifqueue atm_intrq; +#ifdef sgi +extern int atm_intr_index; +#endif +extern struct atm_sock_stat atm_sock_stat; +extern int atm_init; +extern int atm_version; +extern int atm_debug; +extern struct timeval atm_debugtime; +extern int atm_dev_print; +extern int atm_print_data; +extern struct sp_info atm_attributes_pool; + + /* atm_usrreq.c */ +#if (defined(__FreeBSD__) && (BSD >= 199506)) +extern struct pr_usrreqs atm_dgram_usrreqs; +#endif + + +/* + * Global function declarations + */ + /* atm_aal5.c */ +int atm_aal5_ctloutput __P((struct socket *, struct sockopt *)); +void atm_aal5_init __P((void)); + + /* atm_cm.c */ +int atm_cm_connect __P((Atm_endpoint *, void *, Atm_attributes *, + Atm_connection **)); +int atm_cm_listen __P((Atm_endpoint *, void *, Atm_attributes *, + Atm_connection **)); +int atm_cm_addllc __P((Atm_endpoint *, void *, struct attr_llc *, + Atm_connection *, Atm_connection **)); +int atm_cm_addparty __P((Atm_connection *, int, + struct t_atm_sap *)); +int atm_cm_dropparty __P((Atm_connection *, int, + struct t_atm_cause *)); +int atm_cm_release __P((Atm_connection *, struct t_atm_cause *)); +int atm_cm_abort __P((Atm_connvc *, struct t_atm_cause *)); +int atm_cm_incoming __P((struct vccb *, Atm_attributes *)); +void atm_cm_connected __P((Atm_connvc *)); +void atm_cm_cleared __P((Atm_connvc *)); +Atm_connection *atm_cm_match __P((Atm_attributes *, Atm_connection *)); +int atm_cm_cpcs_ctl __P((int, Atm_connection *, void *)); +int atm_cm_cpcs_data __P((Atm_connection *, KBuffer *)); +int atm_cm_saal_ctl __P((int, Atm_connection *, void *)); +int atm_cm_saal_data __P((Atm_connection *, KBuffer *)); +int atm_cm_sscop_ctl __P((int, Atm_connection *, void *, void *)); +int atm_cm_sscop_data __P((Atm_connection *, KBuffer *)); +int atm_endpoint_register __P((Atm_endpoint *)); +int atm_endpoint_deregister __P((Atm_endpoint *)); + + /* atm_device.c */ +int atm_dev_inst __P((struct stack_defn **, Atm_connvc *)); +void atm_dev_lower __P((int, void *, int, int)); +void * atm_dev_alloc __P((u_int, u_int, u_int)); +void atm_dev_free __P((void *)); +#if defined(sun4m) +void * atm_dma_map __P((caddr_t, int, int)); +void atm_dma_free __P((caddr_t, int)); +#endif +KBuffer * atm_dev_compress __P((KBuffer *)); +Cmn_vcc * atm_dev_vcc_find __P((Cmn_unit *, u_int, u_int, u_int)); +void atm_dev_pdu_print __P((Cmn_unit *, Cmn_vcc *, KBuffer *, + char *)); + + /* atm_if.c */ +int atm_physif_register __P((Cmn_unit *, char *, + struct stack_defn *)); +int atm_physif_deregister __P((Cmn_unit *)); +void atm_physif_freenifs __P((struct atm_pif *)); +int atm_netconv_register __P((struct atm_ncm *)); +int atm_netconv_deregister __P((struct atm_ncm *)); +int atm_nif_attach __P((struct atm_nif *)); +void atm_nif_detach __P((struct atm_nif *)); +int atm_nif_setaddr __P((struct atm_nif *, struct ifaddr *)); +#if (defined(BSD) && (BSD >= 199103)) +int atm_ifoutput __P((struct ifnet *, KBuffer *, + struct sockaddr *, struct rtentry *)); +#else +int atm_ifoutput __P((struct ifnet *, KBuffer *, + struct sockaddr *)); +#endif +struct atm_pif * + atm_pifname __P((char *)); +struct atm_nif * + atm_nifname __P((char *)); + + /* atm_proto.c */ +#if (defined(__FreeBSD__) && (BSD >= 199506)) +int atm_proto_notsupp1 __P((struct socket *)); +int atm_proto_notsupp2 __P((struct socket *, struct sockaddr *, + struct proc *)); +int atm_proto_notsupp3 __P((struct socket *, struct sockaddr **)); +int atm_proto_notsupp4 __P((struct socket *, int, KBuffer *, + struct sockaddr *, KBuffer *, struct proc *)); +#endif + + /* atm_signal.c */ +int atm_sigmgr_register __P((struct sigmgr *)); +int atm_sigmgr_deregister __P((struct sigmgr *)); +int atm_sigmgr_attach __P((struct atm_pif *, u_char)); +int atm_sigmgr_detach __P((struct atm_pif *)); +int atm_stack_register __P((struct stack_defn *)); +int atm_stack_deregister __P((struct stack_defn *)); +int atm_create_stack __P((Atm_connvc *, struct stack_list *, + void (*)__P((int, void *, int, int)) )); + + /* atm_socket.c */ +int atm_sock_attach __P((struct socket *, u_long, u_long)); +int atm_sock_detach __P((struct socket *)); +int atm_sock_bind __P((struct socket *, struct sockaddr *)); +int atm_sock_listen __P((struct socket *, Atm_endpoint *)); +int atm_sock_connect __P((struct socket *, struct sockaddr *, + Atm_endpoint *)); +int atm_sock_disconnect __P((struct socket *)); +int atm_sock_sockaddr __P((struct socket *, struct sockaddr **)); +int atm_sock_peeraddr __P((struct socket *, struct sockaddr **)); +int atm_sock_setopt __P((struct socket *, struct sockopt *, + Atm_pcb *)); +int atm_sock_getopt __P((struct socket *, struct sockopt *, + Atm_pcb *)); +void atm_sock_connected __P((void *)); +void atm_sock_cleared __P((void *, struct t_atm_cause *)); + + /* atm_subr.c */ +void atm_initialize __P((void)); +void * atm_allocate __P((struct sp_info *)); +void atm_free __P((void *)); +void atm_release_pool __P((struct sp_info *)); +void atm_timeout __P((struct atm_time *, int, + void (*) __P((struct atm_time *)) )); +int atm_untimeout __P((struct atm_time *)); +int atm_stack_enq __P((int, void (*) __P((int, void *, int, int)), + void *, Atm_connvc *, int, int)); +void atm_stack_drain __P((void)); +void atm_intr __P((void)); +void atm_pdu_print __P((KBuffer *, char *)); + + /* atm_usrreq.c */ +#if (!(defined(__FreeBSD__) && (BSD >= 199506))) +int atm_dgram_usrreq __P((struct socket *, int, KBuffer *, + KBuffer *, KBuffer *)); +#endif + +#endif /* ATM_KERNEL */ + +#endif /* _NETATM_ATM_VAR_H */ diff --git a/sys/netatm/atm_vc.h b/sys/netatm/atm_vc.h new file mode 100644 index 0000000..1c7c7b0 --- /dev/null +++ b/sys/netatm/atm_vc.h @@ -0,0 +1,89 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: atm_vc.h,v 1.6 1998/02/19 20:00:34 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * ATM Virtual Channel definitions + * + */ + +#ifndef _NETATM_ATM_VC_H +#define _NETATM_ATM_VC_H + + +#ifdef ATM_KERNEL +/* + * ATM Virtual Channel Connection control block. All vccb's are created + * and controlled by an ATM signalling manager. Each ATM signalling + * protocol will also have its own protocol-specific vccb format. Each + * of these protocol vccb's must have this common block at the beginning. + */ +struct vccb { + u_char vc_type; /* VCC type (see below) */ + u_char vc_proto; /* Signalling protocol */ + u_char vc_sstate; /* Signalling state (sigmgr specific) */ + u_char vc_ustate; /* User interface state (see below) */ + struct atm_pif *vc_pif; /* Physical interface */ + struct atm_nif *vc_nif; /* Network interface */ + Qelem_t vc_sigelem; /* Signalling instance vccb queue */ + struct atm_time vc_time; /* Timer controls */ + u_short vc_vpi; /* Virtual Path Identifier */ + u_short vc_vci; /* Virtual Channel Identifier */ + Atm_connvc *vc_connvc; /* CM connection VCC instance */ + long vc_ipdus; /* PDUs received from VCC */ + long vc_opdus; /* PDUs sent to VCC */ + long vc_ibytes; /* Bytes received from VCC */ + long vc_obytes; /* Bytes sent to VCC */ + long vc_ierrors; /* Errors receiving from VCC */ + long vc_oerrors; /* Errors sending to VCC */ + time_t vc_tstamp; /* State transition timestamp */ +}; +#endif /* ATM_KERNEL */ + +/* + * VCC Types + */ +#define VCC_PVC 0x01 /* PVC (Permanent Virtual Channel) */ +#define VCC_SVC 0x02 /* SVC (Switched Virtual Channel) */ +#define VCC_IN 0x04 /* Inbound VCC */ +#define VCC_OUT 0x08 /* Outbound VCC */ + +/* + * VCC Signalling-to-User Interface States + */ +#define VCCU_NULL 0 /* No state */ +#define VCCU_POPEN 1 /* Pending open completion */ +#define VCCU_OPEN 2 /* Connection is open */ +#define VCCU_CLOSED 3 /* Connection has been terminated */ +#define VCCU_ABORT 4 /* Connection being aborted */ + + +#endif /* _NETATM_ATM_VC_H */ diff --git a/sys/netatm/ipatm/ipatm.h b/sys/netatm/ipatm/ipatm.h new file mode 100644 index 0000000..b3ce348 --- /dev/null +++ b/sys/netatm/ipatm/ipatm.h @@ -0,0 +1,55 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: ipatm.h,v 1.5 1998/03/24 20:49:49 mks Exp $ + * + */ + +/* + * IP Over ATM Support + * ------------------- + * + * Protocol definitions + * + */ + +#ifndef _IPATM_IPATM_H +#define _IPATM_IPATM_H + +/* + * Protocol Variables + */ +#define IPATM_VCIDLE 15 /* VCC idle time (minutes) */ +#define IPATM_ARP_TIME (60 * ATM_HZ) /* Wait for ARP answer */ +#define IPATM_SVC_TIME (60 * ATM_HZ) /* Wait for SVC open answer */ +#define IPATM_IDLE_TIME (60 * ATM_HZ) /* VCC idle timer tick */ + +/* + * IP/ATM LLC/SNAP header + */ +#define IPATM_LLC_LEN 8 +#define IPATM_LLC_HDR {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00} + +#endif /* _IPATM_IPATM_H */ diff --git a/sys/netatm/ipatm/ipatm_event.c b/sys/netatm/ipatm/ipatm_event.c new file mode 100644 index 0000000..048edf9 --- /dev/null +++ b/sys/netatm/ipatm/ipatm_event.c @@ -0,0 +1,454 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: ipatm_event.c,v 1.8 1998/08/06 18:21:13 mks Exp $ + * + */ + +/* + * IP Over ATM Support + * ------------------- + * + * IP VCC event handler + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: ipatm_event.c,v 1.8 1998/08/06 18:21:13 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm.h> +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> + + +/* + * Process an IP VCC timeout + * + * Called when a previously scheduled ipvcc control block timer expires. + * Processing will be based on the current ipvcc state. + * + * Called at splnet. + * + * Arguments: + * tip pointer to ipvcc timer control block + * + * Returns: + * none + * + */ +void +ipatm_timeout(tip) + struct atm_time *tip; +{ + struct ipvcc *ivp; + + /* + * Back-off to ipvcc control block + */ + ivp = (struct ipvcc *) + ((caddr_t)tip - (int)(&((struct ipvcc *)0)->iv_time)); + + /* + * Process timeout based on protocol state + */ + switch (ivp->iv_state) { + + case IPVCC_PMAP: + /* + * Give up waiting for arp response + */ + (void) ipatm_closevc(ivp, T_ATM_CAUSE_TEMPORARY_FAILURE); + break; + + case IPVCC_POPEN: + case IPVCC_PACCEPT: + /* + * Give up waiting for signalling manager response + */ + (void) ipatm_closevc(ivp, T_ATM_CAUSE_TEMPORARY_FAILURE); + break; + + case IPVCC_ACTPENT: + /* + * Try again to get an ARP entry + */ + switch ((*ivp->iv_ipnif->inf_serv->is_arp_pvcopen)(ivp)) { + + case MAP_PROCEEDING: + /* + * Wait for answer + */ + ivp->iv_state = IPVCC_ACTIVE; + break; + + case MAP_VALID: + /* + * We've got our answer already + */ + ivp->iv_state = IPVCC_ACTIVE; + ivp->iv_flags |= IVF_MAPOK; + ivp->iv_dst.s_addr = ivp->iv_arpent->am_dstip.s_addr; + break; + + case MAP_FAILED: + /* + * Try again later + */ + IPVCC_TIMER(ivp, 5 * ATM_HZ); + break; + + default: + panic("ipatm_timeout: invalid am_pvcopen return"); + } + break; + + default: + log(LOG_ERR, "ipatm: invalid timer state: ivp=0x%x, state=%d\n", + (int)ivp, ivp->iv_state); + } +} + + +/* + * Process IP VCC Connected Notification + * + * Arguments: + * toku owner's connection token (ipvcc protocol block) + * + * Returns: + * none + * + */ +void +ipatm_connected(toku) + void *toku; +{ + struct ipvcc *ivp = (struct ipvcc *)toku; + + /* + * SVC is connected + */ + if ((ivp->iv_state != IPVCC_POPEN) && + (ivp->iv_state != IPVCC_PACCEPT)) { + log(LOG_ERR, "ipatm: invalid CALL_CONNECTED state=%d\n", + ivp->iv_state); + return; + } + + /* + * Verify possible negotiated parameter values + */ + if (ivp->iv_state == IPVCC_POPEN) { + Atm_attributes *ap = &ivp->iv_conn->co_connvc->cvc_attr; + int mtu = (ivp->iv_flags & IVF_LLC) ? + ATM_NIF_MTU + IPATM_LLC_LEN : + ATM_NIF_MTU; + + /* + * Verify final MTU + */ + if (ap->aal.type == ATM_AAL5) { + if ((ap->aal.v.aal5.forward_max_SDU_size < mtu) || + (ap->aal.v.aal5.backward_max_SDU_size > mtu)) { + (void) ipatm_closevc(ivp, + T_ATM_CAUSE_AAL_PARAMETERS_NOT_SUPPORTED); + return; + } + } else { + if ((ap->aal.v.aal4.forward_max_SDU_size < mtu) || + (ap->aal.v.aal4.backward_max_SDU_size > mtu)) { + (void) ipatm_closevc(ivp, + T_ATM_CAUSE_AAL_PARAMETERS_NOT_SUPPORTED); + return; + } + } + } + + /* + * Finish up VCC activation + */ + ipatm_activate(ivp); +} + + +/* + * Process IP VCC Cleared Notification + * + * Arguments: + * toku owner's connection token (ipvcc protocol block) + * cause pointer to cause code + * + * Returns: + * none + * + */ +void +ipatm_cleared(toku, cause) + void *toku; + struct t_atm_cause *cause; +{ + struct ipvcc *ivp = (struct ipvcc *)toku; + + + /* + * VCC has been cleared, so figure out what's next + */ + ivp->iv_conn = NULL; + + switch (ivp->iv_state) { + + case IPVCC_POPEN: + /* + * Call setup failed, see if there is another + * set of vcc parameters to try + */ + ivp->iv_state = IPVCC_CLOSED; + if (ipatm_retrysvc(ivp)) { + (void) ipatm_closevc(ivp, cause->cause_value); + } + break; + + case IPVCC_PACCEPT: + case IPVCC_ACTPENT: + case IPVCC_ACTIVE: + ivp->iv_state = IPVCC_CLOSED; + (void) ipatm_closevc(ivp, cause->cause_value); + break; + } +} + + +/* + * Process an ARP Event Notification + * + * Arguments: + * ivp pointer to IP VCC control block + * event ARP event type + * + * Returns: + * none + * + */ +void +ipatm_arpnotify(ivp, event) + struct ipvcc *ivp; + int event; +{ + struct sockaddr_in sin; + struct ifnet *ifp; + + /* + * Process event + */ + switch (event) { + + case MAP_VALID: + switch (ivp->iv_state) { + + case IPVCC_PMAP: + /* + * We've got our destination, however, first we'll + * check to make sure no other VCC to our destination + * has also had it's ARP table entry completed. + * If we don't find a better VCC to use, then we'll + * go ahead and open this SVC. + */ + sin.sin_family = AF_INET; + sin.sin_addr.s_addr = ivp->iv_dst.s_addr; + if (ipatm_iptovc(&sin, ivp->iv_ipnif->inf_nif) != ivp) { + /* + * We found a better VCC, so use it and + * get rid of this VCC + */ + if (ivp->iv_queue) { + ifp = (struct ifnet *) + ivp->iv_ipnif->inf_nif; + (void) ipatm_ifoutput(ifp, + ivp->iv_queue, + (struct sockaddr *)&sin); + ivp->iv_queue = NULL; + } + (void) ipatm_closevc(ivp, + T_ATM_CAUSE_UNSPECIFIED_NORMAL); + + } else { + /* + * We like this VCC... + */ + ivp->iv_flags |= IVF_MAPOK; + if (ipatm_opensvc(ivp)) { + (void) ipatm_closevc(ivp, + T_ATM_CAUSE_TEMPORARY_FAILURE); + } + } + break; + + case IPVCC_POPEN: + case IPVCC_PACCEPT: + case IPVCC_ACTIVE: + /* + * Everything looks good, so accept new mapping + */ + ivp->iv_flags |= IVF_MAPOK; + ivp->iv_dst.s_addr = ivp->iv_arpent->am_dstip.s_addr; + + /* + * Send queued packet + */ + if ((ivp->iv_state == IPVCC_ACTIVE) && ivp->iv_queue) { + sin.sin_family = AF_INET; + sin.sin_addr.s_addr = ivp->iv_dst.s_addr; + ifp = (struct ifnet *)ivp->iv_ipnif->inf_nif; + (void) ipatm_ifoutput(ifp, ivp->iv_queue, + (struct sockaddr *)&sin); + ivp->iv_queue = NULL; + } + break; + } + break; + + case MAP_INVALID: + switch (ivp->iv_state) { + + case IPVCC_POPEN: + case IPVCC_PACCEPT: + case IPVCC_ACTIVE: + + /* + * Mapping has gone stale, so we cant use this VCC + * until the mapping is refreshed + */ + ivp->iv_flags &= ~IVF_MAPOK; + break; + } + break; + + case MAP_FAILED: + /* + * ARP lookup failed, just trash it all + */ + (void) ipatm_closevc(ivp, T_ATM_CAUSE_TEMPORARY_FAILURE); + break; + + case MAP_CHANGED: + /* + * ARP mapping has changed + */ + if (ivp->iv_flags & IVF_PVC) { + /* + * For PVCs, just reset lookup cache if needed + */ + if (last_map_ipvcc == ivp) { + last_map_ipdst = 0; + last_map_ipvcc = NULL; + } + } else { + /* + * Close SVC if it has already used this mapping + */ + switch (ivp->iv_state) { + + case IPVCC_POPEN: + case IPVCC_ACTIVE: + (void) ipatm_closevc(ivp, + T_ATM_CAUSE_UNSPECIFIED_NORMAL); + break; + } + } + break; + + default: + log(LOG_ERR, "ipatm: unknown arp event %d, ivp=0x%x\n", + event, (int)ivp); + } +} + + +/* + * Process an IP VCC idle timer tick + * + * This function is called every IPATM_IDLE_TIME seconds, in order to + * scan for idle IP VCC's. If an active VCC reaches the idle time limit, + * then it will be closed. + * + * Called at splnet. + * + * Arguments: + * tip pointer to the VCC idle timer control block + * + * Returns: + * none + * + */ +void +ipatm_itimeout(tip) + struct atm_time *tip; +{ + struct ipvcc *ivp, *inext; + struct ip_nif *inp; + + + /* + * Schedule next timeout + */ + atm_timeout(&ipatm_itimer, IPATM_IDLE_TIME, ipatm_itimeout); + + /* + * Check for disabled idle timeout + */ + if (ipatm_vcidle == 0) + return; + + /* + * Check out all IP VCCs + */ + for (inp = ipatm_nif_head; inp; inp = inp->inf_next) { + for (ivp = Q_HEAD(inp->inf_vcq, struct ipvcc); ivp; + ivp = inext) { + + inext = Q_NEXT(ivp, struct ipvcc, iv_elem); + + /* + * Looking for active, idle SVCs + */ + if (ivp->iv_flags & (IVF_PVC | IVF_NOIDLE)) + continue; + if (ivp->iv_state != IPVCC_ACTIVE) + continue; + if (++ivp->iv_idle < ipatm_vcidle) + continue; + + /* + * OK, we found one - close the VCC + */ + (void) ipatm_closevc(ivp, + T_ATM_CAUSE_UNSPECIFIED_NORMAL); + } + } +} + diff --git a/sys/netatm/ipatm/ipatm_if.c b/sys/netatm/ipatm/ipatm_if.c new file mode 100644 index 0000000..ede2450 --- /dev/null +++ b/sys/netatm/ipatm/ipatm_if.c @@ -0,0 +1,335 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: ipatm_if.c,v 1.6 1998/03/24 20:51:47 mks Exp $ + * + */ + +/* + * IP Over ATM Support + * ------------------- + * + * Interface Manager + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: ipatm_if.c,v 1.6 1998/03/24 20:51:47 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm.h> +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> + + +/* + * Local functions + */ +static void ipatm_closenif __P((struct ip_nif *)); + + +/* + * Process Network Interface status change + * + * Called whenever a network interface status change is requested. + * + * Called at splnet. + * + * Arguments: + * cmd command code + * nip pointer to atm network interface control block + * arg command specific parameter + * + * Returns: + * 0 command successful + * errno command failed - reason indicated + * + */ +int +ipatm_nifstat(cmd, nip, arg) + int cmd; + struct atm_nif *nip; + int arg; +{ + struct in_ifaddr *ia; + struct siginst *sip; + struct ip_nif *inp; + int err = 0; + + /* + * Look for corresponding IP interface + */ + for (inp = ipatm_nif_head; inp; inp = inp->inf_next) { + if (inp->inf_nif == nip) + break; + } + + /* + * Process command + */ + switch (cmd) { + + case NCM_ATTACH: + /* + * Make sure i/f isn't already attached + */ + if (inp != NULL) { + err = EEXIST; + break; + } + + /* + * Get a new interface block + */ + inp = (struct ip_nif *)atm_allocate(&ipatm_nifpool); + if (inp == NULL) { + err = ENOMEM; + break; + } + inp->inf_nif = nip; + inp->inf_state = IPNIF_ADDR; + inp->inf_arpnotify = ipatm_arpnotify; + inp->inf_ipinput = ipatm_ipinput; + inp->inf_createsvc = ipatm_createsvc; + LINK2TAIL(inp, struct ip_nif, ipatm_nif_head, inf_next); + break; + + case NCM_DETACH: + /* + * Make sure i/f is attached + */ + if (inp == NULL) { + err = ENODEV; + break; + } + + /* + * Validate interface stuff + */ + if (Q_HEAD(inp->inf_vcq, struct ipvcc)) + panic("ipatm_nifstat: ipvcc queue not empty"); + + /* + * If we're active, close all our VCCs and tell the + * interface service about the deactivation + */ + if (inp->inf_state == IPNIF_ACTIVE) { + + ipatm_closenif(inp); + + if (inp->inf_serv) + (void) (*inp->inf_serv->is_ifdact)(inp); + } + + /* + * Clean up and free block + */ + UNLINK(inp, struct ip_nif, ipatm_nif_head, inf_next); + atm_free((caddr_t)inp); + break; + + case NCM_SETADDR: + /* + * We only care about IP addresses + */ +#if (defined(BSD) && (BSD >= 199103)) + if (((struct ifaddr *)arg)->ifa_addr->sa_family != AF_INET) +#else + if (((struct ifaddr *)arg)->ifa_addr.sa_family != AF_INET) +#endif + break; + + /* + * Make sure i/f is there + */ + ia = (struct in_ifaddr *)arg; + if (inp == NULL) + panic("ipatm_nifstat: setaddr missing ip_nif"); + + /* + * Process new address + */ + switch (inp->inf_state) { + + case IPNIF_SIGMGR: + case IPNIF_ADDR: + inp->inf_addr = ia; + + /* + * If signalling manager is not set, wait for it + */ + sip = nip->nif_pif->pif_siginst; + if (sip == NULL) { + inp->inf_state = IPNIF_SIGMGR; + break; + } + + /* + * Otherwise, everything's set + */ + inp->inf_state = IPNIF_ACTIVE; + + /* + * Tell interface service we're around + */ + if (sip->si_ipserv) { + inp->inf_serv = sip->si_ipserv; + err = (*inp->inf_serv->is_ifact)(inp); + } + + /* + * Reset state if there's been a problem + */ + if (err) { + inp->inf_serv = NULL; + inp->inf_addr = NULL; + inp->inf_state = IPNIF_ADDR; + } + break; + + case IPNIF_ACTIVE: + /* + * We dont support an address change + */ + err = EEXIST; + break; + } + break; + + case NCM_SIGATTACH: + /* + * Make sure i/f is attached + */ + if (inp == NULL) { + err = ENODEV; + break; + } + + /* + * Are we waiting for the sigmgr attach?? + */ + if (inp->inf_state != IPNIF_SIGMGR) { + /* + * No, nothing else to do + */ + break; + } + + /* + * OK, everything's set + */ + inp->inf_state = IPNIF_ACTIVE; + + /* + * Tell interface service we're around + */ + sip = nip->nif_pif->pif_siginst; + if (sip->si_ipserv) { + inp->inf_serv = sip->si_ipserv; + err = (*inp->inf_serv->is_ifact)(inp); + } + + /* + * Just report any problems, since a NCM_SIGDETACH will + * be coming down immediately + */ + break; + + case NCM_SIGDETACH: + /* + * Make sure i/f is attached + */ + if (inp == NULL) { + err = ENODEV; + break; + } + + /* + * Are we currently active?? + */ + if (inp->inf_state != IPNIF_ACTIVE) { + /* + * No, nothing else to do + */ + break; + } + + /* + * Close all the IP VCCs for this interface + */ + ipatm_closenif(inp); + + /* + * Tell interface service that i/f has gone down + */ + if (inp->inf_serv) + (void) (*inp->inf_serv->is_ifdact)(inp); + + /* + * Just have to wait for another sigattach + */ + inp->inf_serv = NULL; + inp->inf_state = IPNIF_SIGMGR; + break; + + default: + log(LOG_ERR, "ipatm_nifstat: unknown command %d\n", cmd); + } + + return (err); +} + + +/* + * Close all VCCs on a Network Interface + * + * Called at splnet. + * + * Arguments: + * inp pointer to IP network interface + * + * Returns: + * none + * + */ +static void +ipatm_closenif(inp) + struct ip_nif *inp; +{ + struct ipvcc *ivp, *inext; + + /* + * Close each IP VCC on this interface + */ + for (ivp = Q_HEAD(inp->inf_vcq, struct ipvcc); ivp; ivp = inext) { + + inext = Q_NEXT(ivp, struct ipvcc, iv_elem); + + (void) ipatm_closevc(ivp, T_ATM_CAUSE_UNSPECIFIED_NORMAL); + } +} + diff --git a/sys/netatm/ipatm/ipatm_input.c b/sys/netatm/ipatm/ipatm_input.c new file mode 100644 index 0000000..ca3e3e7 --- /dev/null +++ b/sys/netatm/ipatm/ipatm_input.c @@ -0,0 +1,210 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: ipatm_input.c,v 1.9 1998/04/07 23:03:52 mks Exp $ + * + */ + +/* + * IP Over ATM Support + * ------------------- + * + * Process stack and data input + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: ipatm_input.c,v 1.9 1998/04/07 23:03:52 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm.h> +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> + + +/* + * Process VCC Input Data + * + * Arguments: + * tok ipatm connection token (pointer to ipvcc) + * m pointer to input packet buffer chain + * + * Returns: + * none + * + */ +void +ipatm_cpcs_data(tok, m) + void *tok; + KBuffer *m; +{ + struct ipvcc *ivp = tok; + +#ifdef DIAGNOSTIC + if (ipatm_print) { + atm_pdu_print(m, "ipatm_input"); + } +#endif + + /* + * Handle input packet + */ + if (ivp->iv_state != IPVCC_ACTIVE) { + KB_FREEALL(m); + ipatm_stat.ias_rcvstate++; + return; + } + + /* + * IP packet - reset idle timer + */ + ivp->iv_idle = 0; + + /* + * Pass packet to IP + */ + (void) ipatm_ipinput(ivp->iv_ipnif, m); +} + + +/* + * IP Input Packet Handler + * + * All IP packets received from various ATM sources will be sent here + * for final queuing to the IP layer. + * + * Arguments: + * inp pointer to packet's receiving IP network interface + * m pointer to packet buffer chain + * + * Returns: + * 0 packet successfully queued to IP layer + * else error queuing packet, buffer chain freed + * + */ +int +ipatm_ipinput(inp, m) + struct ip_nif *inp; + KBuffer *m; +{ + int s, space; + +#ifdef DIAGNOSTIC + if (ipatm_print) { + atm_pdu_print(m, "ipatm_ipinput"); + } +#endif + +#if defined(BSD) +#if BSD >= 199103 + +#ifdef DIAGNOSTIC + if (!KB_ISPKT(m)) { + panic("ipatm_ipinput: no packet header"); + } + { + int cnt = 0; + KBuffer *m0 = m; + + while (m0) { + cnt += KB_LEN(m0); + m0 = KB_NEXT(m0); + } + if (m->m_pkthdr.len != cnt) { + panic("ipatm_ipinput: packet length incorrect"); + } + } +#endif + /* + * Save the input ifnet pointer in the packet header + */ + m->m_pkthdr.rcvif = (struct ifnet *)inp->inf_nif; + +#else /* ! BSD >= 199103 */ + /* + * Stick ifnet pointer onto front of packet - hopefully + * there'll be room in the first buffer. + */ + KB_HEADROOM(m, space); + if (space < sizeof(struct ifnet *)) { + KBuffer *n; + + /* + * We have to allocate another buffer and tack it + * onto the front of the packet + */ + KB_ALLOCPKT(n, sizeof(struct ifnet *), + KB_F_NOWAIT, KB_T_HEADER); + if (n == 0) { + KB_FREEALL(m); + ipatm_stat.ias_rcvnobuf++; + return (1); + } + KB_LEN(n) = sizeof(struct ifnet *); + KB_LINKHEAD(n, m); + m = n; + } else { + /* + * Header fits, just adjust buffer controls + */ + KB_HEADADJ(m, sizeof(struct ifnet *)); + } + { + struct ifnet **p; + + KB_DATASTART(m, p, struct ifnet **); + *p = (struct ifnet *)inp->inf_nif; + } +#endif /* ! BSD >= 199103 */ + + /* + * Finally, hand packet off to IP. + * + * NB: Since we're already in the softint kernel state, we + * just call IP directly to avoid the extra unnecessary + * kernel scheduling. + */ + s = splimp(); + if (IF_QFULL(&ipintrq)) { + IF_DROP(&ipintrq); + (void) splx(s); + KB_FREEALL(m); + return (1); + } + + IF_ENQUEUE(&ipintrq, m); + (void) splx(s); +#if BSD < 199506 + ipintr(); +#else + schednetisr ( NETISR_IP ); +#endif /* BSD >= 199506 */ +#endif /* defined(BSD) */ + + return (0); +} + diff --git a/sys/netatm/ipatm/ipatm_load.c b/sys/netatm/ipatm/ipatm_load.c new file mode 100644 index 0000000..8caa635 --- /dev/null +++ b/sys/netatm/ipatm/ipatm_load.c @@ -0,0 +1,878 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: ipatm_load.c,v 1.12 1998/07/30 22:23:00 mks Exp $ + * + */ + +/* + * IP Over ATM Support + * ------------------- + * + * Support for running as a loadable kernel module + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: ipatm_load.c,v 1.12 1998/07/30 22:23:00 mks Exp $"; +#endif + +#ifndef ATM_IP_MODULE +#include "opt_atm.h" +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm.h> +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> + + +/* + * Global variables + */ +int ipatm_vccnt = 0; +int ipatm_vcidle = IPATM_VCIDLE; +int ipatm_print = 0; +u_long last_map_ipdst = 0; +struct ipvcc* last_map_ipvcc = NULL; + +struct ip_nif *ipatm_nif_head = NULL; + +struct ipatm_stat ipatm_stat = {0}; + +struct atm_time ipatm_itimer = {0, 0}; /* VCC idle timer */ + +Atm_endpoint ipatm_endpt = { + NULL, + ENDPT_IP, + ipatm_ioctl, + ipatm_getname, + ipatm_connected, + ipatm_cleared, + ipatm_incoming, + NULL, + NULL, + NULL, + ipatm_cpcs_data, + NULL, + NULL, + NULL, + NULL +}; + +struct sp_info ipatm_vcpool = { + "ipatm vcc pool", /* si_name */ + sizeof(struct ipvcc), /* si_blksiz */ + 10, /* si_blkcnt */ + 100 /* si_maxallow */ +}; + +struct sp_info ipatm_nifpool = { + "ipatm nif pool", /* si_name */ + sizeof(struct ip_nif), /* si_blksiz */ + 5, /* si_blkcnt */ + 20 /* si_maxallow */ +}; + + +/* + * Local functions + */ +static int ipatm_start __P((void)); +static int ipatm_stop __P((void)); + + +/* + * Local variables + */ +static struct atm_ncm ipatm_ncm = { + NULL, + AF_INET, + ipatm_ifoutput, + ipatm_nifstat +}; + +static struct ipatm_listener { + Atm_attributes attr; + Atm_connection *conn; +} ipatm_listeners[] = { +{ + { NULL, /* nif */ + CMAPI_CPCS, /* api */ + 0, /* api_init */ + 0, /* headin */ + 0, /* headout */ + { /* aal */ + T_ATM_PRESENT, + ATM_AAL5 + }, + { /* traffic */ + T_ATM_PRESENT, + { + { + T_ATM_ABSENT, + 0, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_NO + }, + { + T_ATM_ABSENT, + 0, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_NO + }, + T_YES + }, + }, + { /* bearer */ + T_ATM_ANY + }, + { /* bhli */ + T_ATM_ABSENT + }, + { /* blli */ + T_ATM_PRESENT, + T_ATM_ABSENT, + { + { + T_ATM_SIMPLE_ID, + }, + { + T_ATM_ABSENT + } + } + }, + { /* llc */ + T_ATM_PRESENT, + { + T_ATM_LLC_SHARING, + IPATM_LLC_LEN, + IPATM_LLC_HDR + } + }, + { /* called */ + T_ATM_ANY + }, + { /* calling */ + T_ATM_ANY + }, + { /* qos */ + T_ATM_PRESENT, + { + T_ATM_NETWORK_CODING, + { + T_ATM_QOS_CLASS_0, + }, + { + T_ATM_QOS_CLASS_0 + } + } + }, + { /* transit */ + T_ATM_ANY + }, + { /* cause */ + T_ATM_ABSENT + }, + }, + NULL +}, +{ + { NULL, /* nif */ + CMAPI_CPCS, /* api */ + 0, /* api_init */ + 0, /* headin */ + 0, /* headout */ + { /* aal */ + T_ATM_PRESENT, + ATM_AAL5 + }, + { /* traffic */ + T_ATM_PRESENT, + { + { + T_ATM_ABSENT, + 0, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_NO + }, + { + T_ATM_ABSENT, + 0, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_NO + }, + T_YES + }, + }, + { /* bearer */ + T_ATM_ANY + }, + { /* bhli */ + T_ATM_ABSENT + }, + { /* blli */ + T_ATM_ABSENT, + T_ATM_ABSENT + }, + { /* llc */ + T_ATM_ABSENT + }, + { /* called */ + T_ATM_ANY + }, + { /* calling */ + T_ATM_ANY + }, + { /* qos */ + T_ATM_PRESENT, + { + T_ATM_NETWORK_CODING, + { + T_ATM_QOS_CLASS_0, + }, + { + T_ATM_QOS_CLASS_0 + } + } + }, + { /* transit */ + T_ATM_ANY + }, + { /* cause */ + T_ATM_ABSENT + }, + }, + NULL +}, +{ + { NULL, /* nif */ + CMAPI_CPCS, /* api */ + 0, /* api_init */ + 0, /* headin */ + 0, /* headout */ + { /* aal */ + T_ATM_PRESENT, + ATM_AAL3_4 + }, + { /* traffic */ + T_ATM_PRESENT, + { + { + T_ATM_ABSENT, + 0, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_NO + }, + { + T_ATM_ABSENT, + 0, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_NO + }, + T_YES + }, + }, + { /* bearer */ + T_ATM_ANY + }, + { /* bhli */ + T_ATM_ABSENT + }, + { /* blli */ + T_ATM_ABSENT, + T_ATM_ABSENT + }, + { /* llc */ + T_ATM_ABSENT + }, + { /* called */ + T_ATM_ANY + }, + { /* calling */ + T_ATM_ANY + }, + { /* qos */ + T_ATM_PRESENT, + { + T_ATM_NETWORK_CODING, + { + T_ATM_QOS_CLASS_0, + }, + { + T_ATM_QOS_CLASS_0 + } + } + }, + { /* transit */ + T_ATM_ANY + }, + { /* cause */ + T_ATM_ABSENT + }, + }, + NULL +}, +}; + +static struct t_atm_cause ipatm_cause = { + T_ATM_ITU_CODING, + T_ATM_LOC_USER, + T_ATM_CAUSE_UNSPECIFIED_NORMAL, + {0, 0, 0, 0} +}; + + +/* + * Initialize ipatm processing + * + * This will be called during module loading. We'll just register + * ourselves and wait for the packets to start flying. + * + * Arguments: + * none + * + * Returns: + * 0 startup was successful + * errno startup failed - reason indicated + * + */ +static int +ipatm_start() +{ + struct atm_pif *pip; + struct atm_nif *nip; + int err, s, i; + + /* + * Verify software version + */ + if (atm_version != ATM_VERSION) { + log(LOG_ERR, "version mismatch: ipatm=%d.%d kernel=%d.%d\n", + ATM_VERS_MAJ(ATM_VERSION), ATM_VERS_MIN(ATM_VERSION), + ATM_VERS_MAJ(atm_version), ATM_VERS_MIN(atm_version)); + return (EINVAL); + } + + /* + * Register ourselves as a network convergence module + */ + err = atm_netconv_register(&ipatm_ncm); + if (err) + goto done; + + /* + * Register ourselves as an ATM endpoint + */ + err = atm_endpoint_register(&ipatm_endpt); + if (err) + goto done; + + /* + * Get current system configuration + */ + s = splnet(); + for (pip = atm_interface_head; pip; pip = pip->pif_next) { + /* + * Process each network interface + */ + for (nip = pip->pif_nif; nip; nip = nip->nif_pnext) { + struct ifnet *ifp = (struct ifnet *)nip; + struct in_ifaddr *ia; + + /* + * Attach interface + */ + err = ipatm_nifstat(NCM_ATTACH, nip, 0); + if (err) { + (void) splx(s); + goto done; + } + + /* + * If IP address has been set, register it + */ + TAILQ_FOREACH(ia, &in_ifaddrhead, ia_link) { + if (ia->ia_ifp == ifp) + break; + } + if (ia) { + err = ipatm_nifstat(NCM_SETADDR, nip, (int)ia); + if (err) { + (void) splx(s); + goto done; + } + } + } + } + (void) splx(s); + + /* + * Fill in union fields + */ + ipatm_aal5llc.aal.v.aal5.forward_max_SDU_size = + ATM_NIF_MTU + IPATM_LLC_LEN; + ipatm_aal5llc.aal.v.aal5.backward_max_SDU_size = + ATM_NIF_MTU + IPATM_LLC_LEN; + ipatm_aal5llc.aal.v.aal5.SSCS_type = T_ATM_NULL; + ipatm_aal5llc.blli.v.layer_2_protocol.ID.simple_ID = T_ATM_BLLI2_I8802; + + ipatm_aal5null.aal.v.aal5.forward_max_SDU_size = ATM_NIF_MTU; + ipatm_aal5null.aal.v.aal5.backward_max_SDU_size = ATM_NIF_MTU; + ipatm_aal5null.aal.v.aal5.SSCS_type = T_ATM_NULL; + + ipatm_aal4null.aal.v.aal4.forward_max_SDU_size = ATM_NIF_MTU; + ipatm_aal4null.aal.v.aal4.backward_max_SDU_size = ATM_NIF_MTU; + ipatm_aal4null.aal.v.aal4.SSCS_type = T_ATM_NULL; + ipatm_aal4null.aal.v.aal4.mid_low = 0; + ipatm_aal4null.aal.v.aal4.mid_high = 1023; + + /* + * Listen for incoming calls + */ + for (i = 0; + i < (sizeof(ipatm_listeners) / sizeof(struct ipatm_listener)); + i++) { + struct attr_aal *aalp = &ipatm_listeners[i].attr.aal; + int maxsdu = ATM_NIF_MTU; + + /* + * Fill in union fields + */ + if (ipatm_listeners[i].attr.blli.tag_l2 == T_ATM_PRESENT) { + struct t_atm_blli *bp = &ipatm_listeners[i].attr.blli.v; + + bp->layer_2_protocol.ID.simple_ID = T_ATM_BLLI2_I8802; + maxsdu += IPATM_LLC_LEN; + } + if (aalp->type == ATM_AAL5) { + aalp->v.aal5.forward_max_SDU_size = maxsdu; + aalp->v.aal5.backward_max_SDU_size = maxsdu; + aalp->v.aal5.SSCS_type = T_ATM_NULL; + } else { + aalp->v.aal4.forward_max_SDU_size = maxsdu; + aalp->v.aal4.backward_max_SDU_size = maxsdu; + aalp->v.aal4.SSCS_type = T_ATM_NULL; + aalp->v.aal4.mid_low = 0; + aalp->v.aal4.mid_high = 1023; + } + + /* + * Now start listening + */ + if (err = atm_cm_listen(&ipatm_endpt, (void *)i, + &ipatm_listeners[i].attr, + &ipatm_listeners[i].conn)) + goto done; + } + + /* + * Start background VCC idle timer + */ + atm_timeout(&ipatm_itimer, IPATM_IDLE_TIME, ipatm_itimeout); + +done: + return (err); +} + + +/* + * Halt ipatm processing + * + * This will be called just prior to unloading the module from + * memory. All IP VCCs must be terminated before the protocol can + * be shutdown. + * + * Arguments: + * none + * + * Returns: + * 0 shutdown was successful + * errno shutdown failed - reason indicated + * + */ +static int +ipatm_stop() +{ + struct ip_nif *inp; + int err = 0, i; + int s = splnet(); + + /* + * Any VCCs still open?? + */ + if (ipatm_vccnt) { + + /* Yes, can't stop now */ + err = EBUSY; + goto done; + } + + /* + * Kill VCC idle timer + */ + (void) atm_untimeout(&ipatm_itimer); + + /* + * Stop listening for incoming calls + */ + for (i = 0; + i < (sizeof(ipatm_listeners) / sizeof(struct ipatm_listener)); + i++) { + if (ipatm_listeners[i].conn != NULL) { + (void) atm_cm_release(ipatm_listeners[i].conn, + &ipatm_cause); + } + } + + /* + * Detach all our interfaces + */ + while (inp = ipatm_nif_head) { + (void) ipatm_nifstat(NCM_DETACH, inp->inf_nif, 0); + } + + /* + * De-register from system + */ + (void) atm_netconv_deregister(&ipatm_ncm); + (void) atm_endpoint_deregister(&ipatm_endpt); + + /* + * Free up our storage pools + */ + atm_release_pool(&ipatm_vcpool); + atm_release_pool(&ipatm_nifpool); + +done: + (void) splx(s); + return (err); +} + + +#ifdef ATM_IP_MODULE +/* + ******************************************************************* + * + * Loadable Module Support + * + ******************************************************************* + */ +static int ipatm_doload __P((void)); +static int ipatm_dounload __P((void)); + +/* + * Generic module load processing + * + * This function is called by an OS-specific function when this + * module is being loaded. + * + * Arguments: + * none + * + * Returns: + * 0 load was successful + * errno load failed - reason indicated + * + */ +static int +ipatm_doload() +{ + int err = 0; + + /* + * Start us up + */ + err = ipatm_start(); + if (err) + /* Problems, clean up */ + (void)ipatm_stop(); + + return (err); +} + + +/* + * Generic module unload processing + * + * This function is called by an OS-specific function when this + * module is being unloaded. + * + * Arguments: + * none + * + * Returns: + * 0 unload was successful + * errno unload failed - reason indicated + * + */ +static int +ipatm_dounload() +{ + int err = 0; + + /* + * OK, try to clean up our mess + */ + err = ipatm_stop(); + + return (err); +} + + +#ifdef sun +/* + * Loadable driver description + */ +struct vdldrv ipatm_drv = { + VDMAGIC_PSEUDO, /* Pseudo Driver */ + "ipatm_mod", /* name */ + NULL, /* dev_ops */ + NULL, /* bdevsw */ + NULL, /* cdevsw */ + 0, /* blockmajor */ + 0 /* charmajor */ +}; + + +/* + * Loadable module support entry point + * + * This is the routine called by the vd driver for all loadable module + * functions for this pseudo driver. This routine name must be specified + * on the modload(1) command. This routine will be called whenever the + * modload(1), modunload(1) or modstat(1) commands are issued for this + * module. + * + * Arguments: + * cmd vd command code + * vdp pointer to vd driver's structure + * vdi pointer to command-specific vdioctl_* structure + * vds pointer to status structure (VDSTAT only) + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +int +ipatm_mod(cmd, vdp, vdi, vds) + int cmd; + struct vddrv *vdp; + caddr_t vdi; + struct vdstat *vds; +{ + int err = 0; + + switch (cmd) { + + case VDLOAD: + /* + * Module Load + * + * We dont support any user configuration + */ + err = ipatm_doload(); + if (err == 0) + /* Let vd driver know about us */ + vdp->vdd_vdtab = (struct vdlinkage *)&ipatm_drv; + break; + + case VDUNLOAD: + /* + * Module Unload + */ + err = ipatm_dounload(); + break; + + case VDSTAT: + /* + * Module Status + */ + + /* Not much to say at the moment */ + + break; + + default: + log(LOG_ERR, "ipatm_mod: Unknown vd command 0x%x\n", cmd); + err = EINVAL; + } + + return (err); +} +#endif /* sun */ + +#ifdef __FreeBSD__ + +#include <sys/exec.h> +#include <sys/sysent.h> +#include <sys/lkm.h> + +/* + * Loadable miscellaneous module description + */ +MOD_MISC(ipatm); + + +/* + * Loadable module support "load" entry point + * + * This is the routine called by the lkm driver whenever the + * modload(1) command is issued for this module. + * + * Arguments: + * lkmtp pointer to lkm drivers's structure + * cmd lkm command code + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +static int +ipatm_load(lkmtp, cmd) + struct lkm_table *lkmtp; + int cmd; +{ + return(ipatm_doload()); +} + + +/* + * Loadable module support "unload" entry point + * + * This is the routine called by the lkm driver whenever the + * modunload(1) command is issued for this module. + * + * Arguments: + * lkmtp pointer to lkm drivers's structure + * cmd lkm command code + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +static int +ipatm_unload(lkmtp, cmd) + struct lkm_table *lkmtp; + int cmd; +{ + return(ipatm_dounload()); +} + + +/* + * Loadable module support entry point + * + * This is the routine called by the lkm driver for all loadable module + * functions for this driver. This routine name must be specified + * on the modload(1) command. This routine will be called whenever the + * modload(1), modunload(1) or modstat(1) commands are issued for this + * module. + * + * Arguments: + * lkmtp pointer to lkm drivers's structure + * cmd lkm command code + * ver lkm version + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +int +ipatm_mod(lkmtp, cmd, ver) + struct lkm_table *lkmtp; + int cmd; + int ver; +{ + MOD_DISPATCH(ipatm, lkmtp, cmd, ver, + ipatm_load, ipatm_unload, lkm_nullcmd); +} +#endif /* __FreeBSD__ */ + +#else /* !ATM_IP_MODULE */ + +/* + ******************************************************************* + * + * Kernel Compiled Module Support + * + ******************************************************************* + */ +static void ipatm_doload __P((void *)); + +SYSINIT(atmipatm, SI_SUB_PROTO_END, SI_ORDER_ANY, ipatm_doload, NULL) + +/* + * Kernel initialization + * + * Arguments: + * arg Not used + * + * Returns: + * none + * + */ +static void +ipatm_doload(void *arg) +{ + int err = 0; + + /* + * Start us up + */ + err = ipatm_start(); + if (err) { + /* Problems, clean up */ + (void)ipatm_stop(); + + log(LOG_ERR, "IP over ATM unable to initialize (%d)!!\n", err); + } + return; +} +#endif /* ATM_IP_MODULE */ + diff --git a/sys/netatm/ipatm/ipatm_output.c b/sys/netatm/ipatm/ipatm_output.c new file mode 100644 index 0000000..7f02f28 --- /dev/null +++ b/sys/netatm/ipatm/ipatm_output.c @@ -0,0 +1,216 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: ipatm_output.c,v 1.6 1998/02/19 20:14:17 mks Exp $ + * + */ + +/* + * IP Over ATM Support + * ------------------- + * + * Output IP packets across an ATM VCC + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: ipatm_output.c,v 1.6 1998/02/19 20:14:17 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm.h> +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> + + +/* + * Output an IP Packet + * + * All IP packets output to an ATM interface will be directed here via + * the atm_ifoutput() function. If there is an ATM VCC already setup for + * the destination IP address, then we'll just send the packet to that VCC. + * Otherwise we will have to setup a new VCC, ARPing for the corresponding + * destination ATM hardware address along the way. + * + * Arguments: + * ifp pointer to ifnet structure + * m pointer to packet buffer chain to be output + * dst pointer to packet's IP destination address + * + * Returns: + * 0 packet "output" was successful + * errno output failed - reason indicated + * + */ +int +ipatm_ifoutput(ifp, m, dst) + struct ifnet *ifp; + KBuffer *m; + struct sockaddr *dst; +{ + struct ipvcc *ivp; + int err = 0; + +#ifdef DIAGNOSTIC + if (ipatm_print) { + atm_pdu_print(m, "ipatm_ifoutput"); + } +#endif + + /* + * See if we've already got an appropriate VCC + */ + ivp = ipatm_iptovc((struct sockaddr_in *)dst, (struct atm_nif *)ifp); + if (ivp) { + + /* + * Reset idle timer + */ + ivp->iv_idle = 0; + + /* + * Can we use this VCC now?? + */ + if ((ivp->iv_state == IPVCC_ACTIVE) && + (ivp->iv_flags & IVF_MAPOK)) { + + /* + * OK, now send packet + */ + err = atm_cm_cpcs_data(ivp->iv_conn, m); + if (err) { + /* + * Output problem, drop packet + */ + KB_FREEALL(m); + } + } else { + + /* + * VCC is unavailable for data packets. Queue packet + * for now, but only maintain a queue length of one. + */ + if (ivp->iv_queue) + KB_FREEALL(ivp->iv_queue); + + ivp->iv_queue = m; + } + } else { + struct in_ifaddr *ia; +#if (defined(BSD) && (BSD < 199306)) + extern struct ifnet loif; +#endif + + /* + * No VCC to destination + */ + + /* + * Is packet for our interface address? + */ + TAILQ_FOREACH(ia, &in_ifaddrhead, ia_link) { + if (ia->ia_ifp != ifp) + continue; + if (((struct sockaddr_in *)dst)->sin_addr.s_addr == + IA_SIN(ia)->sin_addr.s_addr) { + + /* + * It's for us - hand packet to loopback driver + */ + (void) if_simloop(ifp, m, dst, 0); + goto done; + } + } + + /* + * Is this a broadcast packet ?? + */ +#if (defined(BSD) && (BSD >= 199306)) + if (in_broadcast(((struct sockaddr_in *)dst)->sin_addr, ifp)) { +#else + if (in_broadcast(((struct sockaddr_in *)dst)->sin_addr)) { +#endif + struct ip_nif *inp; + int s; + + /* + * If interface server exists and provides broadcast + * services, then let it deal with this packet + */ + s = splnet(); + for (inp = ipatm_nif_head; inp; inp = inp->inf_next) { + if (inp->inf_nif == (struct atm_nif *)ifp) + break; + } + (void) splx(s); + + if ((inp == NULL) || + (inp->inf_serv == NULL) || + (inp->inf_serv->is_bcast_output == NULL)) { + KB_FREEALL(m); + err = EADDRNOTAVAIL; + goto done; + } + + err = (*inp->inf_serv->is_bcast_output)(inp, m); + goto done; + } + + /* + * How about a multicast packet ?? + */ + if (IN_MULTICAST(ntohl(SATOSIN(dst)->sin_addr.s_addr))) { + /* + * Multicast isn't currently supported + */ + KB_FREEALL(m); + err = EADDRNOTAVAIL; + goto done; + } + + /* + * Well, I guess we need to create an SVC to the destination + */ + if ((err = ipatm_createsvc(ifp, AF_INET, + (caddr_t)&((struct sockaddr_in *)dst)->sin_addr, + &ivp)) == 0) { + /* + * SVC open is proceeding, queue packet + */ + ivp->iv_queue = m; + + } else { + /* + * SVC open failed, release buffers and return + */ + KB_FREEALL(m); + } + } + +done: + return (err); +} + diff --git a/sys/netatm/ipatm/ipatm_serv.h b/sys/netatm/ipatm/ipatm_serv.h new file mode 100644 index 0000000..2046213 --- /dev/null +++ b/sys/netatm/ipatm/ipatm_serv.h @@ -0,0 +1,114 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: ipatm_serv.h,v 1.6 1998/02/19 20:14:21 mks Exp $ + * + */ + +/* + * IP Over ATM Support + * ------------------- + * + * IP/ATM service interface definitions + * + */ + +#ifndef _IPATM_IPATM_SERV_H +#define _IPATM_IPATM_SERV_H + + +/* + * Structures specifying VCC parameters and pointers to all of the IP + * services offered by an external IP interface service provider. + */ +struct ip_vccparm { + Aal_t ivc_aal; /* AAL type */ + Encaps_t ivc_encaps; /* VCC encapsulation */ +}; + +#define IPATM_VCCPARMS 4 /* Number of parameter lists */ + +struct ip_serv { +/* Interfaces to IP/ATM interface services */ + int (*is_ifact) /* Interface activation */ + __P((struct ip_nif *)); + int (*is_ifdact) /* Interface deactivation */ + __P((struct ip_nif *)); + int (*is_ioctl) /* Interface ioctl */ + __P((int, caddr_t, caddr_t)); + +/* Interfaces to IP/ATM ARP services */ + int (*is_arp_pvcopen) /* IP creating dynamic PVC */ + __P((struct ipvcc *)); + int (*is_arp_svcout) /* IP creating outgoing SVC */ + __P((struct ipvcc *, struct in_addr *)); + int (*is_arp_svcin) /* IP creating incoming SVC */ + __P((struct ipvcc *, Atm_addr *, Atm_addr *)); + int (*is_arp_svcact) /* IP SVC is active */ + __P((struct ipvcc *)); + void (*is_arp_close) /* IP closing VCC */ + __P((struct ipvcc *)); + +/* Interfaces to IP/ATM broadcast services */ + int (*is_bcast_output) /* IP broadcast packet output */ + __P((struct ip_nif *, KBuffer *)); + +/* Interfaces to IP/ATM multicast services */ + +/* Ordered list of parameters to try for IP/ATM VCC connections */ + struct ip_vccparm is_vccparm[IPATM_VCCPARMS]; /* List of vcc params */ +}; + + +/* + * ARP Interface + * ---------------- + */ + +/* + * Common header for IP/ATM ARP mappings. For each IP VCC created, the + * appropriate IP/ATM ARP server must assign one of these structures to + * indicate the address mapping. This is the only IP-visible ARP structure. + * The servers may embed this structure at the beginning of their + * module-specific mappings. + */ +struct arpmap { + struct in_addr am_dstip; /* Destination IP address */ + Atm_addr am_dstatm; /* Destination ATM address */ + Atm_addr am_dstatmsub; /* Destination ATM subaddress */ +}; + + +/* + * is_arp_[ps]open() return codes and ipatm_arpnotify() event types + */ +#define MAP_PROCEEDING 1 /* Lookup is proceeding (open only) */ +#define MAP_VALID 2 /* Mapping is valid */ +#define MAP_INVALID 3 /* Mapping is invalid */ +#define MAP_CHANGED 4 /* Mapping has changed */ +#define MAP_FAILED 5 /* Mapping request has failed */ + + +#endif /* _IPATM_IPATM_SERV_H */ diff --git a/sys/netatm/ipatm/ipatm_usrreq.c b/sys/netatm/ipatm/ipatm_usrreq.c new file mode 100644 index 0000000..1f1751c --- /dev/null +++ b/sys/netatm/ipatm/ipatm_usrreq.c @@ -0,0 +1,394 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: ipatm_usrreq.c,v 1.6 1998/05/18 19:14:04 mks Exp $ + * + */ + +/* + * IP Over ATM Support + * ------------------- + * + * Process user requests + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: ipatm_usrreq.c,v 1.6 1998/05/18 19:14:04 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm.h> +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> + + +/* + * Process IP PF_ATM ioctls + * + * Called at splnet. + * + * Arguments: + * code PF_ATM sub-operation code + * data pointer to code specific parameter data area + * arg1 pointer to code specific argument + * + * Returns: + * 0 request procesed + * errno error processing request - reason indicated + * + */ +int +ipatm_ioctl(code, data, arg1) + int code; + caddr_t data; + caddr_t arg1; +{ + struct atmaddreq *aap; + struct atmdelreq *adp; + struct atminfreq *aip; + struct air_ip_vcc_rsp aivr; + struct atm_nif *nip; + struct ip_nif *inp; + struct ipvcc *ivp; + struct vccb *vcp; + struct ipatmpvc pv; + caddr_t cp; + struct in_addr ip; + int space, err = 0; + + + switch (code) { + + case AIOCS_ADD_PVC: + /* + * Add an IP PVC + */ + aap = (struct atmaddreq *)data; + + /* + * Find the IP network interface + */ + if ((nip = atm_nifname(aap->aar_pvc_intf)) == NULL) { + err = ENXIO; + break; + } + + for (inp = ipatm_nif_head; inp; inp = inp->inf_next) { + if (inp->inf_nif == nip) + break; + } + if (inp == NULL) { + err = ENXIO; + break; + } + + /* + * Validate PVC params + */ + if (aap->aar_pvc_aal == ATM_AAL5) { + if ((aap->aar_pvc_encaps != ATM_ENC_LLC) && + (aap->aar_pvc_encaps != ATM_ENC_NULL)) { + err = EINVAL; + break; + } + } else if (aap->aar_pvc_aal == ATM_AAL3_4) { + if (aap->aar_pvc_encaps != ATM_ENC_NULL) { + err = EINVAL; + break; + } + } else { + err = EINVAL; + break; + } + + if (aap->aar_pvc_flags & PVC_DYN) { + /* + * For dynamic PVC destination addressing, the + * network interface must have support for this + */ + if ((inp->inf_serv == NULL) || + (inp->inf_serv->is_arp_pvcopen == NULL)) { + err = EDESTADDRREQ; + break; + } + } else { + u_long dst = ((struct sockaddr_in *)&aap->aar_pvc_dst) + ->sin_addr.s_addr; + + if (dst == INADDR_ANY) { + err = EINVAL; + break; + } + } + + /* + * Build connection request + */ + pv.ipp_ipnif = inp; + pv.ipp_vpi = aap->aar_pvc_vpi; + pv.ipp_vci = aap->aar_pvc_vci; + pv.ipp_encaps = aap->aar_pvc_encaps; + pv.ipp_aal = aap->aar_pvc_aal; + if (aap->aar_pvc_flags & PVC_DYN) { + pv.ipp_dst.sin_addr.s_addr = INADDR_ANY; + } else + pv.ipp_dst = *(struct sockaddr_in *)&aap->aar_pvc_dst; + + /* + * Open a new VCC + */ + err = ipatm_openpvc(&pv, &ivp); + break; + + case AIOCS_ADD_ARP: + /* + * Add an ARP mapping + */ + aap = (struct atmaddreq *)data; + + /* + * Validate IP address + */ + if (aap->aar_arp_dst.sa_family != AF_INET) { + err = EAFNOSUPPORT; + break; + } + ip = SATOSIN(&aap->aar_arp_dst)->sin_addr; + + if (aap->aar_arp_intf[0] == '\0') { + /* + * Find the IP network interface associated with + * the supplied IP address + */ + for (inp = ipatm_nif_head; inp; inp = inp->inf_next) { + if (ipatm_chknif(ip, inp) == 0) + break; + } + if (inp == NULL) { + err = EADDRNOTAVAIL; + break; + } + } else { + /* + * Find the specified IP network interface + */ + if ((nip = atm_nifname(aap->aar_arp_intf)) == NULL) { + err = ENXIO; + break; + } + for (inp = ipatm_nif_head; inp; inp = inp->inf_next) { + if (inp->inf_nif == nip) + break; + } + if (inp == NULL) { + err = ENXIO; + break; + } + } + + if ((ip.s_addr == INADDR_ANY) || +#if (defined(BSD) && (BSD >= 199306)) + in_broadcast(ip, &inp->inf_nif->nif_if) || +#else + in_broadcast(ip) || +#endif + IN_MULTICAST(ntohl(ip.s_addr))) { + err = EADDRNOTAVAIL; + break; + } + + /* + * Notify the responsible ARP service + */ + err = (*inp->inf_serv->is_ioctl)(code, data, inp->inf_isintf); + break; + + case AIOCS_DEL_ARP: + /* + * Delete an ARP mapping + */ + adp = (struct atmdelreq *)data; + + /* + * Validate IP address + */ + if (adp->adr_arp_dst.sa_family != AF_INET) { + err = EAFNOSUPPORT; + break; + } + ip = SATOSIN(&adp->adr_arp_dst)->sin_addr; + + if (adp->adr_arp_intf[0] == '\0') { + /* + * Find the IP network interface associated with + * the supplied IP address + */ + for (inp = ipatm_nif_head; inp; inp = inp->inf_next) { + if (ipatm_chknif(ip, inp) == 0) + break; + } + if (inp == NULL) { + err = EADDRNOTAVAIL; + break; + } + } else { + /* + * Find the specified IP network interface + */ + if ((nip = atm_nifname(adp->adr_arp_intf)) == NULL) { + err = ENXIO; + break; + } + for (inp = ipatm_nif_head; inp; inp = inp->inf_next) { + if (inp->inf_nif == nip) + break; + } + if (inp == NULL) { + err = ENXIO; + break; + } + } + + if ((ip.s_addr == INADDR_ANY) || +#if (defined(BSD) && (BSD >= 199306)) + in_broadcast(ip, &inp->inf_nif->nif_if) || +#else + in_broadcast(ip) || +#endif + IN_MULTICAST(ntohl(ip.s_addr))) { + err = EADDRNOTAVAIL; + break; + } + + /* + * Notify the responsible ARP service + */ + err = (*inp->inf_serv->is_ioctl)(code, data, inp->inf_isintf); + break; + + case AIOCS_INF_IPM: + /* + * Get IP VCC information + */ + aip = (struct atminfreq *)data; + + if (aip->air_ip_addr.sa_family != AF_INET) + break; + ip = SATOSIN(&aip->air_ip_addr)->sin_addr; + + cp = aip->air_buf_addr; + space = aip->air_buf_len; + + /* + * Loop through all our interfaces + */ + for (inp = ipatm_nif_head; inp; inp = inp->inf_next) { + /* + * Check out each VCC + */ + for (ivp = Q_HEAD(inp->inf_vcq, struct ipvcc); ivp; + ivp = Q_NEXT(ivp, struct ipvcc, iv_elem)) { + + if ((ip.s_addr != INADDR_ANY) && + (ip.s_addr != ivp->iv_dst.s_addr)) + continue; + + /* + * Make sure there's room in user buffer + */ + if (space < sizeof(aivr)) { + err = ENOSPC; + break; + } + + /* + * Fill in info to be returned + */ + KM_ZERO((caddr_t)&aivr, sizeof(aivr)); + SATOSIN(&aivr.aip_dst_addr)->sin_family = + AF_INET; + SATOSIN(&aivr.aip_dst_addr)->sin_addr.s_addr = + ivp->iv_dst.s_addr; + (void) sprintf(aivr.aip_intf, "%s%d", + inp->inf_nif->nif_if.if_name, + inp->inf_nif->nif_if.if_unit); + if ((ivp->iv_conn) && + (ivp->iv_conn->co_connvc) && + (vcp = ivp->iv_conn->co_connvc->cvc_vcc)) { + aivr.aip_vpi = vcp->vc_vpi; + aivr.aip_vci = vcp->vc_vci; + aivr.aip_sig_proto = vcp->vc_proto; + } + aivr.aip_flags = ivp->iv_flags; + aivr.aip_state = ivp->iv_state; + + /* + * Copy data to user buffer and + * update buffer controls + */ + err = copyout((caddr_t)&aivr, cp, sizeof(aivr)); + if (err) + break; + cp += sizeof(aivr); + space -= sizeof(aivr); + } + if (err) + break; + } + + /* + * Update buffer pointer/count + */ + aip->air_buf_addr = cp; + aip->air_buf_len = space; + break; + + default: + err = EOPNOTSUPP; + } + + return (err); +} + + +/* + * Get Connection's Application/Owner Name + * + * Arguments: + * tok ipatm connection token (pointer to ipvcc) + * + * Returns: + * addr pointer to string containing our name + * + */ +caddr_t +ipatm_getname(tok) + void *tok; +{ + return ("IP"); +} + diff --git a/sys/netatm/ipatm/ipatm_var.h b/sys/netatm/ipatm/ipatm_var.h new file mode 100644 index 0000000..6048284 --- /dev/null +++ b/sys/netatm/ipatm/ipatm_var.h @@ -0,0 +1,215 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: ipatm_var.h,v 1.8 1998/03/24 20:56:57 mks Exp $ + * + */ + +/* + * IP Over ATM Support + * ------------------- + * + * Protocol control blocks + * + */ + +#ifndef _IPATM_IPATM_VAR_H +#define _IPATM_IPATM_VAR_H + +#ifdef ATM_KERNEL +/* + * Structure containing information for each VCC, both SVC and PVC, which + * supports IP traffic. + */ +struct ipvcc { + Qelem_t iv_elem; /* ip_nif queueing links */ + u_short iv_flags; /* VCC flags (see below) */ + u_char iv_state; /* VCC state (see below) */ + Atm_connection *iv_conn; /* Connection manager token */ + struct in_addr iv_dst; /* Peer's IP address */ + struct ip_nif *iv_ipnif; /* IP network interface */ + struct atm_time iv_time; /* Timer controls */ + short iv_idle; /* VCC idle timer */ + u_char iv_parmx; /* Index into provider's vcc params */ + KBuffer *iv_queue; /* Packet waiting for VCC */ + struct arpmap *iv_arpent; /* ARP entry for VCC */ + struct ipvcc *iv_arpnext; /* ARP link field */ + Atm_connection *iv_arpconn; /* ARP connection manager token */ +}; +#define iv_forw iv_elem.q_forw +#define iv_back iv_elem.q_back +#endif /* ATM_KERNEL */ + +/* + * VCC Flags + */ +#define IVF_PVC 0x0001 /* PVC */ +#define IVF_SVC 0x0002 /* SVC */ +#define IVF_LLC 0x0004 /* VCC uses LLC/SNAP encapsulation */ +#define IVF_MAPOK 0x0008 /* VCC ARP mapping is valid */ +#define IVF_NOIDLE 0x0010 /* Do not idle-timeout this VCC */ + +/* + * VCC States + */ +#define IPVCC_FREE 0 /* No VCC associated with entry */ +#define IPVCC_PMAP 1 /* SVC waiting for ARP mapping */ +#define IPVCC_POPEN 2 /* Pending SVC open completion */ +#define IPVCC_PACCEPT 3 /* Pending SVC accept completion */ +#define IPVCC_ACTPENT 4 /* PVC open - waiting for ARP entry */ +#define IPVCC_ACTIVE 5 /* VCC open - available */ +#define IPVCC_CLOSED 6 /* VCC has been closed */ + + +#ifdef ATM_KERNEL +/* + * Structure containing IP-specific information for each ATM network + * interface in the system. + */ +struct ip_nif { + struct ip_nif *inf_next; /* Next on interface chain */ + struct atm_nif *inf_nif; /* ATM network interface */ + u_short inf_state; /* Interface state (see below) */ + struct in_ifaddr *inf_addr; /* Interface's IP address */ + Queue_t inf_vcq; /* VCC connections queue */ + struct ip_serv *inf_serv; /* Interface service provider */ + +/* For use by IP interface service provider (ie signalling manager) */ + caddr_t inf_isintf; /* Interface control block */ + +/* IP/ATM provided interface services */ + void (*inf_arpnotify)/* ARP event notification */ + __P((struct ipvcc *, int)); + int (*inf_ipinput) /* IP packet input */ + __P((struct ip_nif *, KBuffer *)); + int (*inf_createsvc)/* Create an IP SVC */ + __P((struct ifnet *, u_short, caddr_t, + struct ipvcc **)); +}; + +/* + * Network Interface States + */ +#define IPNIF_ADDR 1 /* Waiting for i/f address */ +#define IPNIF_SIGMGR 2 /* Waiting for sigmgr attach */ +#define IPNIF_ACTIVE 3 /* Active */ + + +/* + * Global IP/ATM Statistics + */ +struct ipatm_stat { + u_long ias_rcvstate; /* Packets received, bad vcc state */ + u_long ias_rcvnobuf; /* Packets received, no buf avail */ +}; + + +/* + * Structure to pass parameters for ipatm_openpvc() + */ +struct ipatmpvc { + struct ip_nif *ipp_ipnif; /* PVC's IP network interface */ + u_short ipp_vpi; /* VPI value */ + u_short ipp_vci; /* VCI value */ + Aal_t ipp_aal; /* AAL type */ + Encaps_t ipp_encaps; /* VCC encapsulation */ + struct sockaddr_in ipp_dst; /* Destination's IP address */ +}; + + +/* + * Timer macros + */ +#define IPVCC_TIMER(s, t) atm_timeout(&(s)->iv_time, (t), ipatm_timeout) +#define IPVCC_CANCEL(s) atm_untimeout(&(s)->iv_time) + +/* + * Misc useful macros + */ +#define SATOSIN(sa) ((struct sockaddr_in *)(sa)) + + +/* + * Global function declarations + */ + /* ipatm_event.c */ +void ipatm_timeout __P((struct atm_time *)); +void ipatm_connected __P((void *)); +void ipatm_cleared __P((void *, struct t_atm_cause *)); +void ipatm_arpnotify __P((struct ipvcc *, int)); +void ipatm_itimeout __P((struct atm_time *)); + + /* ipatm_if.c */ +int ipatm_nifstat __P((int, struct atm_nif *, int)); + + /* ipatm_input.c */ +void ipatm_cpcs_data __P((void *, KBuffer *)); +int ipatm_ipinput __P((struct ip_nif *, KBuffer *)); + + /* ipatm_load.c */ + + /* ipatm_output.c */ +int ipatm_ifoutput __P((struct ifnet *, KBuffer *, + struct sockaddr *)); + + /* ipatm_usrreq.c */ +int ipatm_ioctl __P((int, caddr_t, caddr_t)); +caddr_t ipatm_getname __P((void *)); + + /* ipatm_vcm.c */ +int ipatm_openpvc __P((struct ipatmpvc *, struct ipvcc **)); +int ipatm_createsvc __P((struct ifnet *, u_short, caddr_t, + struct ipvcc **)); +int ipatm_opensvc __P((struct ipvcc *)); +int ipatm_retrysvc __P((struct ipvcc *)); +void ipatm_activate __P((struct ipvcc *)); +int ipatm_incoming __P((void *, Atm_connection *, Atm_attributes *, + void **)); +int ipatm_closevc __P((struct ipvcc *, int)); +int ipatm_chknif __P((struct in_addr, struct ip_nif *)); +struct ipvcc *ipatm_iptovc __P((struct sockaddr_in *, struct atm_nif *)); + + +/* + * External variables + */ +extern int ipatm_vccnt; +extern int ipatm_vcidle; +extern int ipatm_print; +extern u_long last_map_ipdst; +extern struct ipvcc *last_map_ipvcc; +extern struct ip_nif *ipatm_nif_head; +extern struct sp_info ipatm_vcpool; +extern struct sp_info ipatm_nifpool; +extern struct ipatm_stat ipatm_stat; +extern struct atm_time ipatm_itimer; +extern Atm_endpoint ipatm_endpt; +extern Atm_attributes ipatm_aal5llc; +extern Atm_attributes ipatm_aal5null; +extern Atm_attributes ipatm_aal4null; + +#endif /* ATM_KERNEL */ + +#endif /* _IPATM_IPATM_VAR_H */ diff --git a/sys/netatm/ipatm/ipatm_vcm.c b/sys/netatm/ipatm/ipatm_vcm.c new file mode 100644 index 0000000..5d6a7fc --- /dev/null +++ b/sys/netatm/ipatm/ipatm_vcm.c @@ -0,0 +1,1245 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: ipatm_vcm.c,v 1.13 1998/08/06 18:21:14 mks Exp $ + * + */ + +/* + * IP Over ATM Support + * ------------------- + * + * Virtual Channel Manager + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: ipatm_vcm.c,v 1.13 1998/08/06 18:21:14 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm.h> +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> + + +Atm_attributes ipatm_aal5llc = { + NULL, /* nif */ + CMAPI_CPCS, /* api */ + 0, /* api_init */ + 0, /* headin */ + 0, /* headout */ + { /* aal */ + T_ATM_PRESENT, + ATM_AAL5 + }, + { /* traffic */ + T_ATM_PRESENT, + { + { + T_ATM_ABSENT, + 0, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_NO + }, + { + T_ATM_ABSENT, + 0, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_NO + }, + T_YES + }, + }, + { /* bearer */ + T_ATM_PRESENT, + { + T_ATM_CLASS_X, + T_ATM_NULL, + T_ATM_NULL, + T_NO, + T_ATM_1_TO_1 + } + }, + { /* bhli */ + T_ATM_ABSENT + }, + { /* blli */ + T_ATM_PRESENT, + T_ATM_ABSENT, + { + { + T_ATM_SIMPLE_ID, + }, + { + T_ATM_ABSENT + } + } + }, + { /* llc */ + T_ATM_PRESENT, + { + T_ATM_LLC_SHARING, + IPATM_LLC_LEN, + IPATM_LLC_HDR + } + }, + { /* called */ + T_ATM_PRESENT, + }, + { /* calling */ + T_ATM_ABSENT + }, + { /* qos */ + T_ATM_PRESENT, + { + T_ATM_NETWORK_CODING, + { + T_ATM_QOS_CLASS_0, + }, + { + T_ATM_QOS_CLASS_0 + } + } + }, + { /* transit */ + T_ATM_ABSENT + }, + { /* cause */ + T_ATM_ABSENT + } +}; + +Atm_attributes ipatm_aal5null = { + NULL, /* nif */ + CMAPI_CPCS, /* api */ + 0, /* api_init */ + sizeof(struct ifnet *), /* headin */ + 0, /* headout */ + { /* aal */ + T_ATM_PRESENT, + ATM_AAL5 + }, + { /* traffic */ + T_ATM_PRESENT, + { + { + T_ATM_ABSENT, + 0, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_NO + }, + { + T_ATM_ABSENT, + 0, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_NO + }, + T_YES + }, + }, + { /* bearer */ + T_ATM_PRESENT, + { + T_ATM_CLASS_X, + T_ATM_NULL, + T_ATM_NULL, + T_NO, + T_ATM_1_TO_1 + } + }, + { /* bhli */ + T_ATM_ABSENT + }, + { /* blli */ + T_ATM_ABSENT, + T_ATM_ABSENT + }, + { /* llc */ + T_ATM_ABSENT + }, + { /* called */ + T_ATM_PRESENT, + }, + { /* calling */ + T_ATM_ABSENT + }, + { /* qos */ + T_ATM_PRESENT, + { + T_ATM_NETWORK_CODING, + { + T_ATM_QOS_CLASS_0, + }, + { + T_ATM_QOS_CLASS_0 + } + } + }, + { /* transit */ + T_ATM_ABSENT + }, + { /* cause */ + T_ATM_ABSENT + } +}; + +Atm_attributes ipatm_aal4null = { + NULL, /* nif */ + CMAPI_CPCS, /* api */ + 0, /* api_init */ + sizeof(struct ifnet *), /* headin */ + 0, /* headout */ + { /* aal */ + T_ATM_PRESENT, + ATM_AAL3_4 + }, + { /* traffic */ + T_ATM_PRESENT, + { + { + T_ATM_ABSENT, + 0, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_NO + }, + { + T_ATM_ABSENT, + 0, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_NO + }, + T_YES + }, + }, + { /* bearer */ + T_ATM_PRESENT, + { + T_ATM_CLASS_X, + T_ATM_NULL, + T_ATM_NULL, + T_NO, + T_ATM_1_TO_1 + } + }, + { /* bhli */ + T_ATM_ABSENT + }, + { /* blli */ + T_ATM_ABSENT, + T_ATM_ABSENT + }, + { /* llc */ + T_ATM_ABSENT + }, + { /* called */ + T_ATM_PRESENT, + }, + { /* calling */ + T_ATM_ABSENT + }, + { /* qos */ + T_ATM_PRESENT, + { + T_ATM_NETWORK_CODING, + { + T_ATM_QOS_CLASS_0, + }, + { + T_ATM_QOS_CLASS_0 + } + } + }, + { /* transit */ + T_ATM_ABSENT + }, + { /* cause */ + T_ATM_ABSENT + } +}; + +static struct t_atm_cause ipatm_cause = { + T_ATM_ITU_CODING, + T_ATM_LOC_USER, + 0, + {0, 0, 0, 0} +}; + + +/* + * Open an IP PVC + * + * This function will perform all actions necessary to activate a + * PVC for IP usage. In particular, it will allocate control blocks, + * open the PVC, initialize PVC stack, and initiate whatever ARP + * procedures are required. + * + * Arguments: + * pvp pointer to PVC parameter structure + * sivp address to return pointer to IP PVC control block + * + * Returns: + * 0 PVC was successfully opened + * errno open failed - reason indicated + * + */ +int +ipatm_openpvc(pvp, sivp) + struct ipatmpvc *pvp; + struct ipvcc **sivp; +{ + struct ipvcc *ivp; + Atm_attributes *ap; + Atm_addr_pvc *pvcp; + struct atm_nif *nip; + struct ip_nif *inp; + int s, err = 0; + + inp = pvp->ipp_ipnif; + nip = inp->inf_nif; + + /* + * Make sure interface is ready to go + */ + if (inp->inf_state != IPNIF_ACTIVE) { + err = ENETDOWN; + goto done; + } + + /* + * Validate fixed destination IP address + */ + if (pvp->ipp_dst.sin_addr.s_addr != INADDR_ANY) { +#if (defined(BSD) && (BSD >= 199306)) + if (in_broadcast(pvp->ipp_dst.sin_addr, &nip->nif_if) || +#else + if (in_broadcast(pvp->ipp_dst.sin_addr) || +#endif + IN_MULTICAST(ntohl(pvp->ipp_dst.sin_addr.s_addr)) || + ipatm_chknif(pvp->ipp_dst.sin_addr, inp)) { + err = EINVAL; + goto done; + } + } + + /* + * Allocate IP VCC block + */ + ivp = (struct ipvcc *)atm_allocate(&ipatm_vcpool); + if (ivp == NULL) { + err = ENOMEM; + goto done; + } + + /* + * Initialize the PVC + */ + ivp->iv_flags = IVF_PVC; + if (pvp->ipp_encaps == ATM_ENC_LLC) + ivp->iv_flags |= IVF_LLC; + + /* + * Fill out connection attributes + */ + if (pvp->ipp_aal == ATM_AAL5) { + if (pvp->ipp_encaps == ATM_ENC_LLC) + ap = &ipatm_aal5llc; + else + ap = &ipatm_aal5null; + } else { + ap = &ipatm_aal4null; + } + + ap->nif = nip; + ap->traffic.v.forward.PCR_all_traffic = nip->nif_pif->pif_pcr; + ap->traffic.v.backward.PCR_all_traffic = nip->nif_pif->pif_pcr; + ap->called.addr.address_format = T_ATM_PVC_ADDR; + ap->called.addr.address_length = sizeof(Atm_addr_pvc); + pvcp = (Atm_addr_pvc *)ap->called.addr.address; + ATM_PVC_SET_VPI(pvcp, pvp->ipp_vpi); + ATM_PVC_SET_VCI(pvcp, pvp->ipp_vci); + ap->called.subaddr.address_format = T_ATM_ABSENT; + ap->called.subaddr.address_length = 0; + + /* + * Create PVC + */ + err = atm_cm_connect(&ipatm_endpt, ivp, ap, &ivp->iv_conn); + if (err) { + atm_free((caddr_t)ivp); + goto done; + } + + /* + * Save PVC information and link in VCC + */ + /* ivp->iv_ = ap->headout; */ + + /* + * Queue VCC onto its network interface + */ + s = splnet(); + ipatm_vccnt++; + ENQUEUE(ivp, struct ipvcc, iv_elem, inp->inf_vcq); + ivp->iv_ipnif = inp; + (void) splx(s); + + /* + * Set destination IP address and IPVCC state + */ + if (pvp->ipp_dst.sin_addr.s_addr == INADDR_ANY) { + /* + * Initiate ARP processing + */ + switch ((*inp->inf_serv->is_arp_pvcopen)(ivp)) { + + case MAP_PROCEEDING: + /* + * Wait for answer + */ + ivp->iv_state = IPVCC_ACTIVE; + break; + + case MAP_VALID: + /* + * We've got our answer already + */ + ivp->iv_state = IPVCC_ACTIVE; + ivp->iv_flags |= IVF_MAPOK; + ivp->iv_dst.s_addr = ivp->iv_arpent->am_dstip.s_addr; + break; + + case MAP_FAILED: + /* + * Try again later + */ + ivp->iv_state = IPVCC_ACTPENT; + IPVCC_TIMER(ivp, 1 * ATM_HZ); + break; + + default: + panic("ipatm_openpvc: invalid arp_pvcopen return"); + } + + } else { + /* + * Use configured IP destination + */ + ivp->iv_dst.s_addr = pvp->ipp_dst.sin_addr.s_addr; + ivp->iv_state = IPVCC_ACTIVE; + ivp->iv_flags |= IVF_MAPOK; + } + +done: + if (err) + *sivp = NULL; + else + *sivp = ivp; + return (err); +} + + +/* + * Create an IP SVC + * + * This function will initiate the creation of an IP SVC. The IP VCC + * control block will be initialized and, if required, we will initiate + * ARP processing in order to resolve the destination's ATM address. Once + * the destination ATM address is known, ipatm_opensvc() will be called. + * + * Arguments: + * ifp pointer to destination ifnet structure + * daf destination address family type + * dst pointer to destination address + * sivp address to return pointer to IP SVC control block + * + * Returns: + * 0 SVC creation was successfully initiated + * errno creation failed - reason indicated + * + */ +int +ipatm_createsvc(ifp, daf, dst, sivp) + struct ifnet *ifp; + u_short daf; + caddr_t dst; + struct ipvcc **sivp; +{ + struct atm_nif *nip = (struct atm_nif *)ifp; + struct ip_nif *inp; + struct ipvcc *ivp; + struct in_addr *ip; + Atm_addr *atm; + int s, err = 0; + + /* + * Get IP interface and make sure its ready + */ + for (inp = ipatm_nif_head; inp; inp = inp->inf_next) { + if (inp->inf_nif == nip) + break; + } + if (inp == NULL) { + err = ENXIO; + goto done; + } + if (inp->inf_state != IPNIF_ACTIVE) { + err = ENETDOWN; + goto done; + } + + /* + * Validate destination address + */ + if (daf == AF_INET) { + /* + * Destination is IP address + */ + ip = (struct in_addr *)dst; + atm = NULL; + if (ip->s_addr == INADDR_ANY) { + err = EADDRNOTAVAIL; + goto done; + } + } else if (daf == AF_ATM) { + /* + * Destination is ATM address + */ + atm = (Atm_addr *)dst; + ip = NULL; + if (atm->address_format == T_ATM_ABSENT) { + err = EINVAL; + goto done; + } + } else { + err = EINVAL; + goto done; + } + + /* + * Make sure we have services provider and ARP support + */ + if ((inp->inf_serv == NULL) || + (inp->inf_serv->is_arp_svcout == NULL)) { + err = ENETDOWN; + goto done; + } + + /* + * Allocate IP VCC + */ + ivp = (struct ipvcc *)atm_allocate(&ipatm_vcpool); + if (ivp == NULL) { + err = ENOMEM; + goto done; + } + + /* + * Initialize SVC + */ + ivp->iv_flags = IVF_SVC; + ivp->iv_ipnif = inp; + + /* + * Get destination ATM address + */ + if (daf == AF_INET) { + /* + * ARP is the way... + */ + ivp->iv_dst.s_addr = ip->s_addr; + + switch ((*inp->inf_serv->is_arp_svcout)(ivp, ip)) { + + case MAP_PROCEEDING: + /* + * Wait for answer + */ + ivp->iv_state = IPVCC_PMAP; + IPVCC_TIMER(ivp, IPATM_ARP_TIME); + break; + + case MAP_VALID: + /* + * We've got our answer already, so open SVC + */ + ivp->iv_flags |= IVF_MAPOK; + err = ipatm_opensvc(ivp); + if (err) { + (*inp->inf_serv->is_arp_close)(ivp); + atm_free((caddr_t)ivp); + goto done; + } + break; + + case MAP_FAILED: + /* + * So sorry...come again + */ + atm_free((caddr_t)ivp); + err = ENETDOWN; + goto done; + + default: + panic("ipatm_createsvc: invalid arp_svcout return"); + } + } else { + /* + * We were given the ATM address, so open the SVC + * + * Create temporary arp map entry so that opensvc() works. + * Caller must set up a permanent entry immediately! (yuk) + */ + struct arpmap map; + + ATM_ADDR_COPY(atm, &map.am_dstatm); + map.am_dstatmsub.address_format = T_ATM_ABSENT; + map.am_dstatmsub.address_length = 0; + ivp->iv_arpent = ↦ + err = ipatm_opensvc(ivp); + if (err) { + atm_free((caddr_t)ivp); + goto done; + } + ivp->iv_arpent = NULL; + } + + /* + * Queue VCC onto its network interface + */ + s = splnet(); + ipatm_vccnt++; + ENQUEUE(ivp, struct ipvcc, iv_elem, inp->inf_vcq); + (void) splx(s); + +done: + if (err) + *sivp = NULL; + else + *sivp = ivp; + return (err); +} + + +/* + * Open an IP SVC + * + * This function will continue the IP SVC creation process. Here, we + * will issue an SVC open to the signalling manager and then wait for + * the final SVC setup results. + * + * Arguments: + * ivp pointer to IP SVC to open + * + * Returns: + * 0 SVC open was successfully initiated + * errno open failed - reason indicated + * + */ +int +ipatm_opensvc(ivp) + struct ipvcc *ivp; +{ + struct ip_nif *inp = ivp->iv_ipnif; + Atm_attributes *ap; + int err = 0, i; + + /* + * Cancel possible arp timeout + */ + IPVCC_CANCEL(ivp); + + /* + * Fill out connection attributes + */ + i = ivp->iv_parmx; + if (inp->inf_serv->is_vccparm[i].ivc_aal == ATM_AAL5) { + if (inp->inf_serv->is_vccparm[i].ivc_encaps == ATM_ENC_LLC) { + ap = &ipatm_aal5llc; + ivp->iv_flags |= IVF_LLC; + } else { + ap = &ipatm_aal5null; + ivp->iv_flags &= ~IVF_LLC; + } + } else { + ap = &ipatm_aal4null; + ivp->iv_flags &= ~IVF_LLC; + } + + ap->nif = inp->inf_nif; + ap->traffic.v.forward.PCR_all_traffic = inp->inf_nif->nif_pif->pif_pcr; + ap->traffic.v.backward.PCR_all_traffic = inp->inf_nif->nif_pif->pif_pcr; + + ATM_ADDR_COPY(&ivp->iv_arpent->am_dstatm, &ap->called.addr); + ATM_ADDR_COPY(&ivp->iv_arpent->am_dstatmsub, &ap->called.subaddr); + + /* + * Initiate SVC open + */ + err = atm_cm_connect(&ipatm_endpt, ivp, ap, &ivp->iv_conn); + switch (err) { + + case EINPROGRESS: + /* + * Call is progressing + */ + /* ivp->iv_ = ap->headout; */ + + /* + * Now we just wait for a CALL_CONNECTED event + */ + ivp->iv_state = IPVCC_POPEN; + IPVCC_TIMER(ivp, IPATM_SVC_TIME); + err = 0; + break; + + case 0: + /* + * We've been hooked up with a shared VCC + */ + /* ivp->iv_ = ap->headout; */ + ipatm_activate(ivp); + break; + } + + return (err); +} + + +/* + * Retry an IP SVC Open + * + * This function will attempt to retry a failed SVC open request. The IP + * interface service provider specifies a list of possible VCC parameters + * for IP to use. We will try each set of parameters in turn until either + * an open succeeds or we reach the end of the list. + * + * Arguments: + * ivp pointer to IP SVC + * + * Returns: + * 0 SVC (re)open was successfully initiated + * else retry failed + * + */ +int +ipatm_retrysvc(ivp) + struct ipvcc *ivp; +{ + struct ip_nif *inp = ivp->iv_ipnif; + + /* + * If there isn't another set of vcc parameters to try, return + */ + if ((++ivp->iv_parmx >= IPATM_VCCPARMS) || + (inp->inf_serv->is_vccparm[ivp->iv_parmx].ivc_aal == 0)) + return (1); + + /* + * Okay, now initiate open with a new set of parameters + */ + return (ipatm_opensvc(ivp)); +} + + +/* + * Finish IP SVC Activation + * + * Arguments: + * ivp pointer to IP SVC + * + * Returns: + * none + * + */ +void +ipatm_activate(ivp) + struct ipvcc *ivp; +{ + + /* + * Connection is now active + */ + ivp->iv_state = IPVCC_ACTIVE; + IPVCC_CANCEL(ivp); + + /* + * Tell ARP module that connection is active + */ + if ((*ivp->iv_ipnif->inf_serv->is_arp_svcact)(ivp)) { + (void) ipatm_closevc(ivp, T_ATM_CAUSE_TEMPORARY_FAILURE); + return; + } + + /* + * Send any queued packet + */ + if ((ivp->iv_flags & IVF_MAPOK) && ivp->iv_queue) { + struct sockaddr_in sin; + struct ifnet *ifp; + + sin.sin_family = AF_INET; + sin.sin_addr.s_addr = ivp->iv_dst.s_addr; + ifp = (struct ifnet *)ivp->iv_ipnif->inf_nif; + (void) ipatm_ifoutput(ifp, ivp->iv_queue, + (struct sockaddr *)&sin); + ivp->iv_queue = NULL; + } +} + + +/* + * Process Incoming Calls + * + * This function will receive control when an incoming call has been matched + * to one of our registered listen parameter blocks. Assuming the call passes + * acceptance criteria and all required resources are available, we will + * create an IP SVC and notify the connection manager of our decision. We + * will then await notification of the final SVC setup results. If any + * problems are encountered, we will just tell the connection manager to + * reject the call. + * + * Called at splnet. + * + * Arguments: + * tok owner's matched listening token + * cop pointer to incoming call's connection block + * ap pointer to incoming call's attributes + * tokp pointer to location to store our connection token + * + * Returns: + * 0 call is accepted + * errno call rejected - reason indicated + * + */ +int +ipatm_incoming(tok, cop, ap, tokp) + void *tok; + Atm_connection *cop; + Atm_attributes *ap; + void **tokp; +{ + struct atm_nif *nip = ap->nif; + struct ip_nif *inp; + struct ipvcc *ivp = NULL; + int err, cause; + int usellc = 0, mtu = ATM_NIF_MTU; + + /* + * Get IP interface and make sure its ready + */ + for (inp = ipatm_nif_head; inp; inp = inp->inf_next) { + if (inp->inf_nif == nip) + break; + } + if ((inp == NULL) || (inp->inf_state != IPNIF_ACTIVE)) { + err = ENETUNREACH; + cause = T_ATM_CAUSE_SERVICE_OR_OPTION_UNAVAILABLE; + goto reject; + } + + /* + * Make sure we have services provider and ARP support + */ + if ((inp->inf_serv == NULL) || + (inp->inf_serv->is_arp_svcin == NULL)) { + err = ENETUNREACH; + cause = T_ATM_CAUSE_SERVICE_OR_OPTION_UNAVAILABLE; + goto reject; + } + + /* + * Check for LLC encapsulation + */ + if ((ap->blli.tag_l2 == T_ATM_PRESENT) && + (ap->blli.v.layer_2_protocol.ID_type == T_ATM_SIMPLE_ID) && + (ap->blli.v.layer_2_protocol.ID.simple_ID == T_ATM_BLLI2_I8802)) { + usellc = 1; + mtu += IPATM_LLC_LEN; + } + + /* + * Verify requested MTU + */ + if (ap->aal.type == ATM_AAL5) { + if ((ap->aal.v.aal5.forward_max_SDU_size > mtu) || + (ap->aal.v.aal5.backward_max_SDU_size < mtu)) { + err = ENETUNREACH; + cause = T_ATM_CAUSE_AAL_PARAMETERS_NOT_SUPPORTED; + goto reject; + } + } else { + if ((ap->aal.v.aal4.forward_max_SDU_size > mtu) || + (ap->aal.v.aal4.backward_max_SDU_size < mtu)) { + err = ENETUNREACH; + cause = T_ATM_CAUSE_AAL_PARAMETERS_NOT_SUPPORTED; + goto reject; + } + } + + /* + * Allocate IP VCC + */ + ivp = (struct ipvcc *)atm_allocate(&ipatm_vcpool); + if (ivp == NULL) { + err = ENOMEM; + cause = T_ATM_CAUSE_UNSPECIFIED_RESOURCE_UNAVAILABLE; + goto reject; + } + + /* + * Initialize SVC + */ + ivp->iv_flags = IVF_SVC; + ivp->iv_ipnif = inp; + if (usellc) + ivp->iv_flags |= IVF_LLC; + + /* + * Lookup ARP entry for destination + */ + switch ((*inp->inf_serv->is_arp_svcin) + (ivp, &ap->calling.addr, &ap->calling.subaddr)) { + + case MAP_PROCEEDING: + /* + * We'll be (hopefully) notified later + */ + break; + + case MAP_VALID: + /* + * We've got our answer already + */ + ivp->iv_flags |= IVF_MAPOK; + ivp->iv_dst.s_addr = ivp->iv_arpent->am_dstip.s_addr; + break; + + case MAP_FAILED: + /* + * So sorry...come again + */ + err = ENETUNREACH; + cause = T_ATM_CAUSE_SERVICE_OR_OPTION_UNAVAILABLE; + goto reject; + + default: + panic("ipatm_incoming: invalid arp_svcin return"); + } + + /* + * Accept SVC connection + */ + ivp->iv_state = IPVCC_PACCEPT; + + /* + * Save VCC information + */ + ivp->iv_conn = cop; + *tokp = ivp; + /* ivp->iv_ = ap->headout; */ + + /* + * Queue VCC onto its network interface + */ + ipatm_vccnt++; + ENQUEUE(ivp, struct ipvcc, iv_elem, inp->inf_vcq); + + /* + * Wait for a CALL_CONNECTED event + */ + IPVCC_TIMER(ivp, IPATM_SVC_TIME); + + return (0); + +reject: + /* + * Clean up after call failure + */ + if (ivp) { + (*inp->inf_serv->is_arp_close)(ivp); + atm_free((caddr_t)ivp); + } + ap->cause.tag = T_ATM_PRESENT; + ap->cause.v = ipatm_cause; + ap->cause.v.cause_value = cause; + return (err); +} + + +/* + * Close an IP VCC + * + * This function will close an IP VCC (PVC or SVC), including notifying + * the signalling and ARP subsystems of the VCC's demise and cleaning + * up memory after ourselves. + * + * Arguments: + * ivp pointer to VCC + * code cause code + * + * Returns: + * 0 VCC successfully closed + * errno close failed - reason indicated + * + */ +int +ipatm_closevc(ivp, code) + struct ipvcc *ivp; + int code; +{ + struct ip_nif *inp = ivp->iv_ipnif; + int s, err; + + /* + * Make sure VCC hasn't been through here already + */ + switch (ivp->iv_state) { + + case IPVCC_FREE: + return (EALREADY); + } + + /* + * Reset lookup cache + */ + if (last_map_ipvcc == ivp) { + last_map_ipvcc = NULL; + last_map_ipdst = 0; + } + + /* + * Tell ARP about SVCs and dynamic PVCs + */ + if (inp->inf_serv && + ((ivp->iv_flags & IVF_SVC) || inp->inf_serv->is_arp_pvcopen)) { + (*inp->inf_serv->is_arp_close)(ivp); + } + + /* + * Free queued packets + */ + if (ivp->iv_queue) + KB_FREEALL(ivp->iv_queue); + + /* + * Cancel any timers + */ + IPVCC_CANCEL(ivp); + + /* + * Close VCC + */ + switch (ivp->iv_state) { + + case IPVCC_PMAP: + break; + + case IPVCC_POPEN: + case IPVCC_PACCEPT: + case IPVCC_ACTPENT: + case IPVCC_ACTIVE: + ipatm_cause.cause_value = code; + err = atm_cm_release(ivp->iv_conn, &ipatm_cause); + if (err) { + log(LOG_ERR, + "ipatm_closevc: release fail: err=%d\n", err); + } + break; + + case IPVCC_CLOSED: + break; + + default: + log(LOG_ERR, + "ipatm_closevc: unknown state: ivp=0x%x, state=%d\n", + (int)ivp, ivp->iv_state); + } + + /* + * Remove VCC from network i/f + */ + s = splnet(); + DEQUEUE(ivp, struct ipvcc, iv_elem, inp->inf_vcq); + + /* + * Reset state just to be sure + */ + ivp->iv_state = IPVCC_FREE; + + /* + * If ARP module is done with VCC too, then free it + */ + if (ivp->iv_arpconn == NULL) + atm_free((caddr_t)ivp); + ipatm_vccnt--; + (void) splx(s); + + return (0); +} + + +/* + * Check if IP address is valid on a Network Interface + * + * Checks whether the supplied IP address is allowed to be assigned to + * the supplied IP network interface. + * + * Arguments: + * in IP address + * inp pointer to IP network interface + * + * Returns: + * 0 - OK to assign + * 1 - not valid to assign + * + */ +int +ipatm_chknif(in, inp) + struct in_addr in; + struct ip_nif *inp; +{ + struct in_ifaddr *ia; + u_long i; + + /* + * Make sure there's an interface requested + */ + if (inp == NULL) + return (1); + + /* + * Make sure we have an IP address + */ + i = ntohl(in.s_addr); + if (i == 0) + return (1); + + /* + * Make sure an interface address is set + */ + ia = inp->inf_addr; + if (ia == NULL) + return (1); + + /* + * Make sure we're on the right subnet + */ + if ((i & ia->ia_subnetmask) != ia->ia_subnet) + return (1); + + return (0); +} + + +/* + * Map an IP Address to an IP VCC + * + * Given a destination IP address, this function will return a pointer + * to the appropriate output IP VCC to which to send the packet. + * This is currently implemented using a one-behind cache containing the + * last successful mapping result. If the cache lookup fails, then a + * simple linear search of all IP VCCs on the destination network interface + * is performed. This is obviously an area to look at for performance + * improvements. + * + * Arguments: + * dst pointer to destination IP address + * nip pointer to destination network interface + * + * Returns: + * addr pointer to located IP VCC + * 0 no such mapping exists + * + */ +struct ipvcc * +ipatm_iptovc(dst, nip) + struct sockaddr_in *dst; + struct atm_nif *nip; +{ + struct ip_nif *inp; + struct ipvcc *ivp; + u_long dstip = dst->sin_addr.s_addr; + int s; + + /* + * Look in cache first + */ + if (last_map_ipdst == dstip) + return (last_map_ipvcc); + + /* + * Oh well, we've got to search for it...first find the interface + */ + s = splnet(); + for (inp = ipatm_nif_head; inp; inp = inp->inf_next) { + if (inp->inf_nif == nip) + break; + } + if (inp == NULL) { + (void) splx(s); + return (NULL); + } + + /* + * Now home in on the VCC + */ + for (ivp = Q_HEAD(inp->inf_vcq, struct ipvcc); ivp; + ivp = Q_NEXT(ivp, struct ipvcc, iv_elem)) { + if (ivp->iv_dst.s_addr == dstip) + break; + } + + /* + * Update lookup cache + */ + if (ivp) { + last_map_ipdst = dstip; + last_map_ipvcc = ivp; + } + (void) splx(s); + + return (ivp); +} + diff --git a/sys/netatm/kern_include.h b/sys/netatm/kern_include.h new file mode 100644 index 0000000..9134206 --- /dev/null +++ b/sys/netatm/kern_include.h @@ -0,0 +1,112 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: kern_include.h,v 1.7 1998/07/23 21:44:40 root Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * Common kernel module includes + * + */ + +#ifndef _NETATM_KERN_INCLUDE_H +#define _NETATM_KERN_INCLUDE_H + +/* + * Note that we're compiling kernel code + */ +#define ATM_KERNEL + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/types.h> +#include <sys/errno.h> +#include <sys/malloc.h> +#include <sys/proc.h> +#include <sys/sockio.h> +#include <sys/time.h> +#include <sys/kernel.h> +#include <sys/conf.h> +#include <sys/domain.h> +#include <sys/protosw.h> +#include <sys/socket.h> +#include <sys/socketvar.h> +#include <sys/syslog.h> + +#ifdef sun +#include <machine/cpu.h> +#include <machine/mmu.h> +#include <machine/psl.h> +#include <sun/openprom.h> +#include <sun/vddrv.h> +#include <sundev/mbvar.h> +#endif + +#ifdef __FreeBSD__ +#include <machine/clock.h> +#include <vm/vm.h> +#include <vm/pmap.h> +#endif + +/* + * Networking support + */ +#include <net/if.h> +#if (defined(BSD) && (BSD >= 199103)) +#include <net/if_types.h> +#include <net/if_dl.h> +#endif +#include <net/netisr.h> +#include <net/route.h> +#include <netinet/in.h> +#include <netinet/in_var.h> +#include <netinet/if_ether.h> + +/* + * Porting fluff + */ +#include <netatm/port.h> + +/* + * ATM core services + */ +#include <netatm/queue.h> +#include <netatm/atm.h> +#include <netatm/atm_sys.h> +#include <netatm/atm_sap.h> +#include <netatm/atm_cm.h> +#include <netatm/atm_if.h> +#include <netatm/atm_vc.h> +#include <netatm/atm_ioctl.h> +#include <netatm/atm_sigmgr.h> +#include <netatm/atm_stack.h> +#include <netatm/atm_pcb.h> +#include <netatm/atm_var.h> + +#endif /* _NETATM_KERN_INCLUDE_H */ diff --git a/sys/netatm/port.h b/sys/netatm/port.h new file mode 100644 index 0000000..fac693a --- /dev/null +++ b/sys/netatm/port.h @@ -0,0 +1,564 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: port.h,v 1.7 1998/03/24 20:25:28 mks Exp $ + * + */ + +/* + * System Configuration + * -------------------- + * + * Porting aides + * + */ + +#ifndef _NETATM_PORT_H +#define _NETATM_PORT_H + +/* + * Try to ensure that this system is supported + */ +#if (defined(BSD) && (BSD >= 199103)) + + /* 4.3 BSD Net2 based */ + +#elif defined(sun) + + /* SunOS4.x */ + +#else + + /* Ooops */ + #error "Undefined/unsupported system type" + +#endif + + +/* + * Kernel memory management + * + * KM_ALLOC(size, type, flags) + * Returns an allocated kernel memory chunk of size bytes. + * KM_FREE(addr, size, type) + * Free a kernel memory chunk of size bytes. + * KM_CMP(b1, b2, len) + * Compares len bytes of data from b1 against b2. + * KM_COPY(from, to, len) + * Copies len bytes of data from from to to. + * KM_ZERO(addr, len) + * Zeros len bytes of data from addr. + * + */ +#ifdef ATM_KERNEL +#if (defined(BSD) && (BSD >= 199103)) +#include <sys/malloc.h> +#define KM_ALLOC(size, type, flags) malloc((size), (type), (flags)) +#define KM_FREE(addr, size, type) free((addr), (type)) +#elif defined(sun) +#include <sys/kmem_alloc.h> +#define KM_ALLOC(size, type, flags) kmem_alloc(size) +#define KM_FREE(addr, size, type) kmem_free((addr), (size)) +#endif + +#if defined(BSD) +#define KM_CMP(b1, b2, len) bcmp((void *)(b1), (void *)(b2),\ + (len)) +#define KM_COPY(from, to, len) bcopy((void *)(from), (void *)(to),\ + (len)) +#define KM_ZERO(addr, len) bzero((void *)(addr), (len)) +#endif +#define XM_COPY(f, t, l) KM_COPY((f), (t), (l)) + +#else + +/* + * User-space memory management + * + * UM_ALLOC(size) Returns an allocated kernel memory chunk of size bytes. + * UM_FREE(addr) Free a kernel memory chunk of size bytes. + * UM_COPY(from, to, len) + * Copies len bytes of data from from to to. + * UM_ZERO(addr, len) Zeros len bytes of data from addr. + * + */ +#if (defined(BSD) && (BSD >= 199103)) +#define UM_ALLOC(size) malloc((size_t)(size)) +#define UM_FREE(addr) free((void *)(addr)) +#define UM_COPY(from, to, len) bcopy((void *)(from), (void *)(to),\ + (size_t)(len)) +#define UM_ZERO(addr, len) bzero((void *)(addr), (size_t)(len)) +#elif defined(sun) +#define UM_ALLOC(size) malloc(size) +#define UM_FREE(addr) free((char *)(addr)) +#define UM_COPY(from, to, len) bcopy((char *)(from), (char *)(to), (len)) +#define UM_ZERO(addr, len) bzero((char *)(addr), (len)) + +#endif +#define XM_COPY(f, t, l) UM_COPY((f), (t), (l)) + +#endif /* ATM_KERNEL */ + + +#ifdef ATM_KERNEL +/* + * Kernel buffers + * + * KBuffer Typedef for a kernel buffer. + * + * KB_NEXT(bfr) Access next buffer in chain (r/w). + * KB_LEN(bfr) Access length of data in this buffer (r/w). + * KB_QNEXT(bfr) Access next buffer in queue (r/w). + * + * KB_ALLOC(bfr, size, flags, type) + * Allocates a new kernel buffer of at least size bytes. + * KB_ALLOCPKT(bfr, size, flags, type) + * Allocates a new kernel packet header buffer of at + * least size bytes. + * KB_ALLOCEXT(bfr, size, flags, type) + * Allocates a new kernel buffer with external storage + * of at least size bytes. + * KB_FREEONE(bfr, nxt) Free buffer bfr and set next buffer in chain in nxt. + * KB_FREEALL(bfr) Free bfr's entire buffer chain. + * KB_COPY(bfr, off, len, new, flags) + * Copy len bytes of user data from buffer bfr starting at + * byte offset off and return new buffer chain in new. + * If len is KB_COPYALL, copy until end of chain. + * KB_COPYDATA(bfr, off, len, datap) + * Copy data from buffer bfr starting at byte offset off + * for len bytes into the data area pointed to by datap. + * Returns the number of bytes not copied to datap. + * KB_PULLUP(bfr, n, new) + * Get at least the first n bytes of data in the buffer + * chain headed by bfr contiguous in the first buffer. + * Returns the (potentially new) head of the chain in new. + * On failure the chain is freed and NULL is returned. + * KB_LINKHEAD(new, head) + * Link the kernel buffer new at the head of the buffer + * chain headed by head. If both new and head are + * packet header buffers, new will become the packet + * header for the chain. + * KB_LINK(new, prev) + * Link the kernel buffer new into the buffer chain + * after the buffer prev. + * KB_UNLINKHEAD(head, next) + * Unlink the kernel buffer from the head of the buffer + * chain headed by head. The buffer head will be freed + * and the new chain head will be placed in next. + * KB_UNLINK(old, prev, next) + * Unlink the kernel buffer old with previous buffer prev + * from its buffer chain. The following buffer in the + * chain will be placed in next and the buffer old will + * be freed. + * KB_ISPKT(bfr) Tests whether bfr is a packet header buffer. + * KB_ISEXT(bfr) Tests whether bfr has external storage. + * KB_BFRSTART(bfr, x, t) + * Sets x (cast to type t) to point to the start of the + * buffer space in bfr. + * KB_BFREND(bfr, x, t) + * Sets x (cast to type t) to point one byte past the end + * of the buffer space in bfr. + * KB_BFRLEN(bfr) Returns length of buffer space in bfr. + * KB_DATASTART(bfr, x, t) + * Sets x (cast to type t) to point to the start of the + * buffer data contained in bfr. + * KB_DATAEND(bfr, x, t) + * Sets x (cast to type t) to point one byte past the end + * of the buffer data contained in bfr. + * KB_HEADSET(bfr, n) Sets the start address for buffer data in buffer bfr to + * n bytes from the beginning of the buffer space. + * KB_HEADMOVE(bfr, n) Adjust buffer data controls to move data down (n > 0) + * or up (n < 0) n bytes in the buffer bfr. + * KB_HEADADJ(bfr, n) Adjust buffer data controls to add (n > 0) or subtract + * (n < 0) n bytes of data to/from the beginning of bfr. + * KB_TAILADJ(bfr, n) Adjust buffer data controls to add (n > 0) or subtract + * (n < 0) n bytes of data to/from the end of bfr. + * KB_TAILALIGN(bfr, n) Set buffer data controls to place an object of size n + * at the end of bfr, longword aligned. + * KB_HEADROOM(bfr, n) Set n to the amount of buffer space available before + * the start of data in bfr. + * KB_TAILROOM(bfr, n) Set n to the amount of buffer space available after + * the end of data in bfr. + * KB_PLENGET(bfr, n) Set n to bfr's packet length. + * KB_PLENSET(bfr, n) Set bfr's packet length to n. + * KB_PLENADJ(bfr, n) Adjust total packet length by n bytes. + * + */ +#if defined(BSD) +#include <sys/mbuf.h> +typedef struct mbuf KBuffer; + +#define KB_F_WAIT M_WAIT +#define KB_F_NOWAIT M_DONTWAIT + +#define KB_T_HEADER MT_HEADER +#define KB_T_DATA MT_DATA + +#define KB_COPYALL M_COPYALL + +#if BSD >= 199103 + +#define KB_NEXT(bfr) (bfr)->m_next +#define KB_LEN(bfr) (bfr)->m_len +#define KB_QNEXT(bfr) (bfr)->m_nextpkt +#define KB_ALLOC(bfr, size, flags, type) { \ + if ((size) <= MLEN) { \ + MGET((bfr), (flags), (type)); \ + } else \ + (bfr) = NULL; \ +} +#define KB_ALLOCPKT(bfr, size, flags, type) { \ + if ((size) <= MHLEN) { \ + MGETHDR((bfr), (flags), (type)); \ + } else \ + (bfr) = NULL; \ +} +#define KB_ALLOCEXT(bfr, size, flags, type) { \ + if ((size) <= MCLBYTES) { \ + MGET((bfr), (flags), (type)); \ + if ((bfr) != NULL) { \ + MCLGET((bfr), (flags)); \ + if (((bfr)->m_flags & M_EXT) == 0) { \ + m_freem((bfr)); \ + (bfr) = NULL; \ + } \ + } \ + } else \ + (bfr) = NULL; \ +} +#define KB_FREEONE(bfr, nxt) { \ + (nxt) = m_free(bfr); \ +} +#define KB_FREEALL(bfr) { \ + m_freem(bfr); \ +} +#define KB_COPY(bfr, off, len, new, flags) { \ + (new) = m_copym((bfr), (off), (len), (flags)); \ +} +#define KB_COPYDATA(bfr, off, len, datap) \ + (m_copydata((bfr), (off), (len), (datap)), 0) +#define KB_PULLUP(bfr, n, new) { \ + (new) = m_pullup((bfr), (n)); \ +} +#define KB_LINKHEAD(new, head) { \ + if ((head) && KB_ISPKT(new) && KB_ISPKT(head)) {\ + M_COPY_PKTHDR((new), (head)); \ + (head)->m_flags &= ~M_PKTHDR; \ + } \ + (new)->m_next = (head); \ +} +#define KB_LINK(new, prev) { \ + (new)->m_next = (prev)->m_next; \ + (prev)->m_next = (new); \ +} +#define KB_UNLINKHEAD(head, next) { \ + MFREE((head), (next)); \ +} +#define KB_UNLINK(old, prev, next) { \ + MFREE((old), (next)); \ + (prev)->m_next = (next); \ +} +#define KB_ISPKT(bfr) (((bfr)->m_flags & M_PKTHDR) != 0) +#define KB_ISEXT(bfr) (((bfr)->m_flags & M_EXT) != 0) +#define KB_BFRSTART(bfr, x, t) { \ + if ((bfr)->m_flags & M_EXT) \ + (x) = (t)((bfr)->m_ext.ext_buf); \ + else if ((bfr)->m_flags & M_PKTHDR) \ + (x) = (t)(&(bfr)->m_pktdat); \ + else \ + (x) = (t)((bfr)->m_dat); \ +} +#define KB_BFREND(bfr, x, t) { \ + if ((bfr)->m_flags & M_EXT) \ + (x) = (t)((bfr)->m_ext.ext_buf + (bfr)->m_ext.ext_size);\ + else if ((bfr)->m_flags & M_PKTHDR) \ + (x) = (t)(&(bfr)->m_pktdat + MHLEN); \ + else \ + (x) = (t)((bfr)->m_dat + MLEN); \ +} +#define KB_BFRLEN(bfr) \ + (((bfr)->m_flags & M_EXT) ? (bfr)->m_ext.ext_size : \ + (((bfr)->m_flags & M_PKTHDR) ? MHLEN : MLEN)) +#define KB_DATASTART(bfr, x, t) { \ + (x) = mtod((bfr), t); \ +} +#define KB_DATAEND(bfr, x, t) { \ + (x) = (t)(mtod((bfr), caddr_t) + (bfr)->m_len); \ +} +#define KB_HEADSET(bfr, n) { \ + if ((bfr)->m_flags & M_EXT) \ + (bfr)->m_data = (bfr)->m_ext.ext_buf + (n); \ + else if ((bfr)->m_flags & M_PKTHDR) \ + (bfr)->m_data = (bfr)->m_pktdat + (n); \ + else \ + (bfr)->m_data = (bfr)->m_dat + (n); \ +} +#define KB_HEADMOVE(bfr, n) { \ + (bfr)->m_data += (n); \ +} +#define KB_HEADADJ(bfr, n) { \ + (bfr)->m_len += (n); \ + (bfr)->m_data -= (n); \ +} +#define KB_TAILADJ(bfr, n) { \ + (bfr)->m_len += (n); \ +} +#define KB_TAILALIGN(bfr, n) { \ + (bfr)->m_len = (n); \ + if ((bfr)->m_flags & M_EXT) \ + (bfr)->m_data = (caddr_t)(((u_int)(bfr)->m_ext.ext_buf \ + + (bfr)->m_ext.ext_size - (n)) & ~(sizeof(long) - 1));\ + else \ + (bfr)->m_data = (caddr_t)(((u_int)(bfr)->m_dat + MLEN - (n)) \ + & ~(sizeof(long) - 1)); \ +} +#define KB_HEADROOM(bfr, n) { \ + /* n = M_LEADINGSPACE(bfr) XXX */ \ + (n) = ((bfr)->m_flags & M_EXT ? (bfr)->m_data - (bfr)->m_ext.ext_buf : \ + (bfr)->m_flags & M_PKTHDR ? (bfr)->m_data - (bfr)->m_pktdat : \ + (bfr)->m_data - (bfr)->m_dat); \ +} +#define KB_TAILROOM(bfr, n) { \ + (n) = M_TRAILINGSPACE(bfr); \ +} +#define KB_PLENGET(bfr, n) { \ + (n) = (bfr)->m_pkthdr.len; \ +} +#define KB_PLENSET(bfr, n) { \ + (bfr)->m_pkthdr.len = (n); \ +} +#define KB_PLENADJ(bfr, n) { \ + (bfr)->m_pkthdr.len += (n); \ +} + + +#else /* ! BSD >= 199103 */ + + +#define KB_NEXT(bfr) (bfr)->m_next +#define KB_LEN(bfr) (bfr)->m_len +#define KB_QNEXT(bfr) (bfr)->m_act +#define KB_ALLOC(bfr, size, flags, type) { \ + if ((size) <= MLEN) { \ + MGET((bfr), (flags), (type)); \ + } else \ + (bfr) = NULL; \ +} +#define KB_ALLOCPKT(bfr, size, flags, type) { \ + if ((size) <= MLEN) { \ + MGET((bfr), (flags), (type)); \ + } else \ + (bfr) = NULL; \ +} +#define KB_ALLOCEXT(bfr, size, flags, type) { \ + if ((size) <= MCLBYTES) { \ + MGET((bfr), (flags), (type)); \ + if ((bfr) != NULL) { \ + MCLGET(bfr); \ + if ((bfr)->m_len != MCLBYTES) { \ + m_freem((bfr)); \ + (bfr) = NULL; \ + } \ + } \ + } else \ + (bfr) = NULL; \ +} +#define KB_FREEONE(bfr, nxt) { \ + (nxt) = m_free(bfr); \ +} +#define KB_FREEALL(bfr) { \ + m_freem(bfr); \ +} +#define KB_COPY(bfr, off, len, new, flags) { \ + (new) = m_copy((bfr), (off), (len)); \ +} +#define KB_COPYDATA(bfr, off, len, datap) \ + m_cpytoc((bfr), (off), (len), (datap)) +#define KB_PULLUP(bfr, n, new) { \ + (new) = m_pullup((bfr), (n)); \ +} +#define KB_LINKHEAD(new, head) { \ + (new)->m_next = (head); \ +} +#define KB_LINK(new, prev) { \ + (new)->m_next = (prev)->m_next; \ + (prev)->m_next = (new); \ +} +#define KB_UNLINKHEAD(head, next) { \ + MFREE((head), (next)); \ +} +#define KB_UNLINK(old, prev, next) { \ + MFREE((old), (next)); \ + (prev)->m_next = (next); \ +} +#define KB_ISPKT(bfr) (0) +#define KB_ISEXT(bfr) M_HASCL(bfr) +#define KB_BFRSTART(bfr, x, t) { \ + if (M_HASCL(bfr)) { \ + if ((bfr)->m_cltype == MCL_STATIC) \ + (x) = (t)(mtod((bfr), int) & ~(MCLBYTES - 1)); \ + else \ + (x) = (t)NULL; \ + } else \ + (x) = (t)((bfr)->m_dat); \ +} +#define KB_BFREND(bfr, x, t) { \ + if (M_HASCL(bfr)) { \ + if ((bfr)->m_cltype == MCL_STATIC) \ + (x) = (t)((mtod((bfr), int) & ~(MCLBYTES - 1)) \ + + MCLBYTES); \ + else \ + (x) = (t)NULL; \ + } else \ + (x) = (t)((bfr)->m_dat + MLEN); \ +} +#define KB_BFRLEN(bfr) \ + (M_HASCL(bfr) ? (((bfr)->m_cltype == MCL_STATIC) ? MCLBYTES : 0) : MLEN) +#define KB_DATASTART(bfr, x, t) { \ + (x) = mtod((bfr), t); \ +} +#define KB_DATAEND(bfr, x, t) { \ + (x) = (t)(mtod((bfr), caddr_t) + (bfr)->m_len); \ +} +#define KB_HEADSET(bfr, n) { \ + if (M_HASCL(bfr)) { \ + /* Assume cluster buffer is empty XXX */\ + (bfr)->m_off += (n); \ + } else \ + (bfr)->m_off = MMINOFF + (n); \ +} +#define KB_HEADMOVE(bfr, n) { \ + (bfr)->m_off += (n); \ +} +#define KB_HEADADJ(bfr, n) { \ + (bfr)->m_len += (n); \ + (bfr)->m_off -= (n); \ +} +#define KB_TAILADJ(bfr, n) { \ + (bfr)->m_len += (n); \ +} +#define KB_TAILALIGN(bfr, n) { \ + (bfr)->m_len = (n); \ + if (M_HASCL(bfr)) { \ + if ((bfr)->m_cltype == MCL_STATIC) \ + (bfr)->m_off = (int)(((mtod((bfr), int) \ + & ~(MCLBYTES - 1)) + MCLBYTES - (n)) \ + & ~(sizeof(long) - 1)) - (int)(bfr); \ + /* Out of luck for loaned buffers */ \ + } else \ + (bfr)->m_off = (MMAXOFF - (n)) & ~(sizeof(long) - 1); \ +} +#define KB_HEADROOM(bfr, n) { \ + if (M_HASCL(bfr)) { \ + if ((bfr)->m_cltype == MCL_STATIC) \ + (n) = mtod((bfr), int) & (MCLBYTES - 1); \ + else \ + (n) = 0; \ + } else \ + (n) = (bfr)->m_off - MMINOFF; \ +} +#define KB_TAILROOM(bfr, n) { \ + if (M_HASCL(bfr)) { \ + if ((bfr)->m_cltype == MCL_STATIC) \ + (n) = MCLBYTES - ((mtod((bfr), int) + (bfr)->m_len) \ + & (MCLBYTES - 1)); \ + else \ + (n) = 0; \ + } else \ + (n) = MMAXOFF - ((bfr)->m_off + (bfr)->m_len); \ +} +#define KB_PLENGET(bfr, n) { \ + struct mbuf *zz; \ + for ((n) = 0, zz = (bfr); zz; zz = zz->m_next) \ + (n) += zz->m_len; \ +} +#define KB_PLENSET(bfr, n) { \ +} +#define KB_PLENADJ(bfr, n) { \ +} + + +#endif /* ! BSD >= 199103 */ + +#endif /* defined(BSD) */ + + +/* + * Kernel time + * + * KTimeout_ret Typedef for timeout() function return + * + * KT_TIME(t) Sets t to the current time. + * + */ +#if (defined(BSD) && (BSD >= 199306)) +typedef void KTimeout_ret; +#else +typedef int KTimeout_ret; +#endif +#if (defined(BSD) && (BSD >= 199103)) +#define KT_TIME(t) microtime(&t) +#elif defined(sun) +#define KT_TIME(t) uniqtime(&t) +#else +#define KT_TIME(t) ((t) = time) +#endif + +#endif /* ATM_KERNEL */ + +#ifndef NTOHL +#if BYTE_ORDER == BIG_ENDIAN +#define NTOHL(x) (x) +#define NTOHS(x) (x) +#define HTONL(x) (x) +#define HTONS(x) (x) +#else +#define NTOHL(x) (x) = ntohl((u_long)(x)) +#define NTOHS(x) (x) = ntohs((u_short)(x)) +#define HTONL(x) (x) = htonl((u_long)(x)) +#define HTONS(x) (x) = htons((u_short)(x)) +#endif +#endif /* NTOHL */ + +#ifndef MAX +#define MAX(a,b) max((a),(b)) +#endif +#ifndef MIN +#define MIN(a,b) min((a),(b)) +#endif + +#if (!(defined(BSD) && (BSD >= 199306))) +#ifndef __BIT_TYPES_DEFINED__ +#define __BIT_TYPES_DEFINED__ +typedef char int8_t; +typedef unsigned char u_int8_t; +typedef short int16_t; +typedef unsigned short u_int16_t; +typedef int int32_t; +typedef unsigned int u_int32_t; +#endif +#endif + +#endif /* _NETATM_PORT_H */ diff --git a/sys/netatm/queue.h b/sys/netatm/queue.h new file mode 100644 index 0000000..8a8febf --- /dev/null +++ b/sys/netatm/queue.h @@ -0,0 +1,213 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: queue.h,v 1.2 1997/05/06 22:14:38 mks Exp $ + * + */ + +/* + * Core ATM Services + * ----------------- + * + * General queueing/linking definitions + * + */ + +#ifndef _NETATM_QUEUE_H +#define _NETATM_QUEUE_H + +/* + * Structure defining the queue controls for a doubly linked queue + */ +struct q_queue { + caddr_t q_head; /* Head of queue */ + caddr_t q_tail; /* Tail of queue */ +}; +typedef struct q_queue Queue_t; + +/* + * Structure defining the queue elements of a doubly linked queue + */ +struct q_elem { + caddr_t q_forw; /* Forward link */ + caddr_t q_back; /* Backward link */ +}; +typedef struct q_elem Qelem_t; + +/* + * Macro to add a control block onto the tail of a doubly linked queue + * e = control block to add + * t = control block structure type + * el = name of control block's q_elem field + * q = pointer to queue controls + */ +#define ENQUEUE(e,t,el,q) \ +{ \ + (e)->el.q_forw = NULL; \ + (e)->el.q_back = (q).q_tail; \ + if ((q).q_head == NULL) { \ + (q).q_head = (caddr_t)(e); \ + (q).q_tail = (caddr_t)(e); \ + } else { \ + ((t *)(q).q_tail)->el.q_forw = (caddr_t)(e); \ + (q).q_tail = (caddr_t)(e); \ + } \ +} + +/* + * Macro to remove a control block from a doubly linked queue + * e = control block to remove + * t = control block structure type + * el = name of control block's q_elem field + * q = pointer to queue controls + */ +#define DEQUEUE(e,t,el,q) \ +{ \ + /* Ensure control block is on queue */ \ + if ((e)->el.q_forw || (q).q_tail == (caddr_t)(e)) { \ + if ((e)->el.q_forw) \ + ((t *)(e)->el.q_forw)->el.q_back = (e)->el.q_back;\ + else \ + (q).q_tail = (e)->el.q_back; \ + if ((e)->el.q_back) \ + ((t *)(e)->el.q_back)->el.q_forw = (e)->el.q_forw;\ + else \ + (q).q_head = (e)->el.q_forw; \ + } \ + (e)->el.q_back = (e)->el.q_forw = NULL; \ +} + +/* + * Macro to return the head of a doubly linked queue + * q = pointer to queue controls + * t = control block structure type + */ +#define Q_HEAD(q,t) ((t *)(q).q_head) + +/* + * Macro to return the next control block of a doubly linked queue + * e = current control block + * t = control block structure type + * el = name of control block's q_elem field + */ +#define Q_NEXT(e,t,el) ((t *)(e)->el.q_forw) + + +/* + * Macro to add a control block onto the head of a singly linked chain + * u = control block to add + * t = structure type + * h = head of chain + * l = name of link field + */ +#define LINK2HEAD(u,t,h,l) \ +{ \ + (u)->l = (h); \ + (h) = (u); \ +} + +/* + * Macro to add a control block onto the tail of a singly linked chain + * u = control block to add + * t = structure type + * h = head of chain + * l = name of link field + */ +#define LINK2TAIL(u,t,h,l) \ +{ \ + (u)->l = (t *)NULL; \ + /* Check for empty chain */ \ + if ((h) == (t *)NULL) { \ + (h) = (u); \ + } else { \ + t *tp; \ + /* Loop until we find the end of chain */ \ + for (tp = (h); tp->l != (t *)NULL; tp = tp->l) \ + ; \ + tp->l = (u); \ + } \ +} + +/* + * Macro to remove a control block from a singly linked chain + * u = control block to unlink + * t = structure type + * h = head of chain + * l = name of link field + */ +#define UNLINK(u,t,h,l) \ +{ \ + /* Check for control block at head of chain */ \ + if ((u) == (h)) { \ + (h) = (u)->l; \ + } else { \ + t *tp; \ + /* Loop until we find the control block */ \ + for (tp = (h); tp != (t *)NULL; tp = tp->l) { \ + if (tp->l == (u)) \ + break; \ + } \ + if (tp) { \ + /* Remove it from chain */ \ + tp->l = (u)->l; \ + } \ + } \ + (u)->l = (t *)NULL; \ +} + +/* + * Macro to remove a control block from a singly linked chain and return + * an indication of whether the block was found + * u = control block to unlink + * t = structure type + * h = head of chain + * l = name of link field + * f = flag; 1 => control block found on chain; else 0 + */ +#define UNLINKF(u,t,h,l,f) \ +{ \ + /* Check for control block at head of chain */ \ + if ((u) == (h)) { \ + (h) = (u)->l; \ + (f) = 1; \ + } else { \ + t *tp; \ + /* Loop until we find the control block */ \ + for (tp = (h); tp != (t *)NULL; tp = tp->l) { \ + if (tp->l == (u)) \ + break; \ + } \ + if (tp) { \ + /* Remove it from chain */ \ + tp->l = (u)->l; \ + (f) = 1; \ + } else \ + /* It wasn't on the chain */ \ + (f) = 0; \ + } \ + (u)->l = (t *)NULL; \ +} + +#endif /* _NETATM_QUEUE_H */ diff --git a/sys/netatm/sigpvc/sigpvc.h b/sys/netatm/sigpvc/sigpvc.h new file mode 100644 index 0000000..893a682 --- /dev/null +++ b/sys/netatm/sigpvc/sigpvc.h @@ -0,0 +1,47 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sigpvc.h,v 1.2 1997/05/06 22:15:43 mks Exp $ + * + */ + +/* + * PVC-only Signalling Manager + * --------------------------- + * + * Protocol definitions + * + */ + +#ifndef _SIGPVC_SIGPVC_H +#define _SIGPVC_SIGPVC_H + +/* + * Protocol Variables + */ +#define SIGPVC_DOWN_DELAY (15 * ATM_HZ) /* Delay til i/f marked down */ +#define SIGPVC_UP_DELAY (5 * ATM_HZ) /* Delay til i/f marked up */ + +#endif /* _SIGPVC_SIGPVC_H */ diff --git a/sys/netatm/sigpvc/sigpvc_if.c b/sys/netatm/sigpvc/sigpvc_if.c new file mode 100644 index 0000000..4208f29 --- /dev/null +++ b/sys/netatm/sigpvc/sigpvc_if.c @@ -0,0 +1,953 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sigpvc_if.c,v 1.13 1998/07/30 22:32:42 mks Exp $ + * + */ + +/* + * PVC-only Signalling Manager + * --------------------------- + * + * External interfaces to SigPVC manager. Includes support for + * running as a loadable kernel module. + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: sigpvc_if.c,v 1.13 1998/07/30 22:32:42 mks Exp $"; +#endif + +#ifndef ATM_SIGPVC_MODULE +#include "opt_atm.h" +#endif + +#include <netatm/kern_include.h> + +#include <netatm/sigpvc/sigpvc.h> +#include <netatm/sigpvc/sigpvc_var.h> + + +/* + * Global variables + */ +struct sp_info sigpvc_vcpool = { + "sigpvc vcc pool", /* si_name */ + sizeof(struct sigpvc_vccb), /* si_blksiz */ + 10, /* si_blkcnt */ + 50 /* si_maxallow */ +}; + +/* + * Local functions + */ +static int sigpvc_start __P((void)); +static int sigpvc_stop __P((void)); +static int sigpvc_attach __P((struct sigmgr *, struct atm_pif *)); +static int sigpvc_detach __P((struct atm_pif *)); +static int sigpvc_setup __P((Atm_connvc *, int *)); +static int sigpvc_release __P((struct vccb *, int *)); +static int sigpvc_free __P((struct vccb *)); +static int sigpvc_ioctl __P((int, caddr_t, caddr_t)); + +/* + * Local variables + */ +static int sigpvc_registered = 0; +static struct sigmgr sigpvc_mgr = { + NULL, + ATM_SIG_PVC, + NULL, + sigpvc_attach, + sigpvc_detach, + sigpvc_setup, + NULL, + NULL, + sigpvc_release, + sigpvc_free, + sigpvc_ioctl +}; + +static struct attr_cause sigpvc_cause = { + T_ATM_PRESENT, + { + T_ATM_ITU_CODING, + T_ATM_LOC_USER, + T_ATM_CAUSE_UNSPECIFIED_NORMAL, + {0, 0, 0, 0} + } +}; + + +/* + * Initialize sigpvc processing + * + * This will be called during module loading. We'll just register + * the sigpvc protocol descriptor and wait for a SigPVC ATM interface + * to come online. + * + * Arguments: + * none + * + * Returns: + * 0 startup was successful + * errno startup failed - reason indicated + * + */ +static int +sigpvc_start() +{ + int err = 0; + + /* + * Verify software version + */ + if (atm_version != ATM_VERSION) { + log(LOG_ERR, "version mismatch: sigpvc=%d.%d kernel=%d.%d\n", + ATM_VERS_MAJ(ATM_VERSION), ATM_VERS_MIN(ATM_VERSION), + ATM_VERS_MAJ(atm_version), ATM_VERS_MIN(atm_version)); + return (EINVAL); + } + + /* + * Register ourselves with system + */ + err = atm_sigmgr_register(&sigpvc_mgr); + if (err == 0) + sigpvc_registered = 1; + + return (err); +} + + +/* + * Halt sigpvc processing + * + * This should be called just prior to unloading the module from + * memory. All sigpvc interfaces must be deregistered before the + * protocol can be shutdown. + * + * Arguments: + * none + * + * Returns: + * 0 shutdown was successful + * errno shutdown failed - reason indicated + * + */ +static int +sigpvc_stop() +{ + int err = 0; + int s = splnet(); + + /* + * Is protocol even setup? + */ + if (sigpvc_registered) { + + /* + * Any protocol instances still registered?? + */ + if (sigpvc_mgr.sm_prinst) { + + /* Yes, can't stop now */ + err = EBUSY; + goto done; + } + + /* + * De-register from system + */ + err = atm_sigmgr_deregister(&sigpvc_mgr); + sigpvc_registered = 0; + + /* + * Free up our vccb storage pool + */ + atm_release_pool(&sigpvc_vcpool); + } else + err = ENXIO; + +done: + (void) splx(s); + return (err); +} + + +/* + * Attach a SigPVC-controlled interface + * + * Each ATM physical interface must be attached with the signalling manager for + * the interface's signalling protocol (via the atm_sigmgr_attach function). + * This function will handle the attachment for SigPVC-controlled interfaces. + * A new sigpvc protocol instance will be created and then we'll just sit + * around waiting for connection requests. + * + * Function must be called at splnet. + * + * Arguments: + * smp pointer to sigpvc signalling manager control block + * pip pointer to atm physical interface control block + * + * Returns: + * 0 attach successful + * errno attach failed - reason indicated + * + */ +static int +sigpvc_attach(smp, pip) + struct sigmgr *smp; + struct atm_pif *pip; +{ + int err = 0; + struct sigpvc *pvp = NULL; + + /* + * Allocate sigpvc protocol instance control block + */ + pvp = (struct sigpvc *) + KM_ALLOC(sizeof(struct sigpvc), M_DEVBUF, M_NOWAIT); + if (pvp == NULL) { + err = ENOMEM; + goto done; + } + KM_ZERO(pvp, sizeof(struct sigpvc)); + + /* + * Link instance into manager's chain + */ + LINK2TAIL((struct siginst *)pvp, struct siginst, + smp->sm_prinst, si_next); + + /* + * Finally, set state and link in interface + */ + pvp->pv_pif = pip; + pvp->pv_state = SIGPVC_ACTIVE; + pip->pif_sigmgr = smp; + pip->pif_siginst = (struct siginst *)pvp; + +done: + /* + * Reset our work if attach fails + */ + if (err) { + pip->pif_sigmgr = NULL; + pip->pif_siginst = NULL; + if (pvp) { + UNLINK((struct siginst *)pvp, struct siginst, + smp->sm_prinst, si_next); + KM_FREE(pvp, sizeof(struct sigpvc), M_DEVBUF); + } + } + + return (err); +} + + +/* + * Detach a SigPVC-controlled interface + * + * Each ATM physical interface may be detached from its signalling manager + * (via the atm_sigmgr_detach function). This function will handle the + * detachment for all SigPVC-controlled interfaces. All circuits will be + * immediately terminated. + * + * Function must be called at splnet. + * + * Arguments: + * pip pointer to atm physical interface control block + * + * Returns: + * 0 detach successful + * errno detach failed - reason indicated + * + */ +static int +sigpvc_detach(pip) + struct atm_pif *pip; +{ + struct sigpvc *pvp; + struct vccb *vcp, *vnext; + + /* + * Get SigPVC protocol instance + */ + pvp = (struct sigpvc *)pip->pif_siginst; + + /* + * Terminate all of our VCCs + */ + for (vcp = Q_HEAD(pvp->pv_vccq, struct vccb); vcp; vcp = vnext){ + u_char oustate; + + vnext = Q_NEXT(vcp, struct vccb, vc_sigelem); + + /* + * Close VCC and notify owner + */ + oustate = vcp->vc_ustate; + sigpvc_close_vcc(vcp); + if (oustate == VCCU_OPEN) { + vcp->vc_connvc->cvc_attr.cause = sigpvc_cause; + atm_cm_cleared(vcp->vc_connvc); + } + } + + /* + * If there are no vcc's queued, then get rid of the protocol + * instance. + */ + if (Q_HEAD(pvp->pv_vccq, struct vccb) == NULL) { + struct sigmgr *smp = pip->pif_sigmgr; + + pip->pif_sigmgr = NULL; + pip->pif_siginst = NULL; + UNLINK((struct siginst *)pvp, struct siginst, smp->sm_prinst, + si_next); + KM_FREE(pvp, sizeof(struct sigpvc), M_DEVBUF); + } else { + + /* + * Otherwise, set new state indicating detach in progress. + * The protocol instance will be freed during sigpvc_free + * processing for the last queued vcc. + */ + pvp->pv_state = SIGPVC_DETACH; + } + + return (0); +} + + +/* + * Open a SigPVC ATM Connection + * + * All service user requests to open a VC connection (via atm_open_connection) + * over an ATM interface attached to the SigPVC signalling manager are handled + * here. Only PVC requests are allowed. + * + * Function will be called at splnet. + * + * Arguments: + * cvp pointer to CM's connection VCC + * errp location to store an error code if CALL_FAILED is returned + * + * Returns: + * CALL_PROCEEDING - connection establishment is in progress + * CALL_FAILED - connection establishment failed + * CALL_CONNECTED - connection has been successfully established + * + */ +static int +sigpvc_setup(cvp, errp) + Atm_connvc *cvp; + int *errp; +{ + struct sigpvc *pvp = + (struct sigpvc *)cvp->cvc_attr.nif->nif_pif->pif_siginst; + int ret; + + /* + * See what signalling has to say + */ + switch (pvp->pv_state) { + + case SIGPVC_ACTIVE: + break; + + default: + *errp = ENXIO; + ret = CALL_FAILED; + goto done; + } + + /* + * Open requested type of connection + */ + switch (cvp->cvc_attr.called.addr.address_format) { + + case T_ATM_PVC_ADDR: + /* + * Create a PVC + */ + ret = sigpvc_create_pvc(pvp, cvp, errp); + break; + + default: + *errp = EPROTONOSUPPORT; + ret = CALL_FAILED; + } + +done: + return (ret); +} + + +/* + * Close a SigPVC ATM Connection + * + * All service user requests to terminate a previously open VC connection + * (via the atm_close_connection function), which is running over an interface + * attached to the SigPVC signalling manager, are handled here. + * + * Function will be called at splnet. + * + * Arguments: + * vcp pointer to connection's VC control block + * errp location to store an error code if CALL_FAILED is returned + * + * Returns: + * CALL_PROCEEDING - connection termination is in progress + * CALL_FAILED - connection termination failed + * CALL_CLEARED - connection has been successfully terminated + * + */ +static int +sigpvc_release(vcp, errp) + struct vccb *vcp; + int *errp; +{ + + /* + * Make sure VCC is open + */ + if ((vcp->vc_sstate == VCCS_NULL) || (vcp->vc_sstate == VCCS_FREE) || + (vcp->vc_ustate == VCCU_NULL) || (vcp->vc_ustate == VCCU_CLOSED)) { + *errp = EALREADY; + return (CALL_FAILED); + } + + /* + * Not much else to do except close the vccb + */ + sigpvc_close_vcc(vcp); + + return (CALL_CLEARED); +} + + +/* + * Free SigPVC ATM Connection Resources + * + * All service user requests to free the resources of a closed VCC connection + * (via the atm_free_connection function), which is running over an interface + * attached to the SigPVC signalling manager, are handled here. + * + * Function will be called at splnet. + * + * Arguments: + * vcp pointer to connection's VCC control block + * + * Returns: + * 0 connection free was successful + * errno connection free failed - reason indicated + * + */ +static int +sigpvc_free(vcp) + struct vccb *vcp; +{ + struct atm_pif *pip = vcp->vc_pif; + struct sigpvc *pvp = (struct sigpvc *)pip->pif_siginst; + + /* + * Make sure VCC has been closed + */ + if ((vcp->vc_ustate != VCCU_CLOSED) || (vcp->vc_sstate != VCCS_FREE)) + return (EEXIST); + + /* + * Remove vccb from protocol queue + */ + DEQUEUE(vcp, struct vccb, vc_sigelem, pvp->pv_vccq); + + /* + * Free vccb storage + */ + vcp->vc_ustate = VCCU_NULL; + vcp->vc_sstate = VCCS_NULL; + atm_free((caddr_t)vcp); + + /* + * If we're detaching and this was the last vcc queued, + * get rid of the protocol instance + */ + if ((pvp->pv_state == SIGPVC_DETACH) && + (Q_HEAD(pvp->pv_vccq, struct vccb) == NULL)) { + struct sigmgr *smp = pip->pif_sigmgr; + + pip->pif_sigmgr = NULL; + pip->pif_siginst = NULL; + UNLINK((struct siginst *)pvp, struct siginst, smp->sm_prinst, + si_next); + KM_FREE(pvp, sizeof(struct sigpvc), M_DEVBUF); + } + + return (0); +} + + +/* + * Process Signalling Manager PF_ATM ioctls + * + * Function will be called at splnet. + * + * Arguments: + * code PF_ATM sub-operation code + * data pointer to code specific parameter data area + * arg1 pointer to code specific argument + * + * Returns: + * 0 request procesed + * errno error processing request - reason indicated + * + */ +static int +sigpvc_ioctl(code, data, arg1) + int code; + caddr_t data; + caddr_t arg1; +{ + struct atmdelreq *adp; + struct atminfreq *aip; + struct air_vcc_rsp avr; + struct sigpvc *pvp; + struct vccb *vcp; + Atm_connection *cop; + caddr_t cp; + u_int vpi, vci; + int i, space, err = 0; + + + switch (code) { + + case AIOCS_DEL_PVC: + /* + * Delete a PVC + */ + adp = (struct atmdelreq *)data; + pvp = (struct sigpvc *)arg1; + + /* + * Find requested VCC + */ + vpi = adp->adr_pvc_vpi; + vci = adp->adr_pvc_vci; + for (vcp = Q_HEAD(pvp->pv_vccq, struct vccb); vcp; + vcp = Q_NEXT(vcp, struct vccb, vc_sigelem)) { + if ((vcp->vc_vpi == vpi) && (vcp->vc_vci == vci)) + break; + } + if (vcp == NULL) + return (ENOENT); + + /* + * Schedule VCC termination + */ + err = atm_cm_abort(vcp->vc_connvc, &sigpvc_cause.v); + break; + + case AIOCS_DEL_SVC: + /* + * Delete a SVC + */ + err = ENOENT; + break; + + case AIOCS_INF_VCC: + /* + * Get VCC information + */ + aip = (struct atminfreq *)data; + pvp = (struct sigpvc *)arg1; + + cp = aip->air_buf_addr; + space = aip->air_buf_len; + + /* + * Get info for all VCCs on interface + */ + for (vcp = Q_HEAD(pvp->pv_vccq, struct vccb); vcp; + vcp = Q_NEXT(vcp, struct vccb, vc_sigelem)) { + /* + * Make sure there's room in user buffer + */ + if (space < sizeof(avr)) { + err = ENOSPC; + break; + } + + /* + * Fill in info to be returned + */ + (void) sprintf(avr.avp_intf, "%s%d", + pvp->pv_pif->pif_name, pvp->pv_pif->pif_unit); + avr.avp_vpi = vcp->vc_vpi; + avr.avp_vci = vcp->vc_vci; + avr.avp_type = vcp->vc_type; + avr.avp_sig_proto = ATM_SIG_PVC; + avr.avp_aal = vcp->vc_connvc->cvc_attr.aal.type; + cop = vcp->vc_connvc->cvc_conn; + if (cop) + avr.avp_encaps = cop->co_mpx; + else + avr.avp_encaps = 0; + KM_ZERO(avr.avp_owners, sizeof(avr.avp_owners)); + for (i = 0; cop && i < sizeof(avr.avp_owners); + cop = cop->co_next, + i += T_ATM_APP_NAME_LEN+1) { + strncpy(&avr.avp_owners[i], + cop->co_endpt->ep_getname(cop->co_toku), + T_ATM_APP_NAME_LEN); + } + avr.avp_state = vcp->vc_sstate; + avr.avp_daddr.address_format = T_ATM_ABSENT; + avr.avp_dsubaddr.address_format = T_ATM_ABSENT; + avr.avp_ipdus = vcp->vc_ipdus; + avr.avp_opdus = vcp->vc_opdus; + avr.avp_ibytes = vcp->vc_ibytes; + avr.avp_obytes = vcp->vc_obytes; + avr.avp_ierrors = vcp->vc_ierrors; + avr.avp_oerrors = vcp->vc_oerrors; + avr.avp_tstamp = vcp->vc_tstamp; + + /* + * Copy data to user buffer and update buffer info + */ + if (err = copyout((caddr_t)&avr, cp, sizeof(avr))) + break; + cp += sizeof(avr); + space -= sizeof(avr); + } + + /* + * Update buffer pointer/count + */ + aip->air_buf_addr = cp; + aip->air_buf_len = space; + break; + + case AIOCS_INF_ARP: + /* + * Get ARP table information + */ + /* We don't maintain any ARP information */ + break; + + default: + err = EOPNOTSUPP; + } + + return (err); +} + + +#ifdef ATM_SIGPVC_MODULE +/* + ******************************************************************* + * + * Loadable Module Support + * + ******************************************************************* + */ +static int sigpvc_doload __P((void)); +static int sigpvc_dounload __P((void)); + +/* + * Generic module load processing + * + * This function is called by an OS-specific function when this + * module is being loaded. + * + * Arguments: + * none + * + * Returns: + * 0 load was successful + * errno load failed - reason indicated + * + */ +static int +sigpvc_doload() +{ + int err = 0; + + /* + * Start us up + */ + err = sigpvc_start(); + if (err) + /* Problems, clean up */ + (void)sigpvc_stop(); + + return (err); +} + + +/* + * Generic module unload processing + * + * This function is called by an OS-specific function when this + * module is being unloaded. + * + * Arguments: + * none + * + * Returns: + * 0 unload was successful + * errno unload failed - reason indicated + * + */ +static int +sigpvc_dounload() +{ + int err = 0; + + /* + * OK, try to clean up our mess + */ + err = sigpvc_stop(); + + return (err); +} + + +#ifdef sun +/* + * Loadable driver description + */ +struct vdldrv sigpvc_drv = { + VDMAGIC_PSEUDO, /* Pseudo Driver */ + "sigpvc_mod", /* name */ + NULL, /* dev_ops */ + NULL, /* bdevsw */ + NULL, /* cdevsw */ + 0, /* blockmajor */ + 0 /* charmajor */ +}; + + +/* + * Loadable module support entry point + * + * This is the routine called by the vd driver for all loadable module + * functions for this pseudo driver. This routine name must be specified + * on the modload(1) command. This routine will be called whenever the + * modload(1), modunload(1) or modstat(1) commands are issued for this + * module. + * + * Arguments: + * cmd vd command code + * vdp pointer to vd driver's structure + * vdi pointer to command-specific vdioctl_* structure + * vds pointer to status structure (VDSTAT only) + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +int +sigpvc_mod(cmd, vdp, vdi, vds) + int cmd; + struct vddrv *vdp; + caddr_t vdi; + struct vdstat *vds; +{ + int err = 0; + + switch (cmd) { + + case VDLOAD: + /* + * Module Load + * + * We dont support any user configuration + */ + err = sigpvc_doload(); + if (err == 0) + /* Let vd driver know about us */ + vdp->vdd_vdtab = (struct vdlinkage *)&sigpvc_drv; + break; + + case VDUNLOAD: + /* + * Module Unload + */ + err = sigpvc_dounload(); + break; + + case VDSTAT: + /* + * Module Status + */ + + /* Not much to say at the moment */ + + break; + + default: + log(LOG_ERR, "sigpvc_mod: Unknown vd command 0x%x\n", cmd); + err = EINVAL; + } + + return (err); +} +#endif /* sun */ + +#ifdef __FreeBSD__ + +#include <sys/exec.h> +#include <sys/sysent.h> +#include <sys/lkm.h> + +/* + * Loadable miscellaneous module description + */ +MOD_MISC(sigpvc); + + +/* + * Loadable module support "load" entry point + * + * This is the routine called by the lkm driver whenever the + * modload(1) command is issued for this module. + * + * Arguments: + * lkmtp pointer to lkm drivers's structure + * cmd lkm command code + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +static int +sigpvc_load(lkmtp, cmd) + struct lkm_table *lkmtp; + int cmd; +{ + return(sigpvc_doload()); +} + + +/* + * Loadable module support "unload" entry point + * + * This is the routine called by the lkm driver whenever the + * modunload(1) command is issued for this module. + * + * Arguments: + * lkmtp pointer to lkm drivers's structure + * cmd lkm command code + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +static int +sigpvc_unload(lkmtp, cmd) + struct lkm_table *lkmtp; + int cmd; +{ + return(sigpvc_dounload()); +} + + +/* + * Loadable module support entry point + * + * This is the routine called by the lkm driver for all loadable module + * functions for this driver. This routine name must be specified + * on the modload(1) command. This routine will be called whenever the + * modload(1), modunload(1) or modstat(1) commands are issued for this + * module. + * + * Arguments: + * lkmtp pointer to lkm drivers's structure + * cmd lkm command code + * ver lkm version + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +int +sigpvc_mod(lkmtp, cmd, ver) + struct lkm_table *lkmtp; + int cmd; + int ver; +{ + MOD_DISPATCH(sigpvc, lkmtp, cmd, ver, + sigpvc_load, sigpvc_unload, lkm_nullcmd); +} +#endif /* __FreeBSD__ */ + +#else /* !ATM_SIGPVC_MODULE */ + +/* + ******************************************************************* + * + * Kernel Compiled Module Support + * + ******************************************************************* + */ +static void sigpvc_doload __P((void *)); + +SYSINIT(atmsigpvc, SI_SUB_PROTO_END, SI_ORDER_ANY, sigpvc_doload, NULL) + +/* + * Kernel initialization + * + * Arguments: + * arg Not used + * + * Returns: + * none + * + */ +static void +sigpvc_doload(void *arg) +{ + int err = 0; + + /* + * Start us up + */ + err = sigpvc_start(); + if (err) { + /* Problems, clean up */ + (void)sigpvc_stop(); + + log(LOG_ERR, "ATM SIGPVC unable to initialize (%d)!!\n", err); + } + return; +} +#endif /* ATM_SIGPVC_MODULE */ + diff --git a/sys/netatm/sigpvc/sigpvc_subr.c b/sys/netatm/sigpvc/sigpvc_subr.c new file mode 100644 index 0000000..00f92ec --- /dev/null +++ b/sys/netatm/sigpvc/sigpvc_subr.c @@ -0,0 +1,181 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sigpvc_subr.c,v 1.7 1998/06/29 21:52:25 mks Exp $ + * + */ + +/* + * PVC-only Signalling Manager + * --------------------------- + * + * Subroutines + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: sigpvc_subr.c,v 1.7 1998/06/29 21:52:25 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/sigpvc/sigpvc.h> +#include <netatm/sigpvc/sigpvc_var.h> + +extern struct sp_info sigpvc_vcpool; + +/* + * Create a SigPVC Permanent Virtual Channel + * + * This function will construct a vccb for a "sigpvc-controlled" PVC + * and create the service stack requested by the user. + * + * Must be called at splnet. + * + * Arguments: + * pvp pointer to sigpvc protocol instance + * cvp pointer to CM's connection VCC + * errp location to store an error code if CALL_FAILED is returned + * + * Returns: + * CALL_FAILED - pvc creation failed + * CALL_CONNECTED - pvc has been successfully created + * + */ +int +sigpvc_create_pvc(pvp, cvp, errp) + struct sigpvc *pvp; + Atm_connvc *cvp; + int *errp; +{ + Atm_addr_pvc *pp; + struct vccb *vcp; + u_int vpi, vci; + + pp = (Atm_addr_pvc *)cvp->cvc_attr.called.addr.address; + vpi = ATM_PVC_GET_VPI(pp); + vci = ATM_PVC_GET_VCI(pp); + + /* + * Verify requested VPI,VCI + */ + if ((vpi > pvp->pv_pif->pif_maxvpi) || + (vci == 0) || (vci > pvp->pv_pif->pif_maxvci)) { + *errp = ERANGE; + return (CALL_FAILED); + } + + for (vcp = Q_HEAD(pvp->pv_vccq, struct vccb); vcp; + vcp = Q_NEXT(vcp, struct vccb, vc_sigelem)) { + + if ((vcp->vc_vpi == vpi) && + (vcp->vc_vci == vci)) { + *errp = EADDRINUSE; + return (CALL_FAILED); + } + } + + /* + * Verify network interface + */ + if (cvp->cvc_attr.nif) { + if (cvp->cvc_attr.nif->nif_pif != pvp->pv_pif) { + *errp = EINVAL; + return (CALL_FAILED); + } + } + + /* + * Allocate control block for PVC + */ + vcp = (struct vccb *)atm_allocate(&sigpvc_vcpool); + if (vcp == NULL) { + *errp = ENOMEM; + return (CALL_FAILED); + } + + /* + * Fill in VCCB + */ + vcp->vc_type = VCC_PVC | VCC_IN | VCC_OUT; + vcp->vc_proto = ATM_SIG_PVC; + vcp->vc_sstate = VCCS_ACTIVE; + vcp->vc_ustate = VCCU_OPEN; + vcp->vc_pif = pvp->pv_pif; + vcp->vc_nif = cvp->cvc_attr.nif; + vcp->vc_vpi = vpi; + vcp->vc_vci = vci; + vcp->vc_connvc = cvp; + + /* + * Put VCCB on sigpvc queue + */ + ENQUEUE(vcp, struct vccb, vc_sigelem, pvp->pv_vccq); + + /* + * Pass back VCCB to connection manager + */ + cvp->cvc_vcc = vcp; + + /* + * PVC is ready to go! + */ + return (CALL_CONNECTED); +} + +/* + * Close a SigPVC VCC + * + * Clean up vccb, note that it's closing and wait for its freeing. + * + * Arguments: + * vcp pointer to connection's VCC control block + * + * Returns: + * none + * + */ +void +sigpvc_close_vcc(vcp) + struct vccb *vcp; +{ + + /* + * Sanity check (actually design-flaw check) + */ + if (vcp->vc_connvc->cvc_upcnt || vcp->vc_connvc->cvc_downcnt) + panic("sigpvc_close_vcc: stack call"); + + /* + * Set state variables + */ + vcp->vc_ustate = VCCU_CLOSED; + vcp->vc_sstate = VCCS_FREE; + + /* + * Wait for user to free resources + */ +} + diff --git a/sys/netatm/sigpvc/sigpvc_var.h b/sys/netatm/sigpvc/sigpvc_var.h new file mode 100644 index 0000000..24f92c0 --- /dev/null +++ b/sys/netatm/sigpvc/sigpvc_var.h @@ -0,0 +1,95 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sigpvc_var.h,v 1.5 1998/02/19 20:16:28 mks Exp $ + * + */ + +/* + * PVC-only Signalling Manager + * --------------------------- + * + * Protocol control blocks + * + */ + +#ifndef _SIGPVC_SIGPVC_VAR_H +#define _SIGPVC_SIGPVC_VAR_H + +#ifdef ATM_KERNEL +/* + * Structure containing state information for each SigPVC protocol instance. + * There will be one instance for each ATM device interface using the SigPVC + * signalling manager. + */ +struct sigpvc { + struct siginst pv_inst; /* Common header */ +}; +#define pv_next pv_inst.si_next +#define pv_pif pv_inst.si_pif +#define pv_addr pv_inst.si_addr +#define pv_vccq pv_inst.si_vccq +#define pv_state pv_inst.si_state +#endif /* ATM_KERNEL */ + +/* + * SigPVC Protocol States + */ +#define SIGPVC_ACTIVE 1 /* Active */ +#define SIGPVC_DETACH 2 /* Detach in progress */ + + +#ifdef ATM_KERNEL +/* + * SigPVC Virtual Channel Connection control block. All information regarding + * the state of a SigPVC controlled VCC will be recorded here. There will be + * one SigPVC VCC control block for each SigPVC-controlled VCC. + */ +struct sigpvc_vccb { + struct vccb vcp_hdr; /* Generic vccb */ +}; +#endif /* ATM_KERNEL */ + +/* + * SigPVC VCC Signalling Protocol States + */ +#define VCCS_NULL 0 /* No state */ +#define VCCS_ACTIVE 1 /* Active */ +#define VCCS_FREE 2 /* Waiting for user to free resources */ + + +#ifdef ATM_KERNEL +/* + * Global function declarations + */ + /* sigpvc_if.c */ + + /* sigpvc_subr.c */ +int sigpvc_create_pvc __P((struct sigpvc *, Atm_connvc *, int *)); +void sigpvc_close_vcc __P((struct vccb *)); + +#endif /* ATM_KERNEL */ + +#endif /* _SIGPVC_SIGPVC_VAR_H */ diff --git a/sys/netatm/spans/spans_arp.c b/sys/netatm/spans/spans_arp.c new file mode 100644 index 0000000..5a2443a --- /dev/null +++ b/sys/netatm/spans/spans_arp.c @@ -0,0 +1,1133 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: spans_arp.c,v 1.9 1998/06/29 22:03:12 mks Exp $ + * + */ + +/* + * SPANS Signalling Manager + * --------------------------- + * + * SPANS CLS - ARP support + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: spans_arp.c,v 1.9 1998/06/29 22:03:12 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> +#include "spans_xdr.h" +#include <netatm/spans/spans_var.h> +#include <netatm/spans/spans_cls.h> + + +/* + * Global variables + */ +struct spansarp *spansarp_arptab[SPANSARP_HASHSIZ] = {NULL}; + + +/* + * Local functions + */ +static int spansarp_request __P((struct spansarp *)); +static void spansarp_aging __P((struct atm_time *)); +static void spansarp_retry __P((struct atm_time *)); + +/* + * Local variables + */ +static struct atm_time spansarp_timer = {0, 0}; /* Aging timer */ +static struct atm_time spansarp_rtimer = {0, 0}; /* Retry timer */ + +static struct spansarp *spansarp_retry_head = NULL; /* Retry chain */ + +static struct sp_info spansarp_pool = { + "spans arp pool", /* si_name */ + sizeof(struct spansarp), /* si_blksiz */ + 10, /* si_blkcnt */ + 100 /* si_maxallow */ +}; + + +/* + * Process a new outgoing SVC requiring SPANS ARP support + * + * This function is called by an endpoint wishing to resolve a destination + * IP address to an ATM address in order to open an SVC to that destination. + * If a valid mapping is already in our cache, then we just tell the caller + * about it and that's that. Otherwise, we have to allocate a new arp entry + * and issue a query for the mapping. + * + * Arguments: + * ivp pointer to SVC's IPVCC control block + * dst pointer to destination IP address + * + * Returns: + * MAP_VALID - Got the answer, returned via iv_arpent field. + * MAP_PROCEEDING - OK so far, querying for peer's mapping + * MAP_FAILED - error, unable to allocate resources + * + */ +int +spansarp_svcout(ivp, dst) + struct ipvcc *ivp; + struct in_addr *dst; +{ + struct spanscls *clp; + struct spansarp *sap; + int s; + + ivp->iv_arpent = NULL; + + /* + * Lookup destination address + */ + s = splnet(); + SPANSARP_LOOKUP(dst->s_addr, sap); + + if (sap) { + /* + * Link this vcc to entry queue + */ + LINK2TAIL(ivp, struct ipvcc, sap->sa_ivp, iv_arpnext); + + /* + * If entry is valid, we're done + */ + if (sap->sa_flags & SAF_VALID) { + ivp->iv_arpent = (struct arpmap *)sap; + (void) splx(s); + return (MAP_VALID); + } + + /* + * We're already looking for this address + */ + (void) splx(s); + return (MAP_PROCEEDING); + } + + /* + * Need a new arp entry - first, find the cls instance + * corresponding to the requestor's IP interface. + */ + for (clp = spanscls_head; clp; clp = clp->cls_next) { + if (clp->cls_ipnif == ivp->iv_ipnif) + break; + } + if (clp == NULL) { + (void) splx(s); + return (MAP_FAILED); + } + + /* + * Now get the new arp entry + */ + sap = (struct spansarp *)atm_allocate(&spansarp_pool); + if (sap == NULL) { + (void) splx(s); + return (MAP_FAILED); + } + + /* + * Get entry set up + */ + sap->sa_dstip.s_addr = dst->s_addr; + sap->sa_dstatm.address_format = T_ATM_ABSENT; + sap->sa_dstatm.address_length = 0; + sap->sa_dstatmsub.address_format = T_ATM_ABSENT; + sap->sa_dstatmsub.address_length = 0; + sap->sa_cls = clp; + sap->sa_origin = SAO_LOOKUP; + + /* + * Link ipvcc to arp entry for later notification + */ + LINK2TAIL(ivp, struct ipvcc, sap->sa_ivp, iv_arpnext); + + /* + * Add arp entry to table + */ + SPANSARP_ADD(sap); + + /* + * Add arp entry to retry list and start retry timer if needed + */ + LINK2TAIL(sap, struct spansarp, spansarp_retry_head, sa_rnext); + if ((spansarp_rtimer.ti_flag & TIF_QUEUED) == 0) + atm_timeout(&spansarp_rtimer, SPANSARP_RETRY, spansarp_retry); + + /* + * Issue arp request for this address + */ + (void) spansarp_request(sap); + + (void) splx(s); + return (MAP_PROCEEDING); +} + + +/* + * Process a new incoming SVC requiring SPANS ARP support + * + * This function is called by an endpoint wishing to resolve a destination + * ATM address to its IP address for an incoming call in order to allow a + * bi-directional flow of IP packets on the SVC. + * + * SPANS ARP does not provide reverse mapping facilities and only supports + * uni-directional SVCs. Thus, we lie a little to IP and always return a + * MAP_PROCEEDING indication, but we will never later notify IP of a + * MAP_VALID condition. + * + * Arguments: + * ivp pointer to SVC's IPVCC control block + * dst pointer to destination ATM address + * dstsub pointer to destination ATM subaddress + * + * Returns: + * MAP_VALID - Got the answer, returned via iv_arpent field. + * MAP_PROCEEDING - OK so far, querying for peer's mapping + * MAP_FAILED - error, unable to allocate resources + * + */ +int +spansarp_svcin(ivp, dst, dstsub) + struct ipvcc *ivp; + Atm_addr *dst; + Atm_addr *dstsub; +{ + /* + * Clear ARP entry field + */ + ivp->iv_arpent = NULL; + + return (MAP_PROCEEDING); +} + + +/* + * SPANS ARP SVC activation notification + * + * This function is called when a previously opened SVC has successfully + * been connected. + * + * Arguments: + * ivp pointer to SVC's IPVCC control block + * + * Returns: + * 0 activation processing successful + * errno activation failed - reason indicated + * + */ +int +spansarp_svcactive(ivp) + struct ipvcc *ivp; +{ + struct spansarp *sap; + int s = splnet(); + + /* + * Find an entry for the destination address + */ + SPANSARP_LOOKUP(ivp->iv_dst.s_addr, sap); + if (sap) { + /* + * IP is finished with entry, so remove IP VCC from chain + */ + UNLINK(ivp, struct ipvcc, sap->sa_ivp, iv_arpnext); + ivp->iv_arpent = NULL; + + /* + * This seems like a reasonable reason to refresh the entry + */ + sap->sa_reftime = 0; + } + + (void) splx(s); + return (0); +} + + +/* + * SPANS ARP supported VCC is closing + * + * This function is called just prior to a user closing a VCC which + * supports SPANS ARP. We'll sever our links to the VCC and then + * figure out how much more cleanup we need to do for now. + * + * Arguments: + * ivp pointer to VCC's IPVCC control block + * + * Returns: + * none + * + */ +void +spansarp_vcclose(ivp) + struct ipvcc *ivp; +{ + struct spansarp *sap; + int s = splnet(); + + /* + * Get spansarp entry + */ + SPANSARP_LOOKUP(ivp->iv_dst.s_addr, sap); + if (sap == NULL) { + (void) splx(s); + return; + } + + /* + * Remove IP VCC from chain + */ + UNLINK(ivp, struct ipvcc, sap->sa_ivp, iv_arpnext); + ivp->iv_arpent = NULL; + + /* + * If entry is currently valid or in use, not much else for us to do + */ + if ((sap->sa_flags & (SAF_VALID | SAF_LOCKED)) || + (sap->sa_origin >= SAO_PERM)) { + (void) splx(s); + return; + } + + /* + * If there are still other VCCs waiting, exit + */ + if (sap->sa_ivp) { + (void) splx(s); + return; + } + + /* + * Noone else waiting, so remove entry from the retry chain + */ + UNLINK(sap, struct spansarp, spansarp_retry_head, sa_rnext); + + /* + * Free entry + */ + SPANSARP_DELETE(sap); + atm_free((caddr_t)sap); + (void) splx(s); +} + + +/* + * Process module unloading notification + * + * Called whenever the spans module is about to be unloaded. All signalling + * instances will have been previously detached. All spansarp resources + * must be freed now. + * + * Arguments: + * none + * + * Returns: + * none + * + */ +void +spansarp_stop() +{ + int i; + + /* + * Make sure the arp table is empty + */ + for (i = 0; i < SPANSARP_HASHSIZ; i++) { + if (spansarp_arptab[i] != NULL) + panic("spansarp_stop: arp table not empty"); + } + + /* + * Cancel timers + */ + (void) atm_untimeout(&spansarp_timer); + (void) atm_untimeout(&spansarp_rtimer); + + /* + * Free our storage pools + */ + atm_release_pool(&spansarp_pool); +} + + +/* + * Process IP Network Interface Activation + * + * Called whenever an IP network interface becomes active. + * + * Called at splnet. + * + * Arguments: + * clp pointer to CLS interface + * + * Returns: + * none + * + */ +void +spansarp_ipact(clp) + struct spanscls *clp; +{ + /* + * Make sure aging timer is running + */ + if ((spansarp_timer.ti_flag & TIF_QUEUED) == 0) + atm_timeout(&spansarp_timer, SPANSARP_AGING, spansarp_aging); +} + + +/* + * Process IP Network Interface Deactivation + * + * Called whenever an IP network interface becomes inactive. + * + * Called at splnet. + * + * Arguments: + * clp pointer to CLS interface + * + * Returns: + * none + * + */ +void +spansarp_ipdact(clp) + struct spanscls *clp; +{ + struct spanscls *clp2; + struct spansarp *sap, *snext; + int i; + + /* + * Delete all interface entries + */ + for (i = 0; i < SPANSARP_HASHSIZ; i++) { + for (sap = spansarp_arptab[i]; sap; sap = snext) { + snext = sap->sa_next; + + /* + * Clean up entries for this interface + */ + if (sap->sa_cls != clp) + continue; + + /* + * All VCCs better be gone by now + */ + if (sap->sa_ivp) + panic("spansarp_ipdact: entry not empty"); + + /* + * Remove entry from the retry chain + */ + UNLINK(sap, struct spansarp, + spansarp_retry_head, sa_rnext); + + /* + * Delete entry from arp table + */ + SPANSARP_DELETE(sap); + atm_free((caddr_t)sap); + } + } + + /* + * Stop aging timer if this is the last active interface + */ + for (clp2 = spanscls_head; clp2; clp2 = clp2->cls_next) { + if ((clp != clp2) && (clp2->cls_ipnif)) + break; + } + if (clp2 == NULL) + (void) atm_untimeout(&spansarp_timer); +} + + +/* + * Issue a SPANS ARP request packet + * + * Arguments: + * sap pointer to arp table entry + * + * Returns: + * 0 packet was successfully sent + * else unable to send packet + * + */ +static int +spansarp_request(sap) + struct spansarp *sap; +{ + struct spanscls *clp; + struct spans *spp; + struct spanscls_hdr *chp; + struct spansarp_hdr *ahp; + KBuffer *m; + struct ip_nif *inp; + int err; + + clp = sap->sa_cls; + spp = clp->cls_spans; + inp = clp->cls_ipnif; + + /* + * Make sure CLS VCC is open and that we know our addresses + */ + if (clp->cls_state != CLS_OPEN) + return (1); + if (spp->sp_addr.address_format != T_ATM_SPANS_ADDR) + return (1); + if (inp == NULL) + return (1); + + /* + * Get a buffer for pdu + */ + KB_ALLOCPKT(m, ARP_PACKET_LEN, KB_F_NOWAIT, KB_T_DATA); + if (m == NULL) + return (1); + + /* + * Place pdu at end of buffer + */ + KB_PLENSET(m, ARP_PACKET_LEN); + KB_TAILALIGN(m, ARP_PACKET_LEN); + KB_DATASTART(m, chp, struct spanscls_hdr *); + ahp = (struct spansarp_hdr *)(chp + 1); + + /* + * Build headers + */ + spans_addr_copy(&spans_bcastaddr, &chp->ch_dst); + spans_addr_copy(spp->sp_addr.address, &chp->ch_src); + *(u_int *)&chp->ch_proto = *(u_int *)&spanscls_hdr.ch_proto; + *(u_int *)&chp->ch_dsap = *(u_int *)&spanscls_hdr.ch_dsap; + *(u_short *)&chp->ch_oui[1] = *(u_short *)&spanscls_hdr.ch_oui[1]; + chp->ch_pid = htons(ETHERTYPE_ARP); + + + /* + * Build ARP packet + */ + ahp->ah_hrd = htons(ARP_SPANS); + ahp->ah_pro = htons(ETHERTYPE_IP); + ahp->ah_hln = sizeof(spans_addr); + ahp->ah_pln = sizeof(struct in_addr); + ahp->ah_op = htons(ARP_REQUEST); + spans_addr_copy(spp->sp_addr.address, &ahp->ah_sha); + KM_COPY(&(IA_SIN(inp->inf_addr)->sin_addr), ahp->ah_spa, + sizeof(struct in_addr)); + KM_COPY(&sap->sa_dstip, ahp->ah_tpa, sizeof(struct in_addr)); + + /* + * Now, send the pdu via the CLS service + */ + err = atm_cm_cpcs_data(clp->cls_conn, m); + if (err) { + KB_FREEALL(m); + return (1); + } + + return (0); +} + + +/* + * Process a SPANS ARP input packet + * + * Arguments: + * clp pointer to interface CLS control block + * m pointer to input packet buffer chain + * + * Returns: + * none + * + */ +void +spansarp_input(clp, m) + struct spanscls *clp; + KBuffer *m; +{ + struct spans *spp = clp->cls_spans; + struct spanscls_hdr *chp; + struct spansarp_hdr *ahp; + struct spansarp *sap; + struct ip_nif *inp = clp->cls_ipnif; + struct in_addr in_me, in_src, in_targ; + int s, err; + + /* + * Make sure IP interface has been activated + */ + if (inp == NULL) + goto free; + + /* + * Get the packet together + */ + if (KB_LEN(m) < ARP_PACKET_LEN) { + KB_PULLUP(m, ARP_PACKET_LEN, m); + if (m == 0) + return; + } + KB_DATASTART(m, chp, struct spanscls_hdr *); + ahp = (struct spansarp_hdr *)(chp + 1); + + KM_COPY(ahp->ah_spa, &in_src, sizeof(struct in_addr)); + KM_COPY(ahp->ah_tpa, &in_targ, sizeof(struct in_addr)); + KM_COPY(&(IA_SIN(inp->inf_addr)->sin_addr), &in_me, + sizeof(struct in_addr)); + + /* + * Initial packet verification + */ + if ((ahp->ah_hrd != htons(ARP_SPANS)) || + (ahp->ah_pro != htons(ETHERTYPE_IP))) + goto free; + + /* + * Validate source addresses + * can't be from broadcast + * can't be from me + */ + if (!spans_addr_cmp(&ahp->ah_sha, &spans_bcastaddr)) + goto free; +#if (defined(BSD) && (BSD >= 199306)) + if (in_broadcast(in_src, &inp->inf_nif->nif_if)) +#else + if (in_broadcast(in_src)) +#endif + goto free; + if (!spans_addr_cmp(&ahp->ah_sha, spp->sp_addr.address)) + goto free; + if (in_src.s_addr == in_me.s_addr) { + log(LOG_ERR, + "duplicate IP address sent from spans address %s\n", + spans_addr_print(&ahp->ah_sha)); + in_targ = in_me; + goto chkop; + } + + /* + * Update arp table with source address info + */ + s = splnet(); + SPANSARP_LOOKUP(in_src.s_addr, sap); + if (sap) { + /* + * Found an entry for the source, but don't + * update permanent entries + */ + if (sap->sa_origin != SAO_PERM) { + + /* + * Update the entry + */ + sap->sa_dstatm.address_format = T_ATM_SPANS_ADDR; + sap->sa_dstatm.address_length = sizeof(spans_addr); + spans_addr_copy(&ahp->ah_sha, sap->sa_dstatm.address); + sap->sa_cls = clp; + sap->sa_reftime = 0; + if ((sap->sa_flags & SAF_VALID) == 0) { + /* + * Newly valid entry, notify waiting users + */ + struct ipvcc *ivp, *inext; + + sap->sa_flags |= SAF_VALID; + for (ivp = sap->sa_ivp; ivp; ivp = inext) { + inext = ivp->iv_arpnext; + + ivp->iv_arpent = (struct arpmap *)sap; + (*inp->inf_arpnotify)(ivp, MAP_VALID); + } + + /* + * Remove ourselves from the retry chain + */ + UNLINK(sap, struct spansarp, + spansarp_retry_head, sa_rnext); + } + } + + } else if (in_targ.s_addr == in_me.s_addr) { + /* + * Source unknown and we're the target - add new entry + */ + sap = (struct spansarp *)atm_allocate(&spansarp_pool); + if (sap) { + sap->sa_dstip.s_addr = in_src.s_addr; + sap->sa_dstatm.address_format = T_ATM_SPANS_ADDR; + sap->sa_dstatm.address_length = sizeof(spans_addr); + spans_addr_copy(&ahp->ah_sha, sap->sa_dstatm.address); + sap->sa_dstatmsub.address_format = T_ATM_ABSENT; + sap->sa_dstatmsub.address_length = 0; + sap->sa_cls = clp; + sap->sa_flags = SAF_VALID; + sap->sa_origin = SAO_LOOKUP; + SPANSARP_ADD(sap); + } + } + (void) splx(s); + +chkop: + /* + * If this is a request for our address, send a reply + */ + if (ntohs(ahp->ah_op) != ARP_REQUEST) + goto free; + if (in_targ.s_addr != in_me.s_addr) + goto free; + + spans_addr_copy(&chp->ch_src, &chp->ch_dst); + spans_addr_copy(spp->sp_addr.address, &chp->ch_src); + ahp->ah_op = htons(ARP_REPLY); + spans_addr_copy(&ahp->ah_sha, &ahp->ah_tha); + spans_addr_copy(spp->sp_addr.address, &ahp->ah_sha); + KM_COPY(ahp->ah_spa, ahp->ah_tpa, sizeof(struct in_addr)); + KM_COPY(&in_me, ahp->ah_spa, sizeof(struct in_addr)); + + err = atm_cm_cpcs_data(clp->cls_conn, m); + if (err) + goto free; + return; + +free: + KB_FREEALL(m); +} + + +/* + * Process a SPANS ARP aging timer tick + * + * This function is called every SPANSARP_AGING seconds, in order to age + * all the arp table entries. + * + * Called at splnet. + * + * Arguments: + * tip pointer to spansarp aging timer control block + * + * Returns: + * none + * + */ +static void +spansarp_aging(tip) + struct atm_time *tip; +{ + struct spansarp *sap, *snext; + struct ipvcc *ivp, *inext; + int i; + + + /* + * Schedule next timeout + */ + atm_timeout(&spansarp_timer, SPANSARP_AGING, spansarp_aging); + + /* + * Run through arp table bumping each entry's aging timer. + */ + for (i = 0; i < SPANSARP_HASHSIZ; i++) { + for (sap = spansarp_arptab[i]; sap; sap = snext) { + snext = sap->sa_next; + + /* + * Permanent (manually installed) entries aren't aged + */ + if (sap->sa_origin == SAO_PERM) + continue; + + /* + * See if entry is valid and over-aged + */ + if ((sap->sa_flags & SAF_VALID) == 0) + continue; + if (++sap->sa_reftime < SPANSARP_MAXAGE) + continue; + + /* + * Entry is now invalid, tell IP/ATM about it + */ + sap->sa_flags |= SAF_LOCKED; + for (ivp = sap->sa_ivp; ivp; ivp = inext) { + inext = ivp->iv_arpnext; + (*ivp->iv_ipnif->inf_arpnotify) + (ivp, MAP_INVALID); + } + sap->sa_flags &= ~(SAF_LOCKED | SAF_VALID); + + if (sap->sa_ivp != NULL) { + /* + * Somebody still cares, so add the arp + * entry to the retry list. + */ + LINK2TAIL(sap, struct spansarp, + spansarp_retry_head, sa_rnext); + if ((spansarp_rtimer.ti_flag & TIF_QUEUED) == 0) + atm_timeout(&spansarp_rtimer, + SPANSARP_RETRY, spansarp_retry); + + /* + * Issue arp request for this address + */ + (void) spansarp_request(sap); + + } else { + /* + * Delete unused entry + */ + SPANSARP_DELETE(sap); + atm_free((caddr_t)sap); + } + } + } +} + + +/* + * Process a SPANS ARP retry timer tick + * + * This function is called every SPANSARP_RETRY seconds, in order to retry + * awaiting arp resolution requests. We will retry requests indefinitely, + * assuming that IP will set a timeout to close the VCC(s) requesting the + * failing address resolution. + * + * Called at splnet. + * + * Arguments: + * tip pointer to spansarp retry timer control block + * + * Returns: + * none + * + */ +static void +spansarp_retry(tip) + struct atm_time *tip; +{ + struct spansarp *sap; + + + /* + * See if there's work to do + */ + if (spansarp_retry_head == NULL) { + return; + } + + /* + * Schedule next timeout + */ + atm_timeout(&spansarp_rtimer, SPANSARP_RETRY, spansarp_retry); + + /* + * Run through retry chain, (re)issuing arp requests. + */ + for (sap = spansarp_retry_head; sap; sap = sap->sa_next) { + + /* + * Send another arp request + */ + (void) spansarp_request(sap); + } +} + + +/* + * SPANS ARP IOCTL support + * + * Function will be called at splnet. + * + * Arguments: + * code PF_ATM sub-operation code + * data pointer to code specific parameter data area + * arg1 pointer to code specific argument + * + * Returns: + * 0 request procesed + * errno error processing request - reason indicated + * + */ +int +spansarp_ioctl(code, data, arg1) + int code; + caddr_t data; + caddr_t arg1; +{ + struct atmaddreq *aap; + struct atmdelreq *adp; + struct atminfreq *aip; + struct spans *spp; + struct spanscls *clp; + struct spansarp *sap; + struct air_arp_rsp aar; + struct ip_nif *inp; + struct ipvcc *ivp, *inext; + struct in_addr ip; + u_long dst; + int err = 0, i, buf_len; + caddr_t buf_addr; + + + switch (code) { + + case AIOCS_ADD_ARP: + /* + * Add a permanent ARP mapping + */ + aap = (struct atmaddreq *)data; + clp = (struct spanscls *)arg1; + inp = clp->cls_ipnif; + if ((aap->aar_arp_addr.address_format != T_ATM_SPANS_ADDR) || + (aap->aar_arp_origin != ARP_ORIG_PERM)) { + err = EINVAL; + break; + } + ip = SATOSIN(&aap->aar_arp_dst)->sin_addr; + + /* + * See if we already have an entry for this IP address + */ + SPANSARP_LOOKUP(ip.s_addr, sap); + if (sap == NULL) { + /* + * No, get a new arp entry + */ + sap = (struct spansarp *)atm_allocate(&spansarp_pool); + if (sap == NULL) { + err = ENOMEM; + break; + } + + /* + * Get entry set up + */ + sap->sa_dstip = ip; + ATM_ADDR_COPY(&aap->aar_arp_addr, &sap->sa_dstatm); + sap->sa_dstatmsub.address_format = T_ATM_ABSENT; + sap->sa_dstatmsub.address_length = 0; + sap->sa_cls = clp; + sap->sa_flags |= SAF_VALID; + sap->sa_origin = SAO_PERM; + + /* + * Add entry to table + */ + SPANSARP_ADD(sap); + break; + + } + + /* + * See if we're attempting to change the ATM address for + * this cached entry + */ + if ((sap->sa_dstatm.address_format != T_ATM_ABSENT) && + (!ATM_ADDR_EQUAL(&aap->aar_arp_addr, &sap->sa_dstatm) || + (clp != sap->sa_cls))) { + + /* + * Yes, notify IP/ATM that a mapping change has + * occurred. IP/ATM will close any VCC's which + * aren't waiting for this map. + */ + sap->sa_flags |= SAF_LOCKED; + for (ivp = sap->sa_ivp; ivp; ivp = inext) { + inext = ivp->iv_arpnext; + (*inp->inf_arpnotify)(ivp, MAP_CHANGED); + } + sap->sa_flags &= ~SAF_LOCKED; + } + + /* + * Update the cached entry with the new data + */ + ATM_ADDR_COPY(&aap->aar_arp_addr, &sap->sa_dstatm); + sap->sa_cls = clp; + + /* + * If this entry isn't valid, notify anyone who might + * be interested + */ + if ((sap->sa_flags & SAF_VALID) == 0) { + + sap->sa_flags |= SAF_LOCKED; + for (ivp = sap->sa_ivp; ivp; ivp = inext) { + inext = ivp->iv_arpnext; + (*inp->inf_arpnotify)(ivp, MAP_VALID); + } + sap->sa_flags &= ~SAF_LOCKED; + } + + /* + * Remove this entry from the retry chain + */ + UNLINK(sap, struct spansarp, spansarp_retry_head, sa_rnext); + + /* + * Mark the entry as permanent + */ + sap->sa_flags |= SAF_VALID; + sap->sa_origin = SAO_PERM; + break; + + case AIOCS_DEL_ARP: + /* + * Delete an ARP mapping + */ + adp = (struct atmdelreq *)data; + clp = (struct spanscls *)arg1; + ip = SATOSIN(&adp->adr_arp_dst)->sin_addr; + + /* + * Now find the entry to be deleted + */ + SPANSARP_LOOKUP(ip.s_addr, sap); + if (sap == NULL) { + err = ENOENT; + break; + } + + /* + * Notify all VCCs using this entry that they must finish + * up now. + */ + sap->sa_flags |= SAF_LOCKED; + for (ivp = sap->sa_ivp; ivp; ivp = inext) { + inext = ivp->iv_arpnext; + (*ivp->iv_ipnif->inf_arpnotify)(ivp, MAP_FAILED); + } + + /* + * Now free up the entry + */ + UNLINK(sap, struct spansarp, spansarp_retry_head, sa_rnext); + SPANSARP_DELETE(sap); + atm_free((caddr_t)sap); + break; + + case AIOCS_INF_ARP: + /* + * Get ARP table information + */ + aip = (struct atminfreq *)data; + spp = (struct spans *)arg1; + + if (aip->air_arp_addr.sa_family != AF_INET) + break; + dst = SATOSIN(&aip->air_arp_addr)->sin_addr.s_addr; + + buf_addr = aip->air_buf_addr; + buf_len = aip->air_buf_len; + + if ((clp = spp->sp_cls) == NULL) + break; + + /* + * Run through entire arp table + */ + for (i = 0; i < SPANSARP_HASHSIZ; i++) { + for (sap = spansarp_arptab[i]; sap; + sap = sap->sa_next) { + /* + * We only want entries learned + * from the supplied interface. + */ + if (sap->sa_cls != clp) + continue; + if ((dst != INADDR_ANY) && + (dst != sap->sa_dstip.s_addr)) + continue; + + /* + * Make sure there's room in the user's buffer + */ + if (buf_len < sizeof(aar)) { + err = ENOSPC; + break; + } + + /* + * Fill in info to be returned + */ + SATOSIN(&aar.aap_arp_addr)->sin_family = + AF_INET; + SATOSIN(&aar.aap_arp_addr)->sin_addr.s_addr = + sap->sa_dstip.s_addr; + (void) sprintf(aar.aap_intf, "%s%d", + clp->cls_ipnif->inf_nif->nif_if.if_name, + clp->cls_ipnif->inf_nif->nif_if.if_unit + ); + aar.aap_flags = sap->sa_flags; + aar.aap_origin = sap->sa_origin; + if (sap->sa_flags & SAF_VALID) + aar.aap_age = SPANSARP_MAXAGE - + sap->sa_reftime; + else + aar.aap_age = 0; + ATM_ADDR_COPY(&sap->sa_dstatm, &aar.aap_addr); + ATM_ADDR_COPY(&sap->sa_dstatmsub, + &aar.aap_subaddr); + + /* + * Copy the response into the user's buffer + */ + if (err = copyout((caddr_t)&aar, buf_addr, + sizeof(aar))) + break; + buf_addr += sizeof(aar); + buf_len -= sizeof(aar); + } + if (err) + break; + } + + /* + * Update the buffer pointer and length + */ + aip->air_buf_addr = buf_addr; + aip->air_buf_len = buf_len; + break; + + default: + err = EOPNOTSUPP; + } + + return (err); +} + diff --git a/sys/netatm/spans/spans_cls.c b/sys/netatm/spans/spans_cls.c new file mode 100644 index 0000000..f496311 --- /dev/null +++ b/sys/netatm/spans/spans_cls.c @@ -0,0 +1,848 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: spans_cls.c,v 1.11 1998/06/29 22:04:29 mks Exp $ + * + */ + +/* + * SPANS Signalling Manager + * --------------------------- + * + * SPANS Connectionless Datagram Service (CLS) module + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: spans_cls.c,v 1.11 1998/06/29 22:04:29 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> +#include "spans_xdr.h" +#include <netatm/spans/spans_var.h> +#include <netatm/spans/spans_cls.h> + + +/* + * Global variables + */ +int spanscls_print = 0; + +struct spanscls *spanscls_head = NULL; + +struct spans_addr spans_bcastaddr = { + { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } +}; + +struct spanscls_hdr spanscls_hdr = { + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* dst */ + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* src */ + 0x00, 0x00, 0, + 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0 /* LLC SNAP */ +}; + + +/* + * Local functions + */ +static int spanscls_ipact __P((struct ip_nif *)); +static int spanscls_ipdact __P((struct ip_nif *)); +static int spanscls_bcast_output __P((struct ip_nif *, KBuffer *)); +static void spanscls_cpcs_data __P((void *, KBuffer *)); +static void spanscls_connected __P((void *)); +static void spanscls_cleared __P((void *, struct t_atm_cause *)); +static caddr_t spanscls_getname __P((void *)); +static void spanscls_pdu_print __P((struct spanscls *, KBuffer *, + char *)); + +/* + * Local variables + */ +static struct sp_info spanscls_pool = { + "spans cls pool", /* si_name */ + sizeof(struct spanscls), /* si_blksiz */ + 2, /* si_blkcnt */ + 100 /* si_maxallow */ +}; + +static struct ip_serv spanscls_ipserv = { + spanscls_ipact, + spanscls_ipdact, + spansarp_ioctl, + NULL, + spansarp_svcout, + spansarp_svcin, + spansarp_svcactive, + spansarp_vcclose, + spanscls_bcast_output, + { + {ATM_AAL5, ATM_ENC_NULL}, + {ATM_AAL3_4, ATM_ENC_NULL} + } +}; + +static u_char spanscls_bridged[] = { + 0x00, 0x00, 0x00, 0x00, + 0xaa, 0xaa, 0x03, 0x00, 0x80, 0xc2 /* LLC SNAP */ +}; + +static Atm_endpoint spanscls_endpt = { + NULL, + ENDPT_SPANS_CLS, + NULL, + spanscls_getname, + spanscls_connected, + spanscls_cleared, + NULL, + NULL, + NULL, + NULL, + spanscls_cpcs_data, + NULL, + NULL, + NULL, + NULL +}; + +static Atm_attributes spanscls_attr = { + NULL, /* nif */ + CMAPI_CPCS, /* api */ + 0, /* api_init */ + 0, /* headin */ + 0, /* headout */ + { /* aal */ + T_ATM_PRESENT, + ATM_AAL3_4 + }, + { /* traffic */ + T_ATM_PRESENT, + { + { + T_ATM_ABSENT, + 0, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_NO + }, + { + T_ATM_ABSENT, + 0, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_NO + }, + T_YES + }, + }, + { /* bearer */ + T_ATM_PRESENT, + { + T_ATM_CLASS_X, + T_ATM_NULL, + T_ATM_NULL, + T_NO, + T_ATM_1_TO_1 + } + }, + { /* bhli */ + T_ATM_ABSENT + }, + { /* blli */ + T_ATM_ABSENT, + T_ATM_ABSENT + }, + { /* llc */ + T_ATM_ABSENT + }, + { /* called */ + T_ATM_PRESENT, + }, + { /* calling */ + T_ATM_ABSENT + }, + { /* qos */ + T_ATM_PRESENT, + { + T_ATM_NETWORK_CODING, + { + T_ATM_QOS_CLASS_0, + }, + { + T_ATM_QOS_CLASS_0 + } + } + }, + { /* transit */ + T_ATM_ABSENT + }, + { /* cause */ + T_ATM_ABSENT + } +}; + +static struct t_atm_cause spanscls_cause = { + T_ATM_ITU_CODING, + T_ATM_LOC_USER, + T_ATM_CAUSE_UNSPECIFIED_NORMAL, + {0, 0, 0, 0} +}; + + +/* + * Process module loading + * + * Called whenever the spans module is initializing. + * + * Arguments: + * none + * + * Returns: + * 0 initialization successful + * errno initialization failed - reason indicated + * + */ +int +spanscls_start() +{ + int err; + + /* + * Fill in union fields + */ + spanscls_attr.aal.v.aal4.forward_max_SDU_size = ATM_NIF_MTU; + spanscls_attr.aal.v.aal4.backward_max_SDU_size = ATM_NIF_MTU; + spanscls_attr.aal.v.aal4.SSCS_type = T_ATM_NULL; + spanscls_attr.aal.v.aal4.mid_low = 0; + spanscls_attr.aal.v.aal4.mid_high = 1023; + + /* + * Register our endpoint + */ + err = atm_endpoint_register(&spanscls_endpt); + + return (err); +} + + +/* + * Process module unloading notification + * + * Called whenever the spans module is about to be unloaded. All signalling + * instances will have been previously detached. All spanscls resources + * must be freed now. + * + * Arguments: + * none + * + * Returns: + * none + * + */ +void +spanscls_stop() +{ + int s = splnet(); + + /* + * Tell ARP to stop + */ + spansarp_stop(); + + /* + * Nothing should be left here... + */ + if (spanscls_head) { + panic("spanscls_stop: bad state"); + } + (void) splx(s); + + /* + * De-register ourselves + */ + (void) atm_endpoint_deregister(&spanscls_endpt); + + /* + * Free our storage pools + */ + atm_release_pool(&spanscls_pool); +} + + +/* + * Process signalling interface attach + * + * This function is called whenever a physical interface has been attached + * to spans. We will open the CLS PVC and await further events. + * + * Called at splnet. + * + * Arguments: + * spp pointer to spans signalling protocol instance + * + * Returns: + * 0 attach successful + * errno attach failed - reason indicated + * + */ +int +spanscls_attach(spp) + struct spans *spp; +{ + struct spanscls *clp; + Atm_addr_pvc *pvcp; + int err; + + /* + * Get a new cls control block + */ + clp = (struct spanscls *)atm_allocate(&spanscls_pool); + if (clp == NULL) + return (ENOMEM); + + /* + * Initialize some stuff + */ + clp->cls_state = CLS_CLOSED; + clp->cls_spans = spp; + spp->sp_ipserv = &spanscls_ipserv; + + /* + * Fill out connection attributes + */ + spanscls_attr.nif = spp->sp_pif->pif_nif; + spanscls_attr.traffic.v.forward.PCR_all_traffic = spp->sp_pif->pif_pcr; + spanscls_attr.traffic.v.backward.PCR_all_traffic = spp->sp_pif->pif_pcr; + spanscls_attr.called.addr.address_format = T_ATM_PVC_ADDR; + spanscls_attr.called.addr.address_length = sizeof(Atm_addr_pvc); + pvcp = (Atm_addr_pvc *)spanscls_attr.called.addr.address; + ATM_PVC_SET_VPI(pvcp, SPANS_CLS_VPI); + ATM_PVC_SET_VCI(pvcp, SPANS_CLS_VCI); + spanscls_attr.called.subaddr.address_format = T_ATM_ABSENT; + spanscls_attr.called.subaddr.address_length = 0; + + /* + * Create SPANS Connectionless Service (CLS) PVC + */ + err = atm_cm_connect(&spanscls_endpt, clp, &spanscls_attr, + &clp->cls_conn); + if (err) { + atm_free((caddr_t)clp); + return (err); + } + + /* + * Set new state and link instance + */ + clp->cls_state = CLS_OPEN; + LINK2TAIL(clp, struct spanscls, spanscls_head, cls_next); + spp->sp_cls = clp; + + return (0); +} + + +/* + * Process signalling interface detach + * + * This function is called whenever a physical interface has been detached + * from spans. We will close the CLS PVC and clean up everything. + * + * Called at splnet. + * + * Arguments: + * spp pointer to spans signalling protocol instance + * + * Returns: + * none + * + */ +void +spanscls_detach(spp) + struct spans *spp; +{ + struct spanscls *clp; + + /* + * Get our control block + */ + clp = spp->sp_cls; + if (clp == NULL) + return; + + /* + * Just checking up on things... + */ + if (clp->cls_ipnif) + panic("spanscls_detach: IP interface still active"); + + /* + * Close CLS PVC + */ + spanscls_closevc(clp, &spanscls_cause); + + /* + * Sever links and free server block, if possible + */ + clp->cls_spans = NULL; + spp->sp_cls = NULL; + if (clp->cls_state == CLS_CLOSED) { + UNLINK(clp, struct spanscls, spanscls_head, cls_next); + atm_free((caddr_t)clp); + } +} + + +/* + * Process IP Network Interface Activation + * + * Called whenever an IP network interface becomes active. + * + * Called at splnet. + * + * Arguments: + * inp pointer to IP network interface + * + * Returns: + * 0 command successful + * errno command failed - reason indicated + * + */ +static int +spanscls_ipact(inp) + struct ip_nif *inp; +{ + struct spans *spp; + struct spanscls *clp; + + /* + * Get corresponding cls instance + */ + spp = (struct spans *)inp->inf_nif->nif_pif->pif_siginst; + if ((spp == NULL) || ((clp = spp->sp_cls) == NULL)) + return (ENXIO); + + /* + * Make sure it's not already activated + */ + if (clp->cls_ipnif) + return (EEXIST); + + /* + * Set two-way links with IP world + */ + clp->cls_ipnif = inp; + inp->inf_isintf = (caddr_t)clp; + + /* + * Tell arp about new interface + */ + spansarp_ipact(clp); + + return (0); +} + + +/* + * Process IP Network Interface Deactivation + * + * Called whenever an IP network interface becomes inactive. + * + * Called at splnet. + * + * Arguments: + * inp pointer to IP network interface + * + * Returns: + * 0 command successful + * errno command failed - reason indicated + * + */ +static int +spanscls_ipdact(inp) + struct ip_nif *inp; +{ + struct spanscls *clp; + + /* + * Get cls instance and make sure it's been activated + */ + clp = (struct spanscls *)inp->inf_isintf; + if ((clp == NULL) || (clp->cls_ipnif == NULL)) + return (ENXIO); + + /* + * Let arp know about this + */ + spansarp_ipdact(clp); + + /* + * Clear IP interface pointer + */ + clp->cls_ipnif = NULL; + return (0); +} + + +/* + * Output IP Broadcast Packet + * + * Called whenever an IP broadcast packet is sent to this interface. + * + * Arguments: + * inp pointer to IP network interface + * m pointer to packet buffer chain + * + * Returns: + * 0 packet sent successfully + * errno send failed - reason indicated + * + */ +static int +spanscls_bcast_output(inp, m) + struct ip_nif *inp; + KBuffer *m; +{ + struct spans *spp; + struct spanscls *clp; + struct spanscls_hdr *chp; + int err, space; + + /* + * Get cls instance and make sure it's been activated + */ + clp = (struct spanscls *)inp->inf_isintf; + if ((clp == NULL) || (clp->cls_ipnif == NULL)) { + KB_FREEALL(m); + return (ENETDOWN); + } + + /* + * Make sure that we know our addresses + */ + spp = clp->cls_spans; + if (spp->sp_addr.address_format != T_ATM_SPANS_ADDR) { + KB_FREEALL(m); + return (ENETDOWN); + } + + /* + * See if there's room to add CLS header to front of packet. + */ + KB_HEADROOM(m, space); + if (space < sizeof(struct spanscls_hdr)) { + KBuffer *n; + + /* + * We have to allocate another buffer and tack it + * onto the front of the packet + */ + KB_ALLOCPKT(n, sizeof(struct spanscls_hdr), + KB_F_NOWAIT, KB_T_HEADER); + if (n == 0) { + KB_FREEALL(m); + return (ENOBUFS); + } + KB_TAILALIGN(n, sizeof(struct spanscls_hdr)); + KB_LINKHEAD(n, m); + m = n; + } else { + /* + * Header fits, just adjust buffer controls + */ + KB_HEADADJ(m, sizeof(struct spanscls_hdr)); + } + + /* + * Now, build the CLS header + */ + KB_DATASTART(m, chp, struct spanscls_hdr *); + spans_addr_copy(&spans_bcastaddr, &chp->ch_dst); + spans_addr_copy(spp->sp_addr.address, &chp->ch_src); + *(u_int *)&chp->ch_proto = *(u_int *)&spanscls_hdr.ch_proto; + *(u_int *)&chp->ch_dsap = *(u_int *)&spanscls_hdr.ch_dsap; + *(u_short *)&chp->ch_oui[1] = *(u_short *)&spanscls_hdr.ch_oui[1]; + chp->ch_pid = htons(ETHERTYPE_IP); + +#ifdef DIAGNOSTIC + if (spanscls_print) + spanscls_pdu_print(clp, m, "output"); +#endif + + /* + * Finally, send the pdu via the CLS service + */ + err = atm_cm_cpcs_data(clp->cls_conn, m); + if (err) { + KB_FREEALL(m); + return (ENOBUFS); + } + + return (0); +} + + +/* + * Process VCC Input Data + * + * All input packets received from CLS VCC lower layers are processed here. + * + * Arguments: + * tok connection token (pointer to CLS VCC control block) + * m pointer to input packet buffer chain + * + * Returns: + * none + * + */ +static void +spanscls_cpcs_data(tok, m) + void *tok; + KBuffer *m; +{ + struct spanscls *clp = tok; + struct spans *spp = clp->cls_spans; + struct spanscls_hdr *chp; + struct ip_nif *inp; + + /* + * Make sure we're ready + */ + if ((clp->cls_state != CLS_OPEN) || (spp->sp_state != SPANS_ACTIVE)) { + KB_FREEALL(m); + return; + } + +#ifdef DIAGNOSTIC + if (spanscls_print) + spanscls_pdu_print(clp, m, "input"); +#endif + + /* + * Get CLS header into buffer + */ + if (KB_LEN(m) < sizeof(struct spanscls_hdr)) { + KB_PULLUP(m, sizeof(struct spanscls_hdr), m); + if (m == 0) + return; + } + KB_DATASTART(m, chp, struct spanscls_hdr *); + + /* + * Verify packet information + */ + if ((*(u_int *)&chp->ch_proto != *(u_int *)&spanscls_hdr.ch_proto) || + (*(u_int *)&chp->ch_dsap != *(u_int *)&spanscls_hdr.ch_dsap) || + (*(u_short *)&chp->ch_oui[1] != + *(u_short *)&spanscls_hdr.ch_oui[1])) { + + /* + * Check for bridged PDU + */ + if (bcmp((char *)&chp->ch_proto, (char *)spanscls_bridged, + sizeof(spanscls_bridged))) { + log(LOG_ERR, "spanscls_input: bad format\n"); +#ifdef DIAGNOSTIC + spanscls_pdu_print(clp, m, "input error"); +#endif + } + + KB_FREEALL(m); + return; + } + + /* + * Make sure packet is for us + */ + if (spans_addr_cmp(&chp->ch_dst, spp->sp_addr.address) && + spans_addr_cmp(&chp->ch_dst, &spans_bcastaddr)) { + KB_FREEALL(m); + return; + } + + /* + * Do protocol processing + */ + switch (ntohs(chp->ch_pid)) { + + case ETHERTYPE_IP: + /* + * Drop CLS header + */ + KB_HEADADJ(m, -sizeof(struct spanscls_hdr)); + KB_PLENADJ(m, -sizeof(struct spanscls_hdr)); + + /* + * Packet is ready for input to IP + */ + if (inp = clp->cls_ipnif) + (void) (*inp->inf_ipinput)(inp, m); + else + KB_FREEALL(m); + break; + + case ETHERTYPE_ARP: + spansarp_input(clp, m); + break; + + default: + log(LOG_ERR, "spanscls_input: unknown protocol 0x%x\n", + chp->ch_pid); + KB_FREEALL(m); + return; + } +} + + +/* + * Close a SPANS CLS VCC + * + * This function will close a SPANS CLS VCC. + * + * Arguments: + * clp pointer to CLS instance + * cause pointer to cause code + * + * Returns: + * none + * + */ +void +spanscls_closevc(clp, cause) + struct spanscls *clp; + struct t_atm_cause *cause; +{ + int err; + + /* + * Close VCC + */ + if (clp->cls_conn) { + err = atm_cm_release(clp->cls_conn, cause); + if (err) { + log(LOG_ERR, "spanscls_closevc: release err=%d\n", err); + } + clp->cls_conn = NULL; + } + + clp->cls_state = CLS_CLOSED; +} + + +/* + * Process CLS VCC Connected Notification + * + * Arguments: + * toku user's connection token (spanscls protocol block) + * + * Returns: + * none + * + */ +static void +spanscls_connected(toku) + void *toku; +{ + /* + * We should never get one of these + */ + log(LOG_ERR, "spanscls: unexpected connected event\n"); +} + + +/* + * Process CLS VCC Cleared Notification + * + * Arguments: + * toku user's connection token (spanscls protocol block) + * cause pointer to cause code + * + * Returns: + * none + * + */ +static void +spanscls_cleared(toku, cause) + void *toku; + struct t_atm_cause *cause; +{ + struct spanscls *clp = (struct spanscls *)toku; + + /* + * CLS VCC has been closed, so clean up our side + */ + clp->cls_conn = NULL; + spanscls_closevc(clp, cause); +} + + +/* + * Get Connection's Application/Owner Name + * + * Arguments: + * tok spanscls connection token + * + * Returns: + * addr pointer to string containing our name + * + */ +static caddr_t +spanscls_getname(tok) + void *tok; +{ + return ("SPANSCLS"); +} + + +/* + * Print a SPANS CLS PDU + * + * Arguments: + * clp pointer to cls instance + * m pointer to pdu buffer chain + * msg pointer to message string + * + * Returns: + * none + * + */ +static void +spanscls_pdu_print(clp, m, msg) + struct spanscls *clp; + KBuffer *m; + char *msg; +{ + char buf[128]; + + sprintf(buf, "spanscls %s:\n", msg); + atm_pdu_print(m, buf); +} + diff --git a/sys/netatm/spans/spans_cls.h b/sys/netatm/spans/spans_cls.h new file mode 100644 index 0000000..d2cacac --- /dev/null +++ b/sys/netatm/spans/spans_cls.h @@ -0,0 +1,188 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: spans_cls.h,v 1.6 1998/05/18 19:11:17 mks Exp $ + * + */ + +/* + * SPANS Signalling Manager + * --------------------------- + * + * SPANS Connectionless Datagram Service (CLS) control blocks + * + */ + +#ifndef _SPANS_SPANSCLS_H +#define _SPANS_SPANSCLS_H + +/* + * Protocol constants + */ +#define SPANSARP_AGING (60 * ATM_HZ) /* ARP aging timer */ +#define SPANSARP_RETRY (3 * ATM_HZ) /* ARP retry timer */ +#define SPANSARP_MAXAGE 20 /* Max ARP entry age (minutes)*/ +#define SPANSARP_HASHSIZ 19 /* Hash table size */ + + +/* + * SPANS CLS protocol structure. There will be one such structure for + * each SPANS signalling instance. + */ +struct spanscls { + struct spanscls *cls_next; /* Next attached cls instance */ + u_char cls_state; /* Protocol state (see below) */ + struct spans *cls_spans; /* Spans signalling instance */ + Atm_connection *cls_conn; /* Connection manager token */ + struct ip_nif *cls_ipnif; /* IP network interface */ +}; + +/* + * SPANS CLS Protocol States + */ +#define CLS_CLOSED 1 /* CLS PVC is closed */ +#define CLS_OPEN 2 /* CLS PVC is open */ + + +/* + * Structure for SPANS ARP mappings. Each of these structures will contain + * IP address to SPANS hardware address mappings. There will be one such + * structure for each IP address currently in use. + */ +struct spansarp { + struct arpmap sa_arpmap; /* Common entry header */ + struct spanscls *sa_cls; /* Interface where we learned answer */ + struct spansarp *sa_next; /* Hash chain */ + struct spansarp *sa_rnext; /* Retry chain */ + u_char sa_flags; /* Flags (see below) */ + u_char sa_origin; /* Origin (see below) */ + u_short sa_reftime; /* Entry reference time (minutes) */ + struct ipvcc *sa_ivp; /* IP VCCs waiting for answer */ +}; +#define sa_dstip sa_arpmap.am_dstip +#define sa_dstatm sa_arpmap.am_dstatm +#define sa_dstatmsub sa_arpmap.am_dstatmsub + +/* + * Entry Flags + */ +#define SAF_VALID ARPF_VALID /* Entry is valid */ +#define SAF_REFRESH ARPF_REFRESH /* Entry has been refreshed */ +#define SAF_LOCKED 0x04 /* Entry is locked */ + +/* + * Entry Origin + */ +#define SAO_PERM ARP_ORIG_PERM /* Entry is permanently installed */ +#define SAO_LOOKUP 20 /* Learned via lookup */ + + +/* + * SPANS CLS Packet Header + */ +struct spanscls_hdr { + /* IEEE 802.6 MAC header */ + spans_addr ch_dst; /* Destination SPANS address */ + spans_addr ch_src; /* Source SPANS address */ + u_char ch_proto; /* */ + u_char ch_extlen; /* */ + u_short ch_bridging; /* */ + + /* LLC SNAP header */ + u_char ch_dsap; /* Destination SAP */ + u_char ch_ssap; /* Source SAP */ + u_char ch_ctl; /* Control field */ + u_char ch_oui[3]; /* Organizationally Unique Identifier */ + u_short ch_pid; /* Protocol Identifier */ +}; + +/* + * SPANS ARP Packet Format + */ +struct spansarp_hdr { + u_short ah_hrd; /* Hardware type (see below) */ + u_short ah_pro; /* Protocol type */ + u_char ah_hln; /* Length of hardware address */ + u_char ah_pln; /* Length of protocol address */ + u_short ah_op; /* Operation code (see below) */ + spans_addr ah_sha; /* Source hardware address */ + u_char ah_spa[4]; /* Source protocol address */ + spans_addr ah_tha; /* Target hardware address */ + u_char ah_tpa[4]; /* Target protocol address */ +}; + +/* + * Hardware types + */ +#define ARP_SPANS 0x4040 + +/* + * Operation types + */ +#define ARP_REQUEST 1 /* SPANSARP request */ +#define ARP_REPLY 2 /* SPANSARP response */ + +#define ARP_PACKET_LEN \ + (sizeof(struct spanscls_hdr) + sizeof(struct spansarp_hdr)) + +#ifdef ATM_KERNEL +/* + * Macros for manipulating SPANS ARP tables and entries + */ +#define SPANSARP_HASH(ip) ((u_long)(ip) % SPANSARP_HASHSIZ) + +#define SPANSARP_ADD(sa) \ +{ \ + struct spansarp **h; \ + h = &spansarp_arptab[SPANSARP_HASH((sa)->sa_dstip.s_addr)]; \ + LINK2TAIL((sa), struct spansarp, *h, sa_next); \ +} + +#define SPANSARP_DELETE(sa) \ +{ \ + struct spansarp **h; \ + h = &spansarp_arptab[SPANSARP_HASH((sa)->sa_dstip.s_addr)]; \ + UNLINK((sa), struct spansarp, *h, sa_next); \ +} + +#define SPANSARP_LOOKUP(ip, sa) \ +{ \ + for ((sa) = spansarp_arptab[SPANSARP_HASH(ip)]; \ + (sa); (sa) = (sa)->sa_next) { \ + if ((sa)->sa_dstip.s_addr == (ip)) \ + break; \ + } \ +} + + +/* + * External variables + */ +extern struct spanscls *spanscls_head; +extern struct spanscls_hdr spanscls_hdr; + +#endif /* ATM_KERNEL */ + +#endif /* _SPANS_SPANSCLS_H */ diff --git a/sys/netatm/spans/spans_if.c b/sys/netatm/spans/spans_if.c new file mode 100644 index 0000000..4facf73 --- /dev/null +++ b/sys/netatm/spans/spans_if.c @@ -0,0 +1,1336 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: spans_if.c,v 1.12 1998/08/26 23:29:09 mks Exp $ + * + */ + +/* + * SPANS Signalling Manager + * --------------------------- + * + * External interfaces to SPANS manager. Includes support for + * running as a loadable kernel module. + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: spans_if.c,v 1.12 1998/08/26 23:29:09 mks Exp $"; +#endif + +#ifndef ATM_SPANS_MODULE +#include "opt_atm.h" +#endif + +#include <netatm/kern_include.h> + +#include "spans_xdr.h" +#include <netatm/spans/spans_var.h> + +/* + * Global variables + */ +struct sp_info spans_vcpool = { + "spans vcc pool", /* si_name */ + sizeof(struct spans_vccb), /* si_blksiz */ + 10, /* si_blkcnt */ + 50 /* si_maxallow */ +}; + +struct sp_info spans_msgpool = { + "spans message pool", /* si_name */ + sizeof(spans_msg), /* si_blksiz */ + 10, /* si_blkcnt */ + 50 /* si_maxallow */ +}; + +/* + * Local functions + */ +static int spans_start __P((void)); +static int spans_stop __P((void)); +static int spans_attach __P((struct sigmgr *, struct atm_pif *)); +static int spans_detach __P((struct atm_pif *)); +static int spans_setup __P((Atm_connvc *, int *)); +static int spans_release __P((struct vccb *, int *)); +static int spans_accept __P((struct vccb *, int *)); +static int spans_reject __P((struct vccb *, int *)); +static int spans_ioctl __P((int, caddr_t, caddr_t)); + +/* + * Local variables + */ +static struct sigmgr *spans_mgr = NULL; + + +/* + * Initialize SPANS processing + * + * This will be called during module loading. We'll just register + * the SPANS protocol descriptor and wait for a SPANS ATM interface + * to come online. + * + * Arguments: + * none + * + * Returns: + * 0 startup was successful + * errno startup failed - reason indicated + * + */ +static int +spans_start() +{ + int err = 0; + + /* + * Verify software version + */ + if (atm_version != ATM_VERSION) { + log(LOG_ERR, "version mismatch: spans=%d.%d kernel=%d.%d\n", + ATM_VERS_MAJ(ATM_VERSION), + ATM_VERS_MIN(ATM_VERSION), + ATM_VERS_MAJ(atm_version), + ATM_VERS_MIN(atm_version)); + return (EINVAL); + } + + /* + * Allocate protocol definition structure + */ + spans_mgr = (struct sigmgr *)KM_ALLOC(sizeof(struct sigmgr), + M_DEVBUF, M_NOWAIT); + if (spans_mgr == NULL) { + err = ENOMEM; + goto done; + } + KM_ZERO(spans_mgr, sizeof(struct sigmgr)); + + /* + * Initialize protocol invariant values + */ + spans_mgr->sm_proto = ATM_SIG_SPANS; + spans_mgr->sm_attach = spans_attach; + spans_mgr->sm_detach = spans_detach; + spans_mgr->sm_setup = spans_setup; + spans_mgr->sm_release = spans_release; + spans_mgr->sm_accept = spans_accept; + spans_mgr->sm_reject = spans_reject; + spans_mgr->sm_free = spans_free; + spans_mgr->sm_ioctl = spans_ioctl; + + /* + * Register ourselves with system + */ + err = atm_sigmgr_register(spans_mgr); + if (err) + goto done; + + /* + * Start up Connectionless Service + */ + err = spanscls_start(); + if (err) + goto done; + +done: + return (err); +} + + +/* + * Halt SPANS processing + * + * This should be called just prior to unloading the module from + * memory. All SPANS interfaces must be deregistered before the + * protocol can be shutdown. + * + * Arguments: + * none + * + * Returns: + * 0 startup was successful + * errno startup failed - reason indicated + * + */ +static int +spans_stop() +{ + int err = 0; + int s = splnet(); + + /* + * Is protocol even set up? + */ + if (spans_mgr) { + + /* + * Any protocol instances still registered? + */ + if (spans_mgr->sm_prinst) { + + /* Yes, can't stop now */ + err = EBUSY; + goto done; + } + + /* + * Stop Connectionless Service + */ + spanscls_stop(); + + /* + * De-register from system + */ + err = atm_sigmgr_deregister(spans_mgr); + + /* + * Free up protocol block + */ + KM_FREE(spans_mgr, sizeof(struct sigmgr), M_DEVBUF); + spans_mgr = NULL; + + /* + * Free up our storage pools + */ + atm_release_pool(&spans_vcpool); + atm_release_pool(&spans_msgpool); + } else + err = ENXIO; + +done: + (void) splx(s); + return (err); +} + + +/* + * Attach a SPANS-controlled interface + * + * Each ATM physical interface must be attached with the signalling + * manager for the interface's signalling protocol (via the + * atm_sigmgr_attach function). This function will handle the + * attachment for SPANS-controlled interfaces. A new SPANS protocol + * instance will be created and then we'll just sit around waiting for + * status or connection requests. + * + * Function must be called at splnet. + * + * Arguments: + * smp pointer to SPANS signalling manager control block + * pip pointer to ATM physical interface control block + * + * Returns: + * 0 attach successful + * errno attach failed - reason indicated + * + */ +static int +spans_attach(smp, pip) + struct sigmgr *smp; + struct atm_pif *pip; +{ + int err = 0, n = 0, s; + struct spans *spp = NULL; + struct atm_nif *np; + + ATM_DEBUG2("spans_attach: smp=%x, pip=%x\n", smp, pip); + + /* + * Count network interfaces attached to the physical interface. + * If there are more or less than one, we have big problems. + */ + np = pip->pif_nif; + while (np) { + n++; + np = np->nif_pnext; + } + if (n != 1) { + err = ETOOMANYREFS; + goto done; + } + + /* + * Allocate SPANS protocol instance control block + */ + spp = (struct spans *)KM_ALLOC(sizeof(struct spans), + M_DEVBUF, M_NOWAIT); + if (spp == NULL) { + err = ENOMEM; + goto done; + } + KM_ZERO(spp, sizeof(struct spans)); + + /* + * Set variables in SPANS protocol instance control block + */ + spp->sp_state = SPANS_INIT; + spp->sp_h_epoch = time_second; + spp->sp_s_epoch = 0; + spp->sp_addr.address_format = T_ATM_ABSENT; + spp->sp_addr.address_length = 0; + spp->sp_subaddr.address_format = T_ATM_ABSENT; + spp->sp_subaddr.address_length = 0; + spp->sp_probe_ct = 0; + spp->sp_alloc_vci = SPANS_MIN_VCI; + spp->sp_alloc_vpi = SPANS_VPI; + spp->sp_min_vci = SPANS_MIN_VCI; + spp->sp_max_vci = pip->pif_maxvci; + + /* + * Link instance into manager's chain + */ + LINK2TAIL((struct siginst *)spp, struct siginst, smp->sm_prinst, + si_next); + + /* + * Link in interface + */ + spp->sp_pif = pip; + pip->pif_sigmgr = smp; + pip->pif_siginst = (struct siginst *) spp; + + /* + * Kick-start the SPANS protocol + */ + SPANS_TIMER(spp, 0); + + /* + * Notify Connectionless Service + */ + err = spanscls_attach(spp); + + /* + * Log the fact that we've attached + */ + if (!err) + log(LOG_INFO, "spans: attached to interface %s%d\n", + pip->pif_name, pip->pif_unit); + +done: + /* + * Reset our work if attach fails + */ + if (err) { + if (spp) { + SPANS_CANCEL(spp); + UNLINK((struct siginst *)spp, struct siginst, + smp->sm_prinst, si_next); + KM_FREE(spp, sizeof(struct spans), M_DEVBUF); + } + s = splimp(); + pip->pif_sigmgr = NULL; + pip->pif_siginst = NULL; + (void) splx(s); + } + + return (err); +} + + +/* + * Detach a SPANS-controlled interface + * + * Each ATM physical interface may be detached from its signalling + * manager (via the atm_sigmgr_detach function). This function will + * handle the detachment for all SPANS-controlled interfaces. All + * circuits will be immediately terminated. + * + * Function must be called at splnet. + * + * Arguments: + * pip pointer to ATM physical interface control block + * + * Returns: + * 0 detach successful + * errno detach failed - reason indicated + * + */ +static int +spans_detach(pip) + struct atm_pif *pip; +{ + struct spans *spp; + struct vccb *vcp, *vnext; + Atm_connection *cop; + int err; + + ATM_DEBUG1("spans_detach: pip=0x%x\n", pip); + + /* + * Get SPANS protocol instance + */ + spp = (struct spans *)pip->pif_siginst; + + /* + * Return an error if we're already detaching + */ + if (spp->sp_state == SPANS_DETACH) { + return(EALREADY); + } + + /* + * Cancel any outstanding timer + */ + SPANS_CANCEL(spp); + + /* + * Notify Connectionless Service + */ + spanscls_detach(spp); + + /* + * Terminate all of our VCCs + */ + for (vcp = Q_HEAD(spp->sp_vccq, struct vccb); vcp; vcp = vnext) { + + vnext = Q_NEXT(vcp, struct vccb, vc_sigelem); + + /* + * Don't close the signalling VCC yet + */ + if (vcp->vc_connvc && vcp->vc_connvc->cvc_conn == + spp->sp_conn) + continue; + + /* + * Close VCC and notify owner + */ + err = spans_clear_vcc(spp, (struct spans_vccb *)vcp); + if (err) { + log(LOG_ERR, "spans: error %d clearing VCCB 0x%x\n", + err, vcp); + } + } + + /* + * Now close the SPANS signalling VCC + */ + if (cop = spp->sp_conn) { + err = atm_cm_release(cop, &spans_cause); + if (err) + ATM_DEBUG2( + "spans_detach: close failed for SPANS signalling channel; cop=0x%x, err=%d\n", + cop, err); + } + + + /* + * Get rid of protocol instance if there are no VCCs queued + */ + if (Q_HEAD(spp->sp_vccq, struct vccb) == NULL) { + struct sigmgr *smp = pip->pif_sigmgr; + + pip->pif_sigmgr = NULL; + pip->pif_siginst = NULL; + UNLINK((struct siginst *)spp, struct siginst, + smp->sm_prinst, si_next); + KM_FREE(spp, sizeof(struct spans), M_DEVBUF); + } else { + /* + * Otherwise, wait for protocol instance to be freed + * during spans_free processing for the last queued VCC. + */ + spp->sp_state = SPANS_DETACH; + } + + /* + * Log the fact that we've detached + */ + log(LOG_INFO, "spans: detached from interface %s%d\n", + pip->pif_name, pip->pif_unit); + + return (0); +} + + +/* + * Open a SPANS ATM Connection + * + * All service user requests to open a VC connection (via + * atm_open_connection) over an ATM interface attached to the SPANS + * signalling manager are handled here. + * + * Function will be called at splnet. + * + * Arguments: + * cvp pointer to user's requested connection parameters + * errp pointer to an int for extended error information + * + * Returns: + * CALL_PROCEEDING connection establishment is in progress + * CALL_FAILED connection establishment failed + * CALL_CONNECTED connection has been successfully established + * + */ +static int +spans_setup(cvp, errp) + Atm_connvc *cvp; + int *errp; +{ + struct atm_pif *pip = cvp->cvc_attr.nif->nif_pif; + struct spans *spp = (struct spans *)pip->pif_siginst; + int rc = 0; + + ATM_DEBUG1("spans_setup: cvp=0x%x\n", cvp); + + /* + * Intialize the returned error code + */ + *errp = 0; + + /* + * Open the connection + */ + switch (cvp->cvc_attr.called.addr.address_format) { + case T_ATM_PVC_ADDR: + /* + * Create a PVC + */ + *errp = spans_open_vcc(spp, cvp); + rc = (*errp ? CALL_FAILED : CALL_CONNECTED); + break; + + case T_ATM_SPANS_ADDR: + + /* + * Create an SVC + */ + *errp = spans_open_vcc(spp, cvp); + rc = (*errp ? CALL_FAILED : CALL_PROCEEDING); + break; + + default: + *errp = EPROTONOSUPPORT; + rc = CALL_FAILED; + } + + return (rc); +} + + +/* + * Close a SPANS ATM Connection + * + * All service user requests to terminate a previously open VC + * connection (via the atm_close_connection function), which is running + * over an interface attached to the SPANS signalling manager, are + * handled here. + * + * Function will be called at splnet. + * + * Arguments: + * vcp pointer to connection's VC control block + * errp pointer to an int for extended error information + * + * Returns: + * CALL_PROCEEDING connection termination is in progress + * CALL_FAILED connection termination failed + * CALL_CLEARED connection has been successfully terminated + * + */ +static int +spans_release(vcp, errp) + struct vccb *vcp; + int *errp; +{ + int rc = 0; + struct atm_pif *pip = vcp->vc_pif; + struct spans *spp = (struct spans *)pip->pif_siginst; + + ATM_DEBUG1("spans_release: vcp=0x%x\n", vcp); + + /* + * Initialize returned error code + */ + *errp = 0; + + /* + * Make sure VCC is open + */ + if ((vcp->vc_sstate == SPANS_VC_NULL) || + (vcp->vc_sstate == SPANS_VC_CLOSE) || + (vcp->vc_sstate == SPANS_VC_FREE) || + (vcp->vc_ustate == VCCU_NULL) || + (vcp->vc_ustate == VCCU_CLOSED)) { + *errp = EALREADY; + return(CALL_FAILED); + } + + /* + * Validate the connection type (PVC or SVC) + */ + if (!(vcp->vc_type & (VCC_PVC | VCC_SVC))) { + *errp = EPROTONOSUPPORT; + return(CALL_FAILED); + } + + /* + * Close the VCCB + */ + *errp = spans_close_vcc(spp, (struct spans_vccb *)vcp, FALSE); + + /* + * Set the return code + */ + if (vcp->vc_type & VCC_PVC) { + rc = (*errp ? CALL_FAILED : CALL_CLEARED); + } else { + rc = (*errp ? CALL_FAILED : CALL_PROCEEDING); + } + + return (rc); +} + + +/* + * Accept a SPANS Open from a remote host + * + * A user calls this routine (via the atm_accept_call function) + * after it is notified that an open request was received for it. + * + * Function will be called at splnet. + * + * Arguments: + * vcp pointer to user's VCCB + * errp pointer to an int for extended error information + * + * Returns: + * CALL_PROCEEDING connection establishment is in progress + * CALL_FAILED connection establishment failed + * CALL_CONNECTED connection has been successfully established + * + */ +static int +spans_accept(vcp, errp) + struct vccb *vcp; + int *errp; +{ + struct atm_pif *pip = vcp->vc_pif; + struct spans *spp = (struct spans *)pip->pif_siginst; + struct spans_vccb *svp = (struct spans_vccb *)vcp; + + ATM_DEBUG1("spans_accept: vcp=0x%x\n", vcp); + + /* + * Initialize the returned error code + */ + *errp = 0; + + /* + * Return an error if we're detaching + */ + if (spp->sp_state == SPANS_DETACH) { + *errp = ENETDOWN; + ATM_DEBUG0("spans_accept: detaching\n"); + return(CALL_FAILED); + } + + /* + * Respond to the open request + */ + *errp = spans_send_open_rsp(spp, svp, SPANS_OK); + if (*errp) { + ATM_DEBUG0("spans_accept: spans_send_open_rsp failed\n"); + goto failed; + } + + /* + * Update the VCC states + */ + svp->sv_sstate = SPANS_VC_OPEN; + svp->sv_ustate = VCCU_OPEN; + + return(CALL_CONNECTED); + +failed: + /* + * On error, free the VCCB and return CALL_FAILED + */ + svp->sv_sstate = SPANS_VC_FREE; + svp->sv_ustate = VCCU_CLOSED; + DEQUEUE(svp, struct spans_vccb, sv_sigelem, spp->sp_vccq); + spans_free((struct vccb *)svp); + + return(CALL_FAILED); +} + + +/* + * Reject a SPANS Open from a remote host + * + * A user calls this routine (via the atm_reject_call function) + * after it is notified that an open request was received for it. + * + * Function will be called at splnet. + * + * Arguments: + * vcp pointer to user's VCCB + * errp pointer to an int for extended error information + * + * Returns: + * CALL_CLEARED call request rejected + * CALL_FAILED call rejection failed + * + */ +static int +spans_reject(vcp, errp) + struct vccb *vcp; + int *errp; +{ + struct atm_pif *pip = vcp->vc_pif; + struct spans *spp = (struct spans *)pip->pif_siginst; + struct spans_vccb *svp = (struct spans_vccb *)vcp; + + ATM_DEBUG1("spans_reject: vcp=0x%x\n", vcp); + + /* + * Initialize the returned error code + */ + *errp = 0; + + /* + * Return an error if we're detaching + */ + if (spp->sp_state == SPANS_DETACH) { + *errp = ENETDOWN; + ATM_DEBUG0("spans_reject: detaching\n"); + return(CALL_FAILED); + } + + ATM_DEBUG1("spans_reject: cause code is %d\n", + vcp->vc_connvc->cvc_attr.cause.v.cause_value); + + /* + * Clean up the VCCB--the connection manager will free it + * spans_close_vcc will send a SPANS open response + */ + if (*errp = spans_close_vcc(spp, svp, TRUE)) { + ATM_DEBUG0("spans_reject: spans_close_vcc failed\n"); + return(CALL_FAILED); + } + + return(CALL_CLEARED); +} + + +/* + * Abort a SPANS ATM Connection + * + * All (non-user) requests to abort a previously open VC connection (via + * the atm_abort_connection function), which is running over an + * interface attached to the SPANS signalling manager, are handled here. + * The VCC owner will be notified of the request, in order to initiate + * termination of the connection. + * + * Function will be called at splnet. + * + * Arguments: + * vcp pointer to connection's VC control block + * + * Returns: + * 0 connection release was succesful + * errno connection release failed - reason indicated + * + */ +int +spans_abort(vcp) + struct vccb *vcp; +{ + + /* + * Make sure VCC is available + */ + if ((vcp->vc_sstate == SPANS_VC_NULL) || + (vcp->vc_sstate == SPANS_VC_CLOSE) || + (vcp->vc_sstate == SPANS_VC_FREE) || + (vcp->vc_ustate == VCCU_NULL) || + (vcp->vc_ustate == VCCU_CLOSED)) { + return(EALREADY); + } + + /* + * Only abort once + */ + if (vcp->vc_sstate == SPANS_VC_ABORT) { + return (EALREADY); + } + + /* + * Cancel any timer that might be running + */ + SPANS_VC_CANCEL(vcp); + + /* + * Set immediate timer to schedule connection termination + */ + vcp->vc_sstate = SPANS_VC_ABORT; + SPANS_VC_TIMER(vcp, 0); + + return (0); +} + + +/* + * Free SPANS ATM connection resources + * + * All service user requests to free the resources of a closed + * VCC connection (via the atm_free_connection function), which + * is running over an interface attached to the SigPVC signalling + * manager, are handled here. + * + * Function will be called at splnet. + * + * Arguments: + * vcp pointer to connection's VC control block + * + * Returns: + * 0 connection free was successful + * errno connection free failed - reason indicated + * + */ +int +spans_free(vcp) + struct vccb *vcp; +{ + struct atm_pif *pip = vcp->vc_pif; + struct spans *spp = (struct spans *)pip->pif_siginst; + + ATM_DEBUG1("spans_free: vcp = 0x%x\n", vcp); + + /* + * Make sure VCC has been closed + */ + if ((vcp->vc_ustate != VCCU_CLOSED) || + (vcp->vc_sstate != SPANS_VC_FREE)) { + ATM_DEBUG2("spans_free: bad state, sstate=%d, ustate=%d\n", + vcp->vc_sstate, vcp->vc_ustate); + return(EEXIST); + } + + /* + * Remove VCCB from protocol queue + */ + DEQUEUE(vcp, struct vccb, vc_sigelem, spp->sp_vccq); + + /* + * Free VCCB storage + */ + vcp->vc_ustate = VCCU_NULL; + vcp->vc_sstate = SPANS_VC_NULL; + atm_free((caddr_t)vcp); + + /* + * If we're detaching and this was the last VCC queued, + * get rid of the protocol instance + */ + if ((spp->sp_state == SPANS_DETACH) && + (Q_HEAD(spp->sp_vccq, struct vccb) == NULL)) { + struct sigmgr *smp = pip->pif_sigmgr; + + pip->pif_sigmgr = NULL; + pip->pif_siginst = NULL; + UNLINK((struct siginst *)spp, struct siginst, smp->sm_prinst, + si_next); + KM_FREE(spp, sizeof(struct spans), M_DEVBUF); + } + + return (0); +} + + +/* + * SPANS IOCTL support + * + * Function will be called at splnet. + * + * Arguments: + * code PF_ATM sub-operation code + * data pointer to code specific parameter data area + * arg1 pointer to code specific argument + * + * Returns: + * 0 request procesed + * errno error processing request - reason indicated + * + */ +static int +spans_ioctl(code, data, arg1) + int code; + caddr_t data; + caddr_t arg1; +{ + struct atmdelreq *adp; + struct atminfreq *aip; + struct spans *spp; + struct spans_vccb *svp; + struct air_vcc_rsp rsp; + Atm_connection *cop; + int buf_len, err = 0, i, vpi, vci; + caddr_t buf_addr; + + + switch (code) { + + case AIOCS_DEL_PVC: + case AIOCS_DEL_SVC: + /* + * Delete a VCC + */ + adp = (struct atmdelreq *)data; + spp = (struct spans *)arg1; + + /* + * Don't let a user close the SPANS signalling VC or + * the SPANS CLS VC + */ + vpi = adp->adr_pvc_vpi; + vci = adp->adr_pvc_vci; + if ((vpi == SPANS_SIG_VPI && vci == SPANS_SIG_VCI) || + (vpi == SPANS_CLS_VPI && + vci == SPANS_CLS_VCI)) + return(EINVAL); + + /* + * Find requested VCC + */ + for (svp = Q_HEAD(spp->sp_vccq, struct spans_vccb); svp; + svp = Q_NEXT(svp, struct spans_vccb, sv_sigelem)) { + if ((svp->sv_vpi == vpi) && (svp->sv_vci == vci)) + break; + } + if (svp == NULL) + return (ENOENT); + + /* + * Check VCC type + */ + switch (code) { + case AIOCS_DEL_PVC: + if (!(svp->sv_type & VCC_PVC)) { + return(EINVAL); + } + break; + case AIOCS_DEL_SVC: + if (!(svp->sv_type & VCC_SVC)) { + return(EINVAL); + } + break; + } + + /* + * Schedule VCC termination + */ + err = spans_abort((struct vccb *)svp); + break; + + case AIOCS_INF_VCC: + /* + * Return VCC information + */ + aip = (struct atminfreq *)data; + spp = (struct spans *)arg1; + + buf_addr = aip->air_buf_addr; + buf_len = aip->air_buf_len; + + /* + * Loop through the VCC queue + */ + for (svp = Q_HEAD(spp->sp_vccq, struct spans_vccb); svp; + svp = Q_NEXT(svp, struct spans_vccb, sv_sigelem)) { + /* + * Make sure there's room in the user's buffer + */ + if (buf_len < sizeof(rsp)) { + err = ENOSPC; + break; + } + + /* + * Fill out the response struct for the VCC + */ + (void) sprintf(rsp.avp_intf, "%s%d", + spp->sp_pif->pif_name, + spp->sp_pif->pif_unit); + rsp.avp_vpi = svp->sv_vpi; + rsp.avp_vci = svp->sv_vci; + rsp.avp_type = svp->sv_type; + rsp.avp_aal = svp->sv_connvc->cvc_attr.aal.type; + rsp.avp_sig_proto = svp->sv_proto; + cop = svp->sv_connvc->cvc_conn; + if (cop) + rsp.avp_encaps = cop->co_mpx; + else + rsp.avp_encaps = 0; + rsp.avp_state = svp->sv_sstate; + KM_ZERO(rsp.avp_owners, sizeof(rsp.avp_owners)); + for (i = 0; cop && i < sizeof(rsp.avp_owners); + cop = cop->co_next, + i += T_ATM_APP_NAME_LEN+1) { + strncpy(&rsp.avp_owners[i], + cop->co_endpt->ep_getname(cop->co_toku), + T_ATM_APP_NAME_LEN); + } + rsp.avp_daddr.address_format = T_ATM_SPANS_ADDR; + rsp.avp_daddr.address_length = + sizeof(Atm_addr_spans); + if (svp->sv_type & VCC_OUT) { + spans_addr_copy(&svp->sv_conn.con_dst, + rsp.avp_daddr.address); + } else { + spans_addr_copy(&svp->sv_conn.con_src, + rsp.avp_daddr.address); + } + rsp.avp_dsubaddr.address_format = T_ATM_ABSENT; + rsp.avp_dsubaddr.address_length = 0; + rsp.avp_ipdus = svp->sv_ipdus; + rsp.avp_opdus = svp->sv_opdus; + rsp.avp_ibytes = svp->sv_ibytes; + rsp.avp_obytes = svp->sv_obytes; + rsp.avp_ierrors = svp->sv_ierrors; + rsp.avp_oerrors = svp->sv_oerrors; + rsp.avp_tstamp = svp->sv_tstamp; + + /* + * Copy the response into the user's buffer + */ + if (err = copyout((caddr_t)&rsp, buf_addr, + sizeof(rsp))) + break; + buf_addr += sizeof(rsp); + buf_len -= sizeof(rsp); + } + + /* + * Update the buffer pointer and length + */ + aip->air_buf_addr = buf_addr; + aip->air_buf_len = buf_len; + break; + + case AIOCS_ADD_ARP: + case AIOCS_DEL_ARP: + case AIOCS_INF_ARP: + case AIOCS_INF_ASV: + /* + * ARP specific ioctl's + */ + err = spansarp_ioctl(code, data, arg1); + break; + + default: + err = EOPNOTSUPP; + } + + return (err); +} + + +#ifdef ATM_SPANS_MODULE +/* + ******************************************************************* + * + * Loadable Module Support + * + ******************************************************************* + */ +static int spans_doload __P((void)); +static int spans_dounload __P((void)); + +/* + * Generic module load processing + * + * This function is called by an OS-specific function when this + * module is being loaded. + * + * Arguments: + * none + * + * Returns: + * 0 load was successful + * errno load failed - reason indicated + * + */ +static int +spans_doload() +{ + int err = 0; + + /* + * Start us up + */ + err = spans_start(); + if (err) + /* Problems, clean up */ + (void)spans_stop(); + + return (err); +} + + +/* + * Generic module unload processing + * + * This function is called by an OS-specific function when this + * module is being unloaded. + * + * Arguments: + * none + * + * Returns: + * 0 unload was successful + * errno unload failed - reason indicated + * + */ +static int +spans_dounload() +{ + int err = 0; + + /* + * OK, try to clean up our mess + */ + err = spans_stop(); + + return (err); +} + + +#ifdef sun +/* + * Loadable driver description + */ +struct vdldrv spans_drv = { + VDMAGIC_PSEUDO, /* Pseudo Driver */ + "spans_mod", /* name */ + NULL, /* dev_ops */ + NULL, /* bdevsw */ + NULL, /* cdevsw */ + 0, /* blockmajor */ + 0 /* charmajor */ +}; + + +/* + * Loadable module support entry point + * + * This is the routine called by the vd driver for all loadable module + * functions for this pseudo driver. This routine name must be specified + * on the modload(1) command. This routine will be called whenever the + * modload(1), modunload(1) or modstat(1) commands are issued for this + * module. + * + * Arguments: + * cmd vd command code + * vdp pointer to vd driver's structure + * vdi pointer to command-specific vdioctl_* structure + * vds pointer to status structure (VDSTAT only) + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +int +spans_mod(cmd, vdp, vdi, vds) + int cmd; + struct vddrv *vdp; + caddr_t vdi; + struct vdstat *vds; +{ + int err = 0; + + switch (cmd) { + + case VDLOAD: + /* + * Module Load + * + * We dont support any user configuration + */ + err = spans_doload(); + if (err == 0) + /* Let vd driver know about us */ + vdp->vdd_vdtab = (struct vdlinkage *)&spans_drv; + break; + + case VDUNLOAD: + /* + * Module Unload + */ + err = spans_dounload(); + break; + + case VDSTAT: + /* + * Module Status + */ + + /* Not much to say at the moment */ + + break; + + default: + log(LOG_ERR, "spans_mod: Unknown vd command 0x%x\n", cmd); + err = EINVAL; + } + + return (err); +} +#endif /* sun */ + +#ifdef __FreeBSD__ + +#include <sys/exec.h> +#include <sys/sysent.h> +#include <sys/lkm.h> + +/* + * Loadable miscellaneous module description + */ +MOD_MISC(spans); + + +/* + * Loadable module support "load" entry point + * + * This is the routine called by the lkm driver whenever the + * modload(1) command is issued for this module. + * + * Arguments: + * lkmtp pointer to lkm drivers's structure + * cmd lkm command code + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +static int +spans_load(lkmtp, cmd) + struct lkm_table *lkmtp; + int cmd; +{ + return(spans_doload()); +} + + +/* + * Loadable module support "unload" entry point + * + * This is the routine called by the lkm driver whenever the + * modunload(1) command is issued for this module. + * + * Arguments: + * lkmtp pointer to lkm drivers's structure + * cmd lkm command code + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +static int +spans_unload(lkmtp, cmd) + struct lkm_table *lkmtp; + int cmd; +{ + return(spans_dounload()); +} + + +/* + * Loadable module support entry point + * + * This is the routine called by the lkm driver for all loadable module + * functions for this driver. This routine name must be specified + * on the modload(1) command. This routine will be called whenever the + * modload(1), modunload(1) or modstat(1) commands are issued for this + * module. + * + * Arguments: + * lkmtp pointer to lkm drivers's structure + * cmd lkm command code + * ver lkm version + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +int +spans_mod(lkmtp, cmd, ver) + struct lkm_table *lkmtp; + int cmd; + int ver; +{ + MOD_DISPATCH(spans, lkmtp, cmd, ver, + spans_load, spans_unload, lkm_nullcmd); +} +#endif /* __FreeBSD__ */ + +#else /* !ATM_SPANS_MODULE */ + +/* + ******************************************************************* + * + * Kernel Compiled Module Support + * + ******************************************************************* + */ +static void spans_doload __P((void *)); + +SYSINIT(atmspans, SI_SUB_PROTO_END, SI_ORDER_ANY, spans_doload, NULL) + +/* + * Kernel initialization + * + * Arguments: + * arg Not used + * + * Returns: + * none + * + */ +static void +spans_doload(void *arg) +{ + int err = 0; + + /* + * Start us up + */ + err = spans_start(); + if (err) { + /* Problems, clean up */ + (void)spans_stop(); + + log(LOG_ERR, "ATM SPANS unable to initialize (%d)!!\n", err); + } + return; +} +#endif /* ATM_SPANS_MODULE */ + diff --git a/sys/netatm/spans/spans_kxdr.c b/sys/netatm/spans/spans_kxdr.c new file mode 100644 index 0000000..b6534de --- /dev/null +++ b/sys/netatm/spans/spans_kxdr.c @@ -0,0 +1,684 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: spans_kxdr.c,v 1.2 1997/05/06 22:17:00 mks Exp $ + * + */ + +/* + * SPANS Signalling Manager + * --------------------------- + * + * Kernel XDR (External Data Representation) routines + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: spans_kxdr.c,v 1.2 1997/05/06 22:17:00 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +/* + * This file contains code that has been copied and/or modified from + * the following FreeBSD files: + * + * /usr/src/lib/libc/xdr/xdr.c + * /usr/src/lib/libc/xdr/xdr_mem.c + * + * which are covered by the copyright notice below. + */ + +/* + * Sun RPC is a product of Sun Microsystems, Inc. and is provided for + * unrestricted use provided that this legend is included on all tape + * media and as a part of the software program in whole or part. Users + * may copy or modify Sun RPC without charge, but are not authorized + * to license or distribute it to anyone else except as part of a product or + * program developed by the user. + * + * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE + * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR + * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. + * + * Sun RPC is provided with no support and without any obligation on the + * part of Sun Microsystems, Inc. to assist in its use, correction, + * modification or enhancement. + * + * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE + * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC + * OR ANY PART THEREOF. + * + * In no event will Sun Microsystems, Inc. be liable for any lost revenue + * or profits or other special, indirect and consequential damages, even if + * Sun has been advised of the possibility of such damages. + * + * Sun Microsystems, Inc. + * 2550 Garcia Avenue + * Mountain View, California 94043 + */ + +#if !defined(sun) + +#if defined(LIBC_SCCS) && !defined(lint) +/*static char *sccsid = "from: @(#)xdr.c 1.35 87/08/12";*/ +/*static char *sccsid = "from: @(#)xdr.c 2.1 88/07/29 4.0 RPCSRC";*/ +/*static char *rcsid = "Id: xdr.c,v 1.2.4.2 1996/06/05 02:52:02 jkh Exp";*/ +#endif + +/* + * xdr.c, Generic XDR routines implementation. + * + * Copyright (C) 1986, Sun Microsystems, Inc. + * + * These are the "generic" xdr routines used to serialize and de-serialize + * most common data items. See xdr.h for more info on the interface to + * xdr. + */ + +#include <rpc/types.h> +#include <rpc/xdr.h> + +/* + * constants specific to the xdr "protocol" + */ +#define XDR_FALSE ((long) 0) +#define XDR_TRUE ((long) 1) +#define LASTUNSIGNED ((u_int) 0-1) + +/* + * for unit alignment + */ +static char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 }; + +/* + * XDR integers + */ +bool_t +xdr_int(xdrs, ip) + XDR *xdrs; + int *ip; +{ + +#ifdef lint + (void) (xdr_short(xdrs, (short *)ip)); + return (xdr_long(xdrs, (long *)ip)); +#else + if (sizeof (int) == sizeof (long)) { + return (xdr_long(xdrs, (long *)ip)); + } else { + return (xdr_short(xdrs, (short *)ip)); + } +#endif +} + +/* + * XDR unsigned integers + */ +bool_t +xdr_u_int(xdrs, up) + XDR *xdrs; + u_int *up; +{ + +#ifdef lint + (void) (xdr_short(xdrs, (short *)up)); + return (xdr_u_long(xdrs, (u_long *)up)); +#else + if (sizeof (u_int) == sizeof (u_long)) { + return (xdr_u_long(xdrs, (u_long *)up)); + } else { + return (xdr_short(xdrs, (short *)up)); + } +#endif +} + +/* + * XDR long integers + * same as xdr_u_long - open coded to save a proc call! + */ +bool_t +xdr_long(xdrs, lp) + register XDR *xdrs; + long *lp; +{ + + if (xdrs->x_op == XDR_ENCODE) + return (XDR_PUTLONG(xdrs, lp)); + + if (xdrs->x_op == XDR_DECODE) + return (XDR_GETLONG(xdrs, lp)); + + if (xdrs->x_op == XDR_FREE) + return (TRUE); + + return (FALSE); +} + +/* + * XDR unsigned long integers + * same as xdr_long - open coded to save a proc call! + */ +bool_t +xdr_u_long(xdrs, ulp) + register XDR *xdrs; + u_long *ulp; +{ + + if (xdrs->x_op == XDR_DECODE) + return (XDR_GETLONG(xdrs, (long *)ulp)); + if (xdrs->x_op == XDR_ENCODE) + return (XDR_PUTLONG(xdrs, (long *)ulp)); + if (xdrs->x_op == XDR_FREE) + return (TRUE); + return (FALSE); +} + +/* + * XDR short integers + */ +bool_t +xdr_short(xdrs, sp) + register XDR *xdrs; + short *sp; +{ + long l; + + switch (xdrs->x_op) { + + case XDR_ENCODE: + l = (long) *sp; + return (XDR_PUTLONG(xdrs, &l)); + + case XDR_DECODE: + if (!XDR_GETLONG(xdrs, &l)) { + return (FALSE); + } + *sp = (short) l; + return (TRUE); + + case XDR_FREE: + return (TRUE); + } + return (FALSE); +} + +/* + * XDR unsigned short integers + */ +bool_t +xdr_u_short(xdrs, usp) + register XDR *xdrs; + u_short *usp; +{ + u_long l; + + switch (xdrs->x_op) { + + case XDR_ENCODE: + l = (u_long) *usp; + return (XDR_PUTLONG(xdrs, &l)); + + case XDR_DECODE: + if (!XDR_GETLONG(xdrs, &l)) { + return (FALSE); + } + *usp = (u_short) l; + return (TRUE); + + case XDR_FREE: + return (TRUE); + } + return (FALSE); +} + + +/* + * XDR a char + */ +bool_t +xdr_char(xdrs, cp) + XDR *xdrs; + char *cp; +{ + int i; + + i = (*cp); + if (!xdr_int(xdrs, &i)) { + return (FALSE); + } + *cp = i; + return (TRUE); +} + +/* + * XDR an unsigned char + */ +bool_t +xdr_u_char(xdrs, cp) + XDR *xdrs; + u_char *cp; +{ + u_int u; + + u = (*cp); + if (!xdr_u_int(xdrs, &u)) { + return (FALSE); + } + *cp = u; + return (TRUE); +} + +/* + * XDR booleans + */ +bool_t +xdr_bool(xdrs, bp) + register XDR *xdrs; + bool_t *bp; +{ + long lb; + + switch (xdrs->x_op) { + + case XDR_ENCODE: + lb = *bp ? XDR_TRUE : XDR_FALSE; + return (XDR_PUTLONG(xdrs, &lb)); + + case XDR_DECODE: + if (!XDR_GETLONG(xdrs, &lb)) { + return (FALSE); + } + *bp = (lb == XDR_FALSE) ? FALSE : TRUE; + return (TRUE); + + case XDR_FREE: + return (TRUE); + } + return (FALSE); +} + +/* + * XDR enumerations + */ +bool_t +xdr_enum(xdrs, ep) + XDR *xdrs; + enum_t *ep; +{ +#ifndef lint + enum sizecheck { SIZEVAL }; /* used to find the size of an enum */ + + /* + * enums are treated as ints + */ + if (sizeof (enum sizecheck) == sizeof (long)) { + return (xdr_long(xdrs, (long *)ep)); + } else if (sizeof (enum sizecheck) == sizeof (short)) { + return (xdr_short(xdrs, (short *)ep)); + } else { + return (FALSE); + } +#else + (void) (xdr_short(xdrs, (short *)ep)); + return (xdr_long(xdrs, (long *)ep)); +#endif +} + +/* + * XDR opaque data + * Allows the specification of a fixed size sequence of opaque bytes. + * cp points to the opaque object and cnt gives the byte length. + */ +bool_t +xdr_opaque(xdrs, cp, cnt) + register XDR *xdrs; + caddr_t cp; + register u_int cnt; +{ + register u_int rndup; + static char crud[BYTES_PER_XDR_UNIT]; + + /* + * if no data we are done + */ + if (cnt == 0) + return (TRUE); + + /* + * round byte count to full xdr units + */ + rndup = cnt % BYTES_PER_XDR_UNIT; + if (rndup > 0) + rndup = BYTES_PER_XDR_UNIT - rndup; + + if (xdrs->x_op == XDR_DECODE) { + if (!XDR_GETBYTES(xdrs, cp, cnt)) { + return (FALSE); + } + if (rndup == 0) + return (TRUE); + return (XDR_GETBYTES(xdrs, crud, rndup)); + } + + if (xdrs->x_op == XDR_ENCODE) { + if (!XDR_PUTBYTES(xdrs, cp, cnt)) { + return (FALSE); + } + if (rndup == 0) + return (TRUE); + return (XDR_PUTBYTES(xdrs, xdr_zero, rndup)); + } + + if (xdrs->x_op == XDR_FREE) { + return (TRUE); + } + + return (FALSE); +} + + +/* + * XDR implementation using kernel buffers + */ + +#if defined(LIBC_SCCS) && !defined(lint) +/*static char *sccsid = "from: @(#)xdr_mem.c 1.19 87/08/11 Copyr 1984 Sun Micro";*/ +/*static char *sccsid = "from: @(#)xdr_mem.c 2.1 88/07/29 4.0 RPCSRC";*/ +/*static char *rcsid = "Id: xdr_mem.c,v 1.2.4.2 1996/06/05 02:52:04 jkh Exp";*/ +#endif + +/* + * xdr_mem.h, XDR implementation using memory buffers. + * + * Copyright (C) 1984, Sun Microsystems, Inc. + * + * If you have some data to be interpreted as external data representation + * or to be converted to external data representation in a memory buffer, + * then this is the package for you. + * + */ + + +void xdrmbuf_init __P((XDR *, KBuffer *, enum xdr_op)); +static bool_t xdrmbuf_getlong __P((XDR *, long *)); +static bool_t xdrmbuf_putlong __P((XDR *, long *)); +static bool_t xdrmbuf_getbytes __P((XDR *, caddr_t, u_int)); +static bool_t xdrmbuf_putbytes __P((XDR *, caddr_t, u_int)); +static u_int xdrmbuf_getpos __P((XDR *)); + +static struct xdr_ops xdrmbuf_ops = { + xdrmbuf_getlong, + xdrmbuf_putlong, + xdrmbuf_getbytes, + xdrmbuf_putbytes, + xdrmbuf_getpos, + NULL, + NULL, + NULL +}; + +/* + * The procedure xdrmbuf_init initializes a stream descriptor for a + * kernel buffer. + */ +void +xdrmbuf_init(xdrs, m, op) + register XDR *xdrs; + KBuffer *m; + enum xdr_op op; +{ + + xdrs->x_op = op; + xdrs->x_ops = &xdrmbuf_ops; + xdrs->x_base = (caddr_t)m; + KB_DATASTART(m, xdrs->x_private, caddr_t); + xdrs->x_handy = KB_LEN(m); +} + +static bool_t +xdrmbuf_getlong(xdrs, lp) + register XDR *xdrs; + long *lp; +{ + + /* + * See if long is contained in this buffer + */ + if ((xdrs->x_handy -= sizeof(long)) < 0) { + register KBuffer *m; + + /* + * We (currently) don't allow a long to span a buffer + */ + if (xdrs->x_handy != -sizeof(long)) { + printf("xdrmbuf_getlong: data spans buffers\n"); + return (FALSE); + } + + /* + * Try to move to a chained buffer + */ + if ((m = (KBuffer *)(xdrs->x_base)) != NULL) { + m = KB_NEXT(m); + xdrs->x_base = (caddr_t)m; + } + if (m) { + /* + * Setup new buffer's info + */ + KB_DATASTART(m, xdrs->x_private, caddr_t); + if ((xdrs->x_handy = KB_LEN(m) - sizeof(long)) < 0) { + printf("xdrmbuf_getlong: short buffer\n"); + return (FALSE); + } + } else { + /* + * No more buffers + */ + return (FALSE); + } + } + + /* + * Return the long value + */ + *lp = (long)ntohl((u_long)(*((long *)(xdrs->x_private)))); + + /* + * Advance the data stream + */ + xdrs->x_private += sizeof(long); + return (TRUE); +} + +static bool_t +xdrmbuf_putlong(xdrs, lp) + register XDR *xdrs; + long *lp; +{ + + /* + * See if long will fit in this buffer + */ + if ((xdrs->x_handy -= sizeof(long)) < 0) { + register KBuffer *m; + + /* + * We (currently) don't allow a long to span a buffer + */ + if (xdrs->x_handy != -sizeof(long)) { + printf("xdrmbuf_putlong: data spans buffers\n"); + return (FALSE); + } + + /* + * Try to move to a chained buffer + */ + if ((m = (KBuffer *)(xdrs->x_base)) != NULL) { + m = KB_NEXT(m); + xdrs->x_base = (caddr_t)m; + } + if (m) { + /* + * Setup new buffer's info + */ + KB_DATASTART(m, xdrs->x_private, caddr_t); + if ((xdrs->x_handy = KB_LEN(m) - sizeof(long)) < 0) { + printf("xdrmbuf_putlong: short buffer\n"); + return (FALSE); + } + } else { + /* + * No more buffers + */ + return (FALSE); + } + } + + /* + * Store the long value into our buffer + */ + *(long *)xdrs->x_private = (long)htonl((u_long)(*lp)); + + /* + * Advance the data stream + */ + xdrs->x_private += sizeof(long); + return (TRUE); +} + +static bool_t +xdrmbuf_getbytes(xdrs, addr, len) + register XDR *xdrs; + caddr_t addr; + register u_int len; +{ + + while (len > 0) { + u_int copy; + + if (xdrs->x_handy <= 0) { + register KBuffer *m; + + /* + * No data in current buffer, move to a chained buffer + */ + if ((m = (KBuffer *)(xdrs->x_base)) != NULL) { + m = KB_NEXT(m); + xdrs->x_base = (caddr_t)m; + } + if (m) { + /* + * Setup new buffer's info + */ + KB_DATASTART(m, xdrs->x_private, caddr_t); + xdrs->x_handy = KB_LEN(m); + } else { + /* + * No more buffers + */ + return (FALSE); + } + } + + /* + * Copy from buffer to user's space + */ + copy = MIN(len, xdrs->x_handy); + KM_COPY(xdrs->x_private, addr, copy); + + /* + * Update data stream controls + */ + xdrs->x_private += copy; + xdrs->x_handy -= copy; + addr += copy; + len -= copy; + } + return (TRUE); +} + +static bool_t +xdrmbuf_putbytes(xdrs, addr, len) + register XDR *xdrs; + caddr_t addr; + register u_int len; +{ + + while (len > 0) { + u_int copy; + + if (xdrs->x_handy <= 0) { + register KBuffer *m; + + /* + * No data in current buffer, move to a chained buffer + */ + if ((m = (KBuffer *)(xdrs->x_base)) != NULL) { + m = KB_NEXT(m); + xdrs->x_base = (caddr_t)m; + } + if (m) { + /* + * Setup new buffer's info + */ + KB_DATASTART(m, xdrs->x_private, caddr_t); + xdrs->x_handy = KB_LEN(m); + } else { + /* + * No more buffers + */ + return (FALSE); + } + } + + /* + * Copy from user's space into buffer + */ + copy = MIN(len, xdrs->x_handy); + KM_COPY(addr, xdrs->x_private, copy); + + /* + * Update data stream controls + */ + xdrs->x_private += copy; + xdrs->x_handy -= copy; + addr += copy; + len -= copy; + } + return (TRUE); +} + +static u_int +xdrmbuf_getpos(xdrs) + register XDR *xdrs; +{ + + return ((u_int)xdrs->x_private - (u_int)xdrs->x_base); +} + +#endif /* !defined(sun) */ + diff --git a/sys/netatm/spans/spans_msg.c b/sys/netatm/spans/spans_msg.c new file mode 100644 index 0000000..0dc5df9 --- /dev/null +++ b/sys/netatm/spans/spans_msg.c @@ -0,0 +1,1633 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: spans_msg.c,v 1.8 1998/08/26 23:29:09 mks Exp $ + * + */ + +/* + * SPANS Signalling Manager + * --------------------------- + * + * SPANS signalling message processing. + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: spans_msg.c,v 1.8 1998/08/26 23:29:09 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <rpc/rpc.h> +#include "spans_xdr.h" +#include <netatm/spans/spans_var.h> + +/* + * External functions + */ +void xdrmbuf_init __P((XDR *, KBuffer *, enum xdr_op)); + +/* + * Local functions + */ +static void spans_host_link __P((struct spans *, long)); +static void spans_status_ind __P((struct spans *, spans_msg *)); +static void spans_status_rsp __P((struct spans *, spans_msg *)); +static void spans_open_req __P((struct spans *, spans_msg *)); +static void spans_open_rsp __P((struct spans *, spans_msg *)); +static void spans_close_req __P((struct spans *, spans_msg *)); +static void spans_close_rsp __P((struct spans *, spans_msg *)); +static void spans_multi_req __P((struct spans *, spans_msg *)); +static void spans_add_req __P((struct spans *, spans_msg *)); +static void spans_join_req __P((struct spans *, spans_msg *)); +static void spans_leave_req __P((struct spans *, spans_msg *)); +static void spans_vcir_ind __P((struct spans *, spans_msg *)); +static void spans_query_req __P((struct spans *, spans_msg *)); + + +/* + * Called to set status when a status message comes in from a host + * connected back-to-back with us. Check the epoch and, if it has + * changed, set the appropriate state and save updated state + * information. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * host_epoch epoch of host at far end of link + * + * Returns: + * 0 message sent OK + * errno error encountered + * + */ +static void +spans_host_link(spp, host_epoch) + struct spans *spp; + long host_epoch; +{ + struct atm_pif *pip = spp->sp_pif; + + /* + * There's a host at the other end of the link. If its + * epoch has changed, clean up our state and save the + * new information. + */ + if (spp->sp_s_epoch != host_epoch) { + spp->sp_s_epoch = host_epoch; + spans_switch_reset(spp, SPANS_UNI_UP); + spp->sp_addr.address_format = T_ATM_SPANS_ADDR; + spp->sp_addr.address_length = sizeof(spans_addr); + KM_COPY(&pip->pif_macaddr.ma_data[2], + &spp->sp_addr.address[4], + 4); + log(LOG_INFO, + "spans: using SPANS address of %s on interface %s%d\n", + spans_addr_print((spans_addr *)spp->sp_addr.address), + pip->pif_name, + pip->pif_unit); + } +} + +/* + * Send a SPANS signalling message + * + * Called to send a SPANS message. This routine gets a buffer, performs + * XDR processing, and hands the message to the AAL for transmission. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * msg pointer to status message + * + * Returns: + * 0 message sent OK + * errno error encountered + * + */ +int +spans_send_msg(spp, msg) + struct spans *spp; + spans_msg *msg; +{ + int err = 0; + KBuffer *m; + XDR xdrs; + +#ifdef NOTDEF + ATM_DEBUG2("spans_send_msg: msg=0x%x, type=%d\n", msg, + msg->sm_type); + if (msg->sm_type != SPANS_STAT_REQ && + msg->sm_type != SPANS_STAT_IND && + msg->sm_type != SPANS_STAT_RSP) { + printf("spans_send_msg: sending "); + spans_print_msg(msg); + } +#endif + + /* + * If the signalling channel has been closed, don't do anything + */ + if (!spp->sp_conn) + return(ECONNABORTED); + + /* + * Get a buffer + */ + KB_ALLOCPKT(m, sizeof(spans_msg), KB_F_NOWAIT, KB_T_DATA); + if (m == NULL) { + /* No buffer available */ + return(ENOBUFS); + } + + /* + * Convert message to network order + */ + KB_LEN(m) = KB_BFRLEN(m); + xdrmbuf_init(&xdrs, m, XDR_ENCODE); + if (!xdr_spans_msg(&xdrs, msg)) { + log(LOG_ERR, "spans_send_msg: XDR encode failed\n"); + KB_LEN(m) = XDR_GETPOS(&xdrs); + spans_dump_buffer(m); + KB_FREEALL(m); + return(EIO); + } + KB_LEN(m) = XDR_GETPOS(&xdrs); + + /* + * Send the message + */ + err = atm_cm_cpcs_data(spp->sp_conn, m); + if (err) + KB_FREEALL(m); + + return(err); +} + + +/* + * Send an open request + * + * Build and send an open request. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * svp pointer to VCCB for which the request is being sent + * + * Returns: + * none + * + */ +int +spans_send_open_req(spp, svp) + struct spans *spp; + struct spans_vccb *svp; +{ + spans_msg *req; + int err = 0; + + ATM_DEBUG1("spans_send_open_req: svp=0x%x\n", svp); + + /* + * Get memory for a request message + */ + req = (spans_msg *)atm_allocate(&spans_msgpool); + if (req == NULL) { + err = ENOBUFS; + goto done; + } + + /* + * Fill in the request + */ + req->sm_vers = SPANS_VERS_1_0; + req->sm_type = SPANS_OPEN_REQ; + req->sm_open_req.opreq_conn = svp->sv_conn; + req->sm_open_req.opreq_aal = svp->sv_spans_aal; + req->sm_open_req.opreq_desrsrc = svp->sv_spans_qos; + req->sm_open_req.opreq_minrsrc.rsc_peak = 0; + req->sm_open_req.opreq_minrsrc.rsc_mean = 0; + req->sm_open_req.opreq_minrsrc.rsc_burst = 0; + req->sm_open_req.opreq_vpvc.vpf_valid = FALSE; + + /* + * Send the request + */ + err = spans_send_msg(spp, req); + atm_free(req); + +done: + return(err); +} + + +/* + * Send an open response + * + * Build and send a response to an open request or open indication. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * svp pointer to VCCB for which the response is being sent + * result result code to include in the response + * + * Returns: + * none + * + */ +int +spans_send_open_rsp(spp, svp, result) + struct spans *spp; + struct spans_vccb *svp; + spans_result result; +{ + spans_msg *rsp; + int rc; + + ATM_DEBUG2("spans_send_open_rsp: svp=0x%x, result=%d\n", svp, + result); + + /* + * Get memory for a response message + */ + rsp = (spans_msg *)atm_allocate(&spans_msgpool); + if (rsp == NULL) + return(ENOBUFS); + + /* + * Fill in the response + */ + rsp->sm_vers = SPANS_VERS_1_0; + rsp->sm_type = SPANS_OPEN_RSP; + rsp->sm_open_rsp.oprsp_conn = svp->sv_conn; + rsp->sm_open_rsp.oprsp_result = result; + rsp->sm_open_rsp.oprsp_rsrc = svp->sv_spans_qos; + rsp->sm_open_rsp.oprsp_vpvc = + SPANS_PACK_VPIVCI(svp->sv_vpi, svp->sv_vci); + + /* + * Send the response + */ + rc = spans_send_msg(spp, rsp); + atm_free(rsp); + + return(rc); +} + + +/* + * Send a close request + * + * Called to send a close request. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * svp pointer to VCCB for which the close is being sent + * + * Returns: + * none + * + */ +int +spans_send_close_req(spp, svp) + struct spans *spp; + struct spans_vccb *svp; +{ + spans_msg *req; + int err = 0; + + ATM_DEBUG1("spans_send_close_req: svp=0x%x\n", svp); + + /* + * Get memory for a close request + */ + req = (spans_msg *)atm_allocate(&spans_msgpool); + if (req == NULL) { + err = ENOBUFS; + goto done; + } + + /* + * Fill in the request + */ + req->sm_vers = SPANS_VERS_1_0; + if (svp->sv_type & VCC_OUT) { + req->sm_type = SPANS_CLOSE_REQ; + } else if (svp->sv_type & VCC_IN) { + req->sm_type = SPANS_RCLOSE_REQ; + } else { + err = EINVAL; + ATM_DEBUG1( + "spans_send_close_req: invalid VCCB type 0x%x\n", + svp->sv_type); + goto done; + } + req->sm_close_req.clreq_conn = svp->sv_conn; + + /* + * Send the close request + */ + err = spans_send_msg(spp, req); + +done: + if (req) + atm_free(req); + + return(err); +} + + + +/* + * Process a status indication or status request + * + * Called when a status indication or status request is received. + * Processing will be based on the current SPANS state. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * msg pointer to the status message + * + * Returns: + * none + * + */ +static void +spans_status_ind(spp, msg) + struct spans *spp; + spans_msg *msg; +{ + spans_msg *rsp_msg; + struct atm_pif *pip = spp->sp_pif; + + /* + * Reset the probe count. + */ + spp->sp_probe_ct = 0; + + switch (spp->sp_state) { + case SPANS_PROBE: + /* + * Interface just came up, update signalling state + */ + spp->sp_state = SPANS_ACTIVE; + break; + + case SPANS_ACTIVE: + break; + + default: + log(LOG_ERR, "spans: received status msg in state %d\n", + spp->sp_state); + } + + /* + * Process the message + */ + switch (msg->sm_type) { + + case SPANS_STAT_REQ: + /* + * Handle a request from a host at the other end of + * the link. + */ + spans_host_link(spp, msg->sm_stat_req.streq_es_epoch); + break; + + case SPANS_STAT_IND: + + /* + * There's a switch at the other end of the link. If + * its epoch has changed, reset the SPANS state and save + * the new information. + */ + if (spp->sp_s_epoch != + msg->sm_stat_ind.stind_sw_epoch) { + spans_switch_reset(spp, SPANS_UNI_UP); + spp->sp_s_epoch = + msg->sm_stat_ind.stind_sw_epoch; + spp->sp_addr.address_format = T_ATM_SPANS_ADDR; + spp->sp_addr.address_length = + sizeof(spans_addr); + spans_addr_copy(&msg->sm_stat_ind.stind_es_addr, + spp->sp_addr.address); + log(LOG_INFO, + "spans: received SPANS address %s from switch for interface %s%d\n", + spans_addr_print((spans_addr *)spp->sp_addr.address), + pip->pif_name, + pip->pif_unit); + } + break; + + default: + ATM_DEBUG1("spans_status_ind: Invalid message type %d\n", + msg->sm_type); + return; + } + + /* + * Respond to the status request or indication with a + * status response + */ + rsp_msg = (spans_msg *)atm_allocate(&spans_msgpool); + if (rsp_msg == NULL) + return; + rsp_msg->sm_vers = SPANS_VERS_1_0; + rsp_msg->sm_type = SPANS_STAT_RSP; + rsp_msg->sm_stat_rsp.strsp_es_epoch = spp->sp_h_epoch; + spans_addr_copy(spp->sp_addr.address, + &rsp_msg->sm_stat_rsp.strsp_es_addr); + spans_send_msg(spp, rsp_msg); + atm_free(rsp_msg); +} + + + +/* + * Process a status response + * + * Called when a status response is received. + * Processing will be based on the current SPANS state. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * msg pointer to the status response message + * + * Returns: + * none + * + */ +static void +spans_status_rsp(spp, msg) + struct spans *spp; + spans_msg *msg; +{ + + /* + * Reset the probe count. + */ + spp->sp_probe_ct = 0; + + switch (spp->sp_state) { + case SPANS_PROBE: + /* + * Interface just came up, update signalling state + */ + spp->sp_state = SPANS_ACTIVE; + break; + + case SPANS_ACTIVE: + break; + + default: + log(LOG_ERR, "spans: received status msg in state %d\n", + spp->sp_state); + } + + /* + * Process the message + */ + spans_host_link(spp, msg->sm_stat_req.streq_es_epoch); +} + + +/* + * Process an open indication or open request + * + * Called when an open indication or open request is received. + * Processing will be based on the state of the requested connection. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * msg pointer to the open message + * + * Returns: + * none + * + */ +static void +spans_open_req(spp, msg) + struct spans *spp; + spans_msg *msg; +{ + spans_result result = SPANS_OK; + spans_msg *rsp_msg; + struct spans_vccb *svp = NULL; + struct atm_pif *pip; + spans_vpvc vpvc; + int err = 0, vpi, vci; + Aal_t aal; + Atm_attributes call_attrs; + + ATM_DEBUG2("spans_open_req: spp=0x%x, msg=0x%x\n", spp, msg); + + /* + * See if the connection is new + */ + if (svp = spans_find_conn(spp, &msg->sm_open_req.opreq_conn)) { + /* + * We already have a VCCB that matches the connection in + * the request + */ + vpi = SPANS_EXTRACT_VPI(msg->sm_open_req.opreq_vpvc.vpf_vpvc); + vci = SPANS_EXTRACT_VCI(msg->sm_open_req.opreq_vpvc.vpf_vpvc); + if (msg->sm_open_req.opreq_aal == svp->sv_spans_aal && + (!msg->sm_open_req.opreq_vpvc.vpf_valid || + (vpi == svp->sv_vpi && + vci == svp->sv_vci))) { + /* + * VCCB already exists, process depending on + * state + */ + switch (svp->sv_sstate) { + case SPANS_VC_R_POPEN: + /* I'm still thinking about it */ + return; + case SPANS_VC_OPEN: + /* Retransmit the open_rsp */ + break; + case SPANS_VC_POPEN: + case SPANS_VC_CLOSE: + case SPANS_VC_ABORT: + ATM_DEBUG0("spans_open_req: bad VCCB state\n"); + result = SPANS_FAIL; + break; + } + } else { + /* + * VCCB is for same connection, but other + * parameters don't match + */ + ATM_DEBUG0("spans_open_req: VCCB confusion\n"); + result = SPANS_FAIL; + } + svp = NULL; + goto response; + } + + /* + * Verify that the request is for our ATM addres + */ + if (spans_addr_cmp(spp->sp_addr.address, + &msg->sm_open_req.opreq_conn.con_dst)) { + ATM_DEBUG0("spans_open_req: bad destination\n"); + result = SPANS_BADDEST; + goto response; + } + + /* + * See if we recognize the specified AAL + */ + if (!spans_get_local_aal(msg->sm_open_req.opreq_aal, &aal)) { + ATM_DEBUG0("spans_open_req: bad AAL\n"); + result = SPANS_FAIL; + goto response; + } + + /* + * Should verify that we can handle requested connection QOS + */ + + /* + * Select a VPI/VCI for the new connection + */ + if (msg->sm_open_req.opreq_vpvc.vpf_valid) { + /* + * Requestor asked for a certain VPI/VCI. Make sure we + * aren't already using the pair that was asked for. + */ + vpi = SPANS_EXTRACT_VPI(msg->sm_open_req.opreq_vpvc.vpf_vpvc); + vci = SPANS_EXTRACT_VCI(msg->sm_open_req.opreq_vpvc.vpf_vpvc); + if (spans_find_vpvc(spp, vci, vpi, VCC_IN)) { + ATM_DEBUG0("spans_open_req: VPI, VCI busy\n"); + result = SPANS_NOVPVC; + goto response; + } + vpvc = msg->sm_open_req.opreq_vpvc.vpf_vpvc; + } else { + /* + * Allocate a VPI/VCI for this end of the VCC + */ + vpvc = spans_alloc_vpvc(spp); + if (vpvc == 0) { + ATM_DEBUG0("spans_open_req: no VPI, VCI available\n"); + result = SPANS_NOVPVC; + goto response; + } + } + + /* + * Get a new VCCB for the connection + */ + svp = (struct spans_vccb *)atm_allocate(&spans_vcpool); + if (svp == NULL) { + ATM_DEBUG0("spans_open_req: VCCB pool empty\n"); + result = SPANS_NORSC; + goto response; + } + + /* + * Find the physical interface structure + */ + pip = spp->sp_pif; + + /* + * Fill in the VCCB fields that we can at this point + */ + svp->sv_type = VCC_SVC | VCC_IN; + svp->sv_proto = ATM_SIG_SPANS; + svp->sv_sstate = SPANS_VC_R_POPEN; + svp->sv_ustate = VCCU_POPEN; + svp->sv_pif = pip; + svp->sv_nif = pip->pif_nif; + svp->sv_conn = msg->sm_open_req.opreq_conn; + svp->sv_spans_qos = msg->sm_open_req.opreq_desrsrc; + svp->sv_spans_aal = msg->sm_open_req.opreq_aal; + svp->sv_tstamp = time_second; + + svp->sv_vpi = SPANS_EXTRACT_VPI(vpvc); + svp->sv_vci = SPANS_EXTRACT_VCI(vpvc); + + /* + * Put the VCCB on the SPANS queue + */ + ENQUEUE(svp, struct spans_vccb, sv_sigelem, spp->sp_vccq); + + /* + * Set up the ATM attributes block + */ + KM_ZERO(&call_attrs, sizeof(call_attrs)); + call_attrs.nif = svp->sv_nif; + call_attrs.api = CMAPI_CPCS; + + call_attrs.aal.tag = T_ATM_PRESENT; + call_attrs.aal.type = aal; + switch(aal) { + case ATM_AAL3_4: + call_attrs.aal.v.aal4.forward_max_SDU_size = + ATM_NIF_MTU; + call_attrs.aal.v.aal4.backward_max_SDU_size = + ATM_NIF_MTU; + call_attrs.aal.v.aal4.SSCS_type = + T_ATM_NULL; + call_attrs.aal.v.aal4.mid_low = 0; + call_attrs.aal.v.aal4.mid_high = 1023; + break; + case ATM_AAL5: + call_attrs.aal.v.aal5.forward_max_SDU_size = + ATM_NIF_MTU; + call_attrs.aal.v.aal5.backward_max_SDU_size = + ATM_NIF_MTU; + call_attrs.aal.v.aal5.SSCS_type = + T_ATM_NULL; + break; + } + + call_attrs.traffic.tag = T_ATM_PRESENT; + call_attrs.traffic.v.forward.PCR_high_priority = T_ATM_ABSENT; + call_attrs.traffic.v.forward.PCR_all_traffic = + msg->sm_open_req.opreq_desrsrc.rsc_peak * + 1000 / 53; + call_attrs.traffic.v.forward.SCR_high_priority = T_ATM_ABSENT; + call_attrs.traffic.v.forward.SCR_all_traffic = T_ATM_ABSENT; + call_attrs.traffic.v.forward.MBS_high_priority = T_ATM_ABSENT; + call_attrs.traffic.v.forward.MBS_all_traffic = T_ATM_ABSENT; + call_attrs.traffic.v.forward.tagging = T_NO; + call_attrs.traffic.v.backward.PCR_high_priority = T_ATM_ABSENT; + call_attrs.traffic.v.backward.PCR_all_traffic = + call_attrs.traffic.v.forward.PCR_all_traffic; + call_attrs.traffic.v.backward.SCR_high_priority = T_ATM_ABSENT; + call_attrs.traffic.v.backward.SCR_all_traffic = T_ATM_ABSENT; + call_attrs.traffic.v.backward.MBS_high_priority = T_ATM_ABSENT; + call_attrs.traffic.v.backward.MBS_all_traffic = T_ATM_ABSENT; + call_attrs.traffic.v.backward.tagging = T_NO; + call_attrs.traffic.v.best_effort = T_YES; + + call_attrs.bearer.tag = T_ATM_PRESENT; + call_attrs.bearer.v.bearer_class = T_ATM_CLASS_X; + call_attrs.bearer.v.traffic_type = T_ATM_NULL; + call_attrs.bearer.v.timing_requirements = T_ATM_NULL; + call_attrs.bearer.v.clipping_susceptibility = T_NO; + call_attrs.bearer.v.connection_configuration = T_ATM_1_TO_1; + + + call_attrs.bhli.tag = T_ATM_ABSENT; + call_attrs.blli.tag_l2 = T_ATM_ABSENT; + call_attrs.blli.tag_l3 = T_ATM_ABSENT; + call_attrs.llc.tag = T_ATM_ABSENT; + + call_attrs.called.tag = T_ATM_PRESENT; + spans_addr_copy(&msg->sm_open_req.opreq_conn.con_dst, + call_attrs.called.addr.address); + call_attrs.called.addr.address_format = T_ATM_SPANS_ADDR; + call_attrs.called.addr.address_length = sizeof(spans_addr); + call_attrs.called.subaddr.address_format = T_ATM_ABSENT; + call_attrs.called.subaddr.address_length = 0; + + call_attrs.calling.tag = T_ATM_PRESENT; + spans_addr_copy(&msg->sm_open_req.opreq_conn.con_src, + call_attrs.calling.addr.address); + call_attrs.calling.addr.address_format = T_ATM_SPANS_ADDR; + call_attrs.calling.addr.address_length = sizeof(spans_addr); + call_attrs.calling.subaddr.address_format = T_ATM_ABSENT; + call_attrs.calling.subaddr.address_length = 0; + + call_attrs.qos.tag = T_ATM_PRESENT; + call_attrs.qos.v.coding_standard = T_ATM_NETWORK_CODING; + call_attrs.qos.v.forward.qos_class = T_ATM_QOS_CLASS_0; + call_attrs.qos.v.backward.qos_class = T_ATM_QOS_CLASS_0; + + call_attrs.transit.tag = T_ATM_ABSENT; + call_attrs.cause.tag = T_ATM_ABSENT; + + /* + * Notify the connection manager that it has a new channel + */ + err = atm_cm_incoming((struct vccb *)svp, &call_attrs); + if (err) { + ATM_DEBUG0("spans_open_req: atm_cm_incoming returned error\n"); + result = SPANS_FAIL; + goto response; + } + + /* + * Wait for the connection recipient to issue an accept + */ + return; + +response: + /* + * Clean up the VCCB and the atm_conn block if we got them + */ + if (svp) { + DEQUEUE(svp, struct spans_vccb, sv_sigelem, + spp->sp_vccq); + atm_free(svp); + } + + /* + * Some problem was detected with the request. Send a SPANS + * message rejecting the connection. + */ + rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool); + if (rsp_msg == NULL) + return; + + /* + * Fill out the response + */ + rsp_msg->sm_vers = SPANS_VERS_1_0; + rsp_msg->sm_type = SPANS_OPEN_RSP; + rsp_msg->sm_open_rsp.oprsp_conn = msg->sm_open_req.opreq_conn; + rsp_msg->sm_open_rsp.oprsp_result = result; + rsp_msg->sm_open_rsp.oprsp_vpvc = 0; + + /* + * Send the Open Response + */ + spans_send_msg(spp, rsp_msg); + atm_free(rsp_msg); +} + + +/* + * Process an open response or open confirmation + * + * Called when an open response or open confirmation is received. + * Processing will be based on the state of the requested connection and + * the status returned. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * msg pointer to the open response or confirmation message + * + * Returns: + * none + * + */ +static void +spans_open_rsp(spp, msg) + struct spans *spp; + spans_msg *msg; +{ + struct spans_vccb *svp; + + ATM_DEBUG2("spans_open_rsp: spp=0x%x, msg=0x%x\n", spp, msg); + + /* + * Locate the VCCB for the connection + */ + svp = spans_find_conn(spp, &msg->sm_open_rsp.oprsp_conn); + if (svp == NULL) + return; + + /* + * Check the connection state + */ + if ((svp->sv_sstate != SPANS_VC_POPEN && + svp->sv_sstate != SPANS_VC_R_POPEN) || + svp->sv_ustate != VCCU_POPEN) { + ATM_DEBUG2( + "spans_open_rsp: invalid VCCB state, sstate=%d, ustate=%d\n", + svp->sv_sstate, svp->sv_ustate); + return; + } + + /* + * Cancel the retransmission timer + */ + SPANS_VC_CANCEL((struct vccb *) svp); + + /* + * Check the result + */ + switch (msg->sm_open_rsp.oprsp_result) { + + case SPANS_OK: + /* + * Save the assigned VPI and VCI + */ + svp->sv_vpi = SPANS_EXTRACT_VPI(msg->sm_open_rsp.oprsp_vpvc); + svp->sv_vci = SPANS_EXTRACT_VCI(msg->sm_open_rsp.oprsp_vpvc); + + /* + * Update the VCC state and notify the VCC owner + */ + svp->sv_sstate = SPANS_VC_OPEN; + svp->sv_ustate = VCCU_OPEN; + svp->sv_tstamp = time_second; + atm_cm_connected(svp->sv_connvc); + break; + + case SPANS_FAIL: + case SPANS_NOVPVC: + case SPANS_NORSC: + case SPANS_BADDEST: + /* + * Close out the VCCB and notify the user + */ + svp->sv_sstate = SPANS_VC_FREE; + svp->sv_ustate = VCCU_CLOSED; + svp->sv_connvc->cvc_attr.cause.tag = T_ATM_PRESENT; + svp->sv_connvc->cvc_attr.cause.v.coding_standard = + T_ATM_ITU_CODING; + svp->sv_connvc->cvc_attr.cause.v.location = + T_ATM_LOC_USER; + svp->sv_connvc->cvc_attr.cause.v.cause_value = + T_ATM_CAUSE_CALL_REJECTED; + KM_ZERO(svp->sv_connvc->cvc_attr.cause.v.diagnostics, + sizeof(svp->sv_connvc->cvc_attr.cause.v.diagnostics)); + atm_cm_cleared(svp->sv_connvc); + break; + + default: + log(LOG_ERR, "spans: unknown result %d in open rsp\n", + msg->sm_open_rsp.oprsp_result); + break; + } +} + + +/* + * Process a close request from the network + * + * Called when a close request, close indication, rclose request, or + * rclose indication is received. Processing will be based on the + * state of the connection. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * msg pointer to the close request message + * + * Returns: + * none + * + */ +static void +spans_close_req(spp, msg) + struct spans *spp; + spans_msg *msg; +{ + struct spans_vccb *svp; + spans_result result; + spans_msg *rsp_msg; + u_char outstate; + Atm_connvc *cvp; + + ATM_DEBUG2("spans_close_req: spp=0x%x, msg=0x%x\n", spp, msg); + + /* + * Locate the VCCB for the connection + */ + svp = spans_find_conn(spp, &msg->sm_close_req.clreq_conn); + if (svp == NULL) { + result = SPANS_BADDEST; + goto response; + } + + /* + * Check the connection type + */ + if (!(svp->sv_type & VCC_SVC)) { + result = SPANS_FAIL; + goto response; + } + + /* + * Check the connection state + */ + switch (svp->sv_sstate) { + case SPANS_VC_OPEN: + case SPANS_VC_R_POPEN: + case SPANS_VC_POPEN: + /* + * VCC is open or opening--continue + */ + break; + case SPANS_VC_CLOSE: + case SPANS_VC_FREE: + case SPANS_VC_ABORT: + /* + * We're already closing--give a response, since this + * is probably a retransmission + */ + result = SPANS_OK; + goto response; + case SPANS_VC_NULL: + result = SPANS_FAIL; + goto response; + } + + /* + * Cancel the retransmission timer + */ + SPANS_VC_CANCEL((struct vccb *) svp); + + /* + * Close out the VCCB and notify the user + */ + outstate = svp->sv_sstate; + svp->sv_ustate = VCCU_CLOSED; + svp->sv_sstate = SPANS_VC_FREE; + cvp = svp->sv_connvc; + switch (outstate) { + case SPANS_VC_R_POPEN: + spans_free((struct vccb *)svp); + /* FALLTHRU */ + + case SPANS_VC_POPEN: + case SPANS_VC_OPEN: + cvp->cvc_attr.cause.tag = T_ATM_PRESENT; + cvp->cvc_attr.cause.v.coding_standard = + T_ATM_ITU_CODING; + cvp->cvc_attr.cause.v.location = T_ATM_LOC_USER; + cvp->cvc_attr.cause.v.cause_value = + T_ATM_CAUSE_NORMAL_CALL_CLEARING; + KM_ZERO(cvp->cvc_attr.cause.v.diagnostics, + sizeof(cvp->cvc_attr.cause.v.diagnostics)); + atm_cm_cleared(svp->sv_connvc); + break; + } + + result = SPANS_OK; + +response: + /* + * Respond to the SPANS_CLOSE_IND with a SPANS_CLOSE_RSP + */ + rsp_msg = (spans_msg *)atm_allocate(&spans_msgpool); + if (rsp_msg == NULL) + return; + rsp_msg->sm_vers = SPANS_VERS_1_0; + if (msg->sm_type == SPANS_RCLOSE_REQ || + msg->sm_type == SPANS_RCLOSE_IND) { + rsp_msg->sm_type = SPANS_RCLOSE_RSP; + } else { + rsp_msg->sm_type = SPANS_CLOSE_RSP; + } + rsp_msg->sm_close_rsp.clrsp_conn = msg->sm_close_req.clreq_conn; + rsp_msg->sm_close_rsp.clrsp_result = result; + spans_send_msg(spp, rsp_msg); + atm_free(rsp_msg); +} + + +/* + * Process a close response or close confirmation + * + * Called when an close response or close confirmation is received. + * Processing will be based on the state of the requested connection and + * the returned status. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * msg pointer to the close response or confirmation message + * + * Returns: + * none + * + */ +static void +spans_close_rsp(spp, msg) + struct spans *spp; + spans_msg *msg; +{ + struct spans_vccb *svp; + + ATM_DEBUG2("spans_close_rsp: spp=0x%x, msg=0x%x\n", spp, msg); + + /* + * Locate the VCCB for the connection + */ + svp = spans_find_conn(spp, &msg->sm_close_rsp.clrsp_conn); + if (svp == NULL) { + return; + } + + /* + * Check the VCCB state + */ + if (svp->sv_sstate != SPANS_VC_CLOSE) { + return; + } + + /* + * Cancel the retransmission timer + */ + SPANS_VC_CANCEL((struct vccb *) svp); + + /* + * Check the response from the remote end + */ + switch (msg->sm_close_rsp.clrsp_result) { + + case SPANS_OK: + /* + * Mark the VCCB as closed and notify the owner + */ + svp->sv_sstate = SPANS_VC_FREE; + svp->sv_connvc->cvc_attr.cause.tag = T_ATM_PRESENT; + svp->sv_connvc->cvc_attr.cause.v.coding_standard = + T_ATM_ITU_CODING; + svp->sv_connvc->cvc_attr.cause.v.location = + T_ATM_LOC_USER; + svp->sv_connvc->cvc_attr.cause.v.cause_value = + T_ATM_CAUSE_NORMAL_CALL_CLEARING; + KM_ZERO(svp->sv_connvc->cvc_attr.cause.v.diagnostics, + sizeof(svp->sv_connvc->cvc_attr.cause.v.diagnostics)); + atm_cm_cleared(svp->sv_connvc); + break; + + case SPANS_NOVPVC: + case SPANS_BADDEST: + case SPANS_FAIL: + case SPANS_NORSC: + /* + * Mark the VCCB as closed and notify the owner + */ + svp->sv_sstate = SPANS_VC_FREE; + svp->sv_connvc->cvc_attr.cause.tag = T_ATM_PRESENT; + svp->sv_connvc->cvc_attr.cause.v.coding_standard = + T_ATM_ITU_CODING; + svp->sv_connvc->cvc_attr.cause.v.location = + T_ATM_LOC_USER; + svp->sv_connvc->cvc_attr.cause.v.cause_value = + T_ATM_CAUSE_UNSPECIFIED_NORMAL; + KM_ZERO(svp->sv_connvc->cvc_attr.cause.v.diagnostics, + sizeof(svp->sv_connvc->cvc_attr.cause.v.diagnostics)); + atm_cm_cleared(svp->sv_connvc); + break; + + default: + log(LOG_ERR, "spans: unknown result %d in close rsp\n", + msg->sm_close_rsp.clrsp_result); + break; + } +} + + +/* + * Process a multi request or multi indication + * + * Called when a multi response or multi confirmation is received. We + * don't support multicast channels, so we just reject the request. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * msg pointer to the multi request or indication message + * + * Returns: + * none + * + */ +static void +spans_multi_req(spp, msg) + struct spans *spp; + spans_msg *msg; +{ + spans_msg *rsp_msg; + + /* + * Get memory for a SPANS_MULTI_RSP message. + */ + rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool); + if (rsp_msg == NULL) + return; + + /* + * Fill out the response. + */ + rsp_msg->sm_vers = SPANS_VERS_1_0; + rsp_msg->sm_type = SPANS_MULTI_RSP; + rsp_msg->sm_multi_rsp.mursp_conn = msg->sm_multi_req.mureq_conn; + rsp_msg->sm_multi_rsp.mursp_result = SPANS_FAIL; + rsp_msg->sm_multi_rsp.mursp_rsrc = msg->sm_multi_req.mureq_desrsrc; + rsp_msg->sm_multi_rsp.mursp_vpvc = 0; + + /* + * Send the response and free the message. + */ + (void) spans_send_msg(spp, rsp_msg); + atm_free(rsp_msg); +} + + +/* + * Process an add request or add indication + * + * Called when an add response or add confirmation is received. We + * don't support multicast channels, so we just reject the request. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * msg pointer to the add request or indication message + * + * Returns: + * none + * + */ +static void +spans_add_req(spp, msg) + struct spans *spp; + spans_msg *msg; +{ + spans_msg *rsp_msg; + + /* + * Get memory for a SPANS_ADD_RSP message. + */ + rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool); + if (rsp_msg == NULL) + return; + + /* + * Fill out the response. + */ + rsp_msg->sm_vers = SPANS_VERS_1_0; + rsp_msg->sm_type = SPANS_ADD_RSP; + rsp_msg->sm_add_rsp.adrsp_conn = msg->sm_add_req.adreq_desconn; + rsp_msg->sm_add_rsp.adrsp_result = SPANS_FAIL; + rsp_msg->sm_add_rsp.adrsp_rsrc.rsc_peak = 0; + rsp_msg->sm_add_rsp.adrsp_rsrc.rsc_mean = 0; + rsp_msg->sm_add_rsp.adrsp_rsrc.rsc_burst = 0; + + /* + * Send the response and free the message. + */ + (void) spans_send_msg(spp, rsp_msg); + atm_free(rsp_msg); +} + + +/* + * Process a join request + * + * Called when an join request is received. We don't support group + * addresses, so we just reject the request. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * msg pointer to the join request message + * + * Returns: + * none + * + */ +static void +spans_join_req(spp, msg) + struct spans *spp; + spans_msg *msg; +{ + spans_msg *rsp_msg; + + /* + * Get memory for a SPANS_JOIN_CNF message. + */ + rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool); + if (rsp_msg == NULL) + return; + + /* + * Fill out the response. + */ + rsp_msg->sm_vers = SPANS_VERS_1_0; + rsp_msg->sm_type = SPANS_JOIN_CNF; + spans_addr_copy(&msg->sm_join_req.jnreq_addr, + &rsp_msg->sm_join_cnf.jncnf_addr); + rsp_msg->sm_join_cnf.jncnf_result = SPANS_FAIL; + + /* + * Send the response and free the message. + */ + (void) spans_send_msg(spp, rsp_msg); + atm_free(rsp_msg); +} + + +/* + * Process a leave request + * + * Called when an leave request is received. We don't support group + * addresses, so we just reject the request. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * msg pointer to the leave request message + * + * Returns: + * none + * + */ +static void +spans_leave_req(spp, msg) + struct spans *spp; + spans_msg *msg; +{ + spans_msg *rsp_msg; + + /* + * Get memory for a SPANS_LEAVE_CNF message. + */ + rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool); + if (rsp_msg == NULL) + return; + + /* + * Fill out the response. + */ + rsp_msg->sm_vers = SPANS_VERS_1_0; + rsp_msg->sm_type = SPANS_LEAVE_CNF; + spans_addr_copy(&msg->sm_leave_req.lvreq_addr, + &rsp_msg->sm_leave_cnf.lvcnf_addr); + rsp_msg->sm_leave_cnf.lvcnf_result = SPANS_FAIL; + + /* + * Send the response and free the message. + */ + (void) spans_send_msg(spp, rsp_msg); + atm_free(rsp_msg); +} + + +/* + * Process a VCI range indication + * + * Called when a VCI range indication is received. Adjust the VCI + * bounds if they have changed. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * msg pointer to the VCI range indication message + * + * Returns: + * none + * + */ +static void +spans_vcir_ind(spp, msg) + struct spans *spp; + spans_msg *msg; +{ + /* + * Adjust the limits if they have changed + */ + if (msg->sm_vcir_ind.vrind_min != spp->sp_min_vci) { + spp->sp_min_vci = + (msg->sm_vcir_ind.vrind_min < + SPANS_MIN_VCI ? + SPANS_MIN_VCI : + msg->sm_vcir_ind.vrind_min); + } + if (msg->sm_vcir_ind.vrind_max != spp->sp_max_vci) { + spp->sp_max_vci = + (msg->sm_vcir_ind.vrind_max > + SPANS_MAX_VCI ? + SPANS_MAX_VCI : + msg->sm_vcir_ind.vrind_max); + } +} + + +/* + * Process a query request + * + * Called when a query request is received. Respond with the + * appropriate query response. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * msg pointer to the VCI range indication message + * + * Returns: + * none + * + */ +static void +spans_query_req(spp, msg) + struct spans *spp; + spans_msg *msg; +{ + struct spans_vccb *svp = NULL; + spans_msg *rsp_msg; + + ATM_DEBUG1("spans_query_req: msg=0x%x\n", msg); + + /* + * Ignore an end-to-end query + */ + if (msg->sm_query_req.qyreq_type == SPANS_QUERY_END_TO_END) { + return; + } + + /* + * Get memory for a SPANS_QUERY_RSP message. + */ + rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool); + if (rsp_msg == NULL) + return; + + /* + * Fill out the response. + */ + rsp_msg->sm_vers = SPANS_VERS_1_0; + rsp_msg->sm_type = SPANS_QUERY_RSP; + rsp_msg->sm_query_rsp.qyrsp_conn = msg->sm_query_req.qyreq_conn; + rsp_msg->sm_query_rsp.qyrsp_type = msg->sm_query_req.qyreq_type; + rsp_msg->sm_query_rsp.qyrsp_data = 0; + + /* + * Get the state of the requested connection + */ + svp = spans_find_conn(spp, &msg->sm_query_req.qyreq_conn); + if (svp) { + switch(svp->sv_sstate) { + case SPANS_VC_NULL: + case SPANS_VC_FREE: + rsp_msg->sm_query_rsp.qyrsp_state = + SPANS_CONN_CLOSED; + break; + case SPANS_VC_OPEN: + rsp_msg->sm_query_rsp.qyrsp_state = + SPANS_CONN_OPEN; + break; + case SPANS_VC_POPEN: + case SPANS_VC_R_POPEN: + rsp_msg->sm_query_rsp.qyrsp_state = + SPANS_CONN_OPEN_PEND; + break; + case SPANS_VC_CLOSE: + case SPANS_VC_ABORT: + rsp_msg->sm_query_rsp.qyrsp_state = + SPANS_CONN_CLOSE_PEND; + break; + case SPANS_VC_ACTIVE: + case SPANS_VC_ACT_DOWN: + /* + * VCCB is for a PVC (shouldn't happen) + */ + atm_free(rsp_msg); + return; + } + } else { + /* + * No VCCB found--connection doesn't exist + */ + rsp_msg->sm_query_rsp.qyrsp_state = SPANS_CONN_CLOSED; + } + + /* + * Send the response and free the message. + */ + (void) spans_send_msg(spp, rsp_msg); + atm_free(rsp_msg); +} + + +/* + * Process a SPANS signalling message + * + * Called when a SPANS message is received. The message is converted + * into internal format with XDR and decoded by calling the appropriate + * mesage handling routine. Unrecognized and unexpected messages are + * logged. + * + * Arguments: + * spp pointer to SPANS protocol instance block + * m pointer to a buffer chain containing the SPANS message + * + * Returns: + * none + * + */ +void +spans_rcv_msg(spp, m) + struct spans *spp; + KBuffer *m; +{ + XDR xdrs; + spans_msg *msg; + + /* + * Get storage for the message + */ + msg = (spans_msg *)atm_allocate(&spans_msgpool); + if (msg == NULL) { + return; + } + + /* + * Convert the message from network order to internal format + */ + xdrmbuf_init(&xdrs, m, XDR_DECODE); + if (!xdr_spans_msg(&xdrs, msg)) { + log(LOG_ERR, "spans_rcv_msg: XDR decode failed\n"); + spans_dump_buffer(m); + goto done; + } + +#ifdef NOTDEF + /* + * Debug--print some information about the message + */ + if (msg->sm_type != SPANS_STAT_REQ && + msg->sm_type != SPANS_STAT_IND && + msg->sm_type != SPANS_STAT_RSP) { + printf("spans_rcv_msg: got "); + spans_print_msg(msg); + } +#endif + + /* + * Verify the message sm_vers + */ + if (msg->sm_vers != SPANS_VERS_1_0) { + log(LOG_ERR, "spans: invalid message version 0x%x\n", + msg->sm_vers); + } + + /* + * Ignore the message if SPANS isn't up yet + */ + if (spp->sp_state != SPANS_ACTIVE && + (spp->sp_state != SPANS_PROBE || + (msg->sm_type != SPANS_STAT_REQ && + msg->sm_type != SPANS_STAT_RSP && + msg->sm_type != SPANS_STAT_IND))) { + goto done; + } + + /* + * Process the message based on its type + */ + switch(msg->sm_type) { + case SPANS_STAT_REQ: + spans_status_ind(spp, msg); + break; + case SPANS_STAT_IND: + spans_status_ind(spp, msg); + break; + case SPANS_STAT_RSP: + spans_status_rsp(spp, msg); + break; + case SPANS_OPEN_REQ: + spans_open_req(spp, msg); + break; + case SPANS_OPEN_IND: + spans_open_req(spp, msg); + break; + case SPANS_OPEN_RSP: + spans_open_rsp(spp, msg); + break; + case SPANS_OPEN_CNF: + spans_open_rsp(spp, msg); + break; + case SPANS_CLOSE_REQ: + spans_close_req(spp, msg); + break; + case SPANS_CLOSE_IND: + spans_close_req(spp, msg); + break; + case SPANS_CLOSE_RSP: + spans_close_rsp(spp, msg); + break; + case SPANS_CLOSE_CNF: + spans_close_rsp(spp, msg); + break; + case SPANS_RCLOSE_REQ: + spans_close_req(spp, msg); + break; + case SPANS_RCLOSE_IND: + spans_close_req(spp, msg); + break; + case SPANS_RCLOSE_RSP: + spans_close_rsp(spp, msg); + break; + case SPANS_RCLOSE_CNF: + spans_close_rsp(spp, msg); + break; + case SPANS_MULTI_REQ: + spans_multi_req(spp, msg); + break; + case SPANS_MULTI_IND: + spans_multi_req(spp, msg); + break; + case SPANS_MULTI_RSP: + log(LOG_ERR, + "spans: unexpected message (multi_rsp)\n"); + break; + case SPANS_MULTI_CNF: + log(LOG_ERR, + "spans: unexpected message (multi_conf)\n"); + break; + case SPANS_ADD_REQ: + spans_add_req(spp, msg); + break; + case SPANS_ADD_IND: + spans_add_req(spp, msg); + break; + case SPANS_ADD_RSP: + log(LOG_ERR, + "spans: unexpected message (add_rsp)\n"); + break; + case SPANS_ADD_CNF: + log(LOG_ERR, "spans: unexpected message (add_conf)\n"); + break; + case SPANS_JOIN_REQ: + spans_join_req(spp, msg); + break; + case SPANS_JOIN_CNF: + log(LOG_ERR, "spans: unexpected message (join_conf)\n"); + break; + case SPANS_LEAVE_REQ: + spans_leave_req(spp, msg); + break; + case SPANS_LEAVE_CNF: + log(LOG_ERR, + "spans: unexpected message (leave_conf)\n"); + break; + case SPANS_VCIR_IND: + spans_vcir_ind(spp, msg); + break; + case SPANS_QUERY_REQ: + spans_query_req(spp, msg); + break; + case SPANS_QUERY_RSP: + log(LOG_ERR, + "spans: unexpected message (query_rsp)\n"); + break; + default: + log(LOG_ERR, "spans: unknown SPANS message type %d\n", + msg->sm_type); + } + +done: + /* + * Free the incoming message (both buffer and internal format) if + * necessary. + */ + if (msg) + atm_free(msg); + if (m) + KB_FREEALL(m); +} diff --git a/sys/netatm/spans/spans_print.c b/sys/netatm/spans/spans_print.c new file mode 100644 index 0000000..60dc670 --- /dev/null +++ b/sys/netatm/spans/spans_print.c @@ -0,0 +1,1062 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: spans_print.c,v 1.4 1997/05/06 22:17:11 mks Exp $ + * + */ + +/* + * SPANS Signalling Manager + * --------------------------- + * + * SPANS Print Routines. + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: spans_print.c,v 1.4 1997/05/06 22:17:11 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include "spans_xdr.h" +#include <netatm/spans/spans_var.h> + +/* + * If LONGPRINT is defined, every field of the SPANS message will be + * printed. If not, a shorter summary (useful for debugging without + * swamping the console) is printed. + */ +/* #define LONGPRINT */ + +/* + * Local functions + */ +static void inc_indent __P((void)); +static void dec_indent __P((void)); +static void spans_aal_str __P((spans_aal *, char *)); +static void spans_result_str __P((spans_result *, char *)); +static void spans_msgtype_str __P((spans_msgtype *, char *)); +static void spans_query_type_str __P((spans_query_type *, char *)); +static void spans_state_str __P((spans_query_type *, char *)); +static void spans_print_version __P((spans_version *)); +static void spans_print_vpvc __P((spans_vpvc *)); +static void spans_print_vpvc_pref __P((spans_vpvc_pref *)); +static void spans_print_addr __P((spans_addr *)); +static void spans_print_sap __P((spans_sap *)); +static void spans_print_atm_conn __P((spans_atm_conn *)); +static void spans_print_resrc __P((spans_resrc *)); +static void spans_print_aal __P((spans_aal *)); +static void spans_print_result __P((spans_result *)); +static void spans_print_msgtype __P((spans_msgtype *)); +static void spans_print_parm_stat_req __P((spans_parm_stat_req *)); +static void spans_print_parm_stat_ind __P((spans_parm_stat_ind *)); +static void spans_print_parm_stat_rsp __P((spans_parm_stat_rsp *)); +static void spans_print_parm_open_req __P((spans_parm_open_req *)); +static void spans_print_parm_open_ind __P((spans_parm_open_ind *)); +static void spans_print_parm_open_rsp __P((spans_parm_open_rsp *)); +static void spans_print_parm_open_cnf __P((spans_parm_open_cnf *)); +static void spans_print_parm_close_req __P((spans_parm_close_req *)); +static void spans_print_parm_close_ind __P((spans_parm_close_ind *)); +static void spans_print_parm_close_rsp __P((spans_parm_close_rsp *)); +static void spans_print_parm_close_cnf __P((spans_parm_close_cnf *)); +static void spans_print_parm_rclose_req __P((spans_parm_rclose_req *)); +static void spans_print_parm_rclose_ind __P((spans_parm_rclose_ind *)); +static void spans_print_parm_rclose_rsp __P((spans_parm_rclose_rsp *)); +static void spans_print_parm_rclose_cnf __P((spans_parm_rclose_cnf *)); +static void spans_print_parm_multi_req __P((spans_parm_multi_req *)); +static void spans_print_parm_multi_ind __P((spans_parm_multi_ind *)); +static void spans_print_parm_multi_rsp __P((spans_parm_multi_rsp *)); +static void spans_print_parm_multi_cnf __P((spans_parm_multi_cnf *)); +static void spans_print_parm_add_req __P((spans_parm_add_req *)); +static void spans_print_parm_add_ind __P((spans_parm_add_ind *)); +static void spans_print_parm_add_rsp __P((spans_parm_add_rsp *)); +static void spans_print_parm_add_cnf __P((spans_parm_add_cnf *)); +static void spans_print_parm_join_req __P((spans_parm_join_req *)); +static void spans_print_parm_join_cnf __P((spans_parm_join_cnf *)); +static void spans_print_parm_leave_req __P((spans_parm_leave_req *)); +static void spans_print_parm_leave_cnf __P((spans_parm_leave_cnf *)); +static void spans_print_parm_vcir_ind __P((spans_parm_vcir_ind *)); +static void spans_print_parm_query_req __P((spans_parm_query_req *)); +static void spans_print_parm_query_rsp __P((spans_parm_query_rsp *)); +static void spans_print_msgbody __P((spans_msgbody *)); + + +/* + * Local variables + */ +#define MAX_INDENT 10 +#define INIT_INDENT &indent_str[MAX_INDENT] +static char *spans_indent; +static char indent_str[11] = " "; + +static void +inc_indent() +{ + if (spans_indent != &indent_str[0]) { + *spans_indent--; + } +} + +static void +dec_indent() +{ + if (spans_indent != INIT_INDENT) { + *spans_indent++; + } +} + +static void +spans_aal_str(objp, dest) + spans_aal *objp; + char *dest; +{ + static char *aal_names[] = { + "SPANS_AAL0", + "SPANS_AAL1", + "SPANS_AAL2", + "SPANS_AAL3", + "SPANS_AAL4", + "SPANS_AAL5" + }; + + if (*objp < SPANS_AAL0 || *objp > SPANS_AAL5) { + sprintf(dest, "Invalid (%d)", (int)*objp); + } else { + sprintf(dest, "%s (%d)", aal_names[(int)*objp], + (int)*objp); + } +} + +static void +spans_result_str(objp, dest) + spans_result *objp; + char *dest; +{ + static char *result_names[] = { + "SPANS_OK", + "SPANS_FAIL", + "SPANS_NOVPVC", + "SPANS_NORSC", + "SPANS_BADDEST" + }; + + if (*objp < SPANS_OK || *objp > SPANS_BADDEST) { + sprintf(dest, "Invalid (%d)", (int)*objp); + } else { + sprintf(dest, "%s (%d)", + result_names[(int)*objp], (int)*objp); + } +} + +static void +spans_msgtype_str(objp, dest) + spans_msgtype *objp; + char *dest; +{ + int i; + + static struct { + spans_msgtype type; + char *name; + } msgtype_names[] = { + { SPANS_STAT_REQ, "SPANS_STAT_REQ" }, + { SPANS_STAT_IND, "SPANS_STAT_IND" }, + { SPANS_STAT_RSP, "SPANS_STAT_RSP" }, + { SPANS_OPEN_REQ, "SPANS_OPEN_REQ" }, + { SPANS_OPEN_IND, "SPANS_OPEN_IND" }, + { SPANS_OPEN_RSP, "SPANS_OPEN_RSP" }, + { SPANS_OPEN_CNF, "SPANS_OPEN_CNF" }, + { SPANS_CLOSE_REQ, "SPANS_CLOSE_REQ" }, + { SPANS_CLOSE_IND, "SPANS_CLOSE_IND" }, + { SPANS_CLOSE_RSP, "SPANS_CLOSE_RSP" }, + { SPANS_CLOSE_CNF, "SPANS_CLOSE_CNF" }, + { SPANS_RCLOSE_REQ, "SPANS_RCLOSE_REQ" }, + { SPANS_RCLOSE_IND, "SPANS_RCLOSE_IND" }, + { SPANS_RCLOSE_RSP, "SPANS_RCLOSE_RSP" }, + { SPANS_RCLOSE_CNF, "SPANS_RCLOSE_CNF" }, + { SPANS_MULTI_REQ, "SPANS_MULTI_REQ" }, + { SPANS_MULTI_IND, "SPANS_MULTI_IND" }, + { SPANS_MULTI_RSP, "SPANS_MULTI_RSP" }, + { SPANS_MULTI_CNF, "SPANS_MULTI_CNF" }, + { SPANS_ADD_REQ, "SPANS_ADD_REQ" }, + { SPANS_ADD_IND, "SPANS_ADD_IND" }, + { SPANS_ADD_RSP, "SPANS_ADD_RSP" }, + { SPANS_ADD_CNF, "SPANS_ADD_CNF" }, + { SPANS_JOIN_REQ, "SPANS_JOIN_REQ" }, + { SPANS_JOIN_CNF, "SPANS_JOIN_CNF" }, + { SPANS_LEAVE_REQ, "SPANS_LEAVE_REQ" }, + { SPANS_LEAVE_CNF, "SPANS_LEAVE_CNF" }, + { SPANS_VCIR_IND, "SPANS_VCIR_IND" }, + { SPANS_QUERY_REQ, "SPANS_QUERY_REQ" }, + { SPANS_QUERY_RSP, "SPANS_QUERY_RSP" }, + { 0, (char *) 0 } + }; + + /* + * Search the name table for the specified type + */ + for (i=0; msgtype_names[i].name; i++) { + if (*objp == msgtype_names[i].type) { + sprintf(dest, "%s (%d)", + msgtype_names[i].name, + (int)*objp); + return; + } + } + + /* + * Type was not found--return an error indicator + */ + sprintf(dest, "Invalid (%d)", (int)*objp); +} + +static void +spans_query_type_str(objp, dest) + spans_query_type *objp; + char *dest; +{ + static char *query_names[] = { + "SPANS_QUERY_NORMAL", + "SPANS_QUERY_DEBUG", + "SPANS_QUERY_END_TO_END" + }; + + if (*objp < SPANS_QUERY_NORMAL || + *objp > SPANS_QUERY_END_TO_END) { + sprintf(dest, "Invalid (%d)", (int)*objp); + } else { + sprintf(dest, "%s (%d)", query_names[(int)*objp], + (int)*objp); + } +} + +static void +spans_state_str(objp, dest) + spans_query_type *objp; + char *dest; +{ + static char *state_names[] = { + "SPANS_CONN_OPEN", + "SPANS_CONN_OPEN_PEND", + "SPANS_CONN_CLOSE_PEND", + "SPANS_CONN_CLOSED" + }; + + if (*objp < SPANS_CONN_OPEN || *objp > SPANS_CONN_CLOSED) { + sprintf(dest, "Invalid (%d)", (int)*objp); + } else { + sprintf(dest, "%s (%d)", state_names[(int)*objp], + (int)*objp); + } +} + +#ifdef LONGPRINT + +static void +spans_print_version(objp) + spans_version *objp; +{ + printf("%sspans_version 0x%x\n", spans_indent, *objp); +} + +static void +spans_print_vpvc(objp) + spans_vpvc *objp; +{ + printf("%sVP/VC %d/%d\n", spans_indent, + SPANS_EXTRACT_VPI(*objp), + SPANS_EXTRACT_VCI(*objp)); +} + +static void +spans_print_vpvc_pref(objp) + spans_vpvc_pref *objp; +{ + printf("%sspans_vpvc_pref\n", spans_indent); + inc_indent(); + printf("%s%s\n", spans_indent, + (objp->vpf_valid ? "Valid" : "Not valid")); + spans_print_vpvc(&objp->vpf_vpvc); + dec_indent(); +} + +static void +spans_print_addr(objp) + spans_addr *objp; +{ + char addr_str[80]; + + strncpy(addr_str, spans_addr_print(objp), sizeof(addr_str)); + printf("%sspans_addr %s\n", spans_indent, addr_str); +} + +static void +spans_print_sap(objp) + spans_sap *objp; +{ + printf("%sSAP %d\n", spans_indent, *objp); +} + +static void +spans_print_atm_conn(objp) + spans_atm_conn *objp; +{ + printf("%sspans_atm_conn\n", spans_indent); + inc_indent(); + spans_print_addr(&objp->con_dst); + spans_print_addr(&objp->con_src); + spans_print_sap(&objp->con_dsap); + spans_print_sap(&objp->con_ssap); + dec_indent(); +} + +static void +spans_print_resrc(objp) + spans_resrc *objp; +{ + printf("%sspans_resrc\n", spans_indent); + inc_indent(); + printf("%srsc_peak %d\n", spans_indent, objp->rsc_peak); + printf("%srsc_mean %d\n", spans_indent, objp->rsc_mean); + printf("%srsc_burst %d\n", spans_indent, objp->rsc_burst); + dec_indent(); +} + +static void +spans_print_aal(objp) + spans_aal *objp; +{ + char aal_str[80]; + + spans_aal_str(objp, aal_str); + printf("%sspans_aal %s\n", spans_indent, aal_str); +} + +static void +spans_print_result(objp) + spans_result *objp; +{ + char result_str[80]; + + spans_result_str(objp, result_str); + printf("%sspans_result %s\n", spans_indent, result_str); +} + +static void +spans_print_msgtype(objp) + spans_msgtype *objp; +{ + char msgtype_str[80]; + + spans_msgtype_str(objp, msgtype_str); + printf("%sspans_msgtype %s\n", spans_indent, msgtype_str); +} + +static void +spans_print_parm_stat_req(objp) + spans_parm_stat_req *objp; +{ + printf("%sspans_parm_stat_req\n", spans_indent); + inc_indent(); + printf("%sstreq_es_epoch %d\n", spans_indent, + objp->streq_es_epoch); + dec_indent(); +} + +static void +spans_print_parm_stat_ind(objp) + spans_parm_stat_ind *objp; +{ + printf("%sspans_parm_stat_ind\n", spans_indent); + inc_indent(); + printf("%sstind_sw_epoch %d\n", spans_indent, + objp->stind_sw_epoch); + spans_print_addr(&objp->stind_es_addr); + spans_print_addr(&objp->stind_sw_addr); + dec_indent(); +} + +static void +spans_print_parm_stat_rsp(objp) + spans_parm_stat_rsp *objp; +{ + printf("%sspans_parm_stat_rsp\n", spans_indent); + inc_indent(); + printf("%sstrsp_es_epoch %d\n", spans_indent, + objp->strsp_es_epoch); + spans_print_addr(&objp->strsp_es_addr); + dec_indent(); +} + +static void +spans_print_parm_open_req(objp) + spans_parm_open_req *objp; +{ + printf("%sspans_parm_open_req\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->opreq_conn); + spans_print_aal(&objp->opreq_aal); + spans_print_resrc(&objp->opreq_desrsrc); + spans_print_resrc(&objp->opreq_minrsrc); + spans_print_vpvc_pref(&objp->opreq_vpvc); + dec_indent(); +} + +static void +spans_print_parm_open_ind(objp) + spans_parm_open_ind *objp; +{ + printf("%sspans_parm_open_ind\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->opind_conn); + spans_print_aal(&objp->opind_aal); + spans_print_resrc(&objp->opind_desrsrc); + spans_print_resrc(&objp->opind_minrsrc); + spans_print_vpvc_pref(&objp->opind_vpvc); + dec_indent(); +} + +static void +spans_print_parm_open_rsp(objp) + spans_parm_open_rsp *objp; +{ + printf("%sspans_parm_open_rsp\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->oprsp_conn); + spans_print_result(&objp->oprsp_result); + spans_print_resrc(&objp->oprsp_rsrc); + spans_print_vpvc(&objp->oprsp_vpvc); + dec_indent(); +} + +static void +spans_print_parm_open_cnf(objp) + spans_parm_open_cnf *objp; +{ + printf("%sspans_parm_open_cnf\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->opcnf_conn); + spans_print_result(&objp->opcnf_result); + spans_print_resrc(&objp->opcnf_rsrc); + spans_print_vpvc(&objp->opcnf_vpvc); + dec_indent(); +} + +static void +spans_print_parm_close_req(objp) + spans_parm_close_req *objp; +{ + printf("%sspans_parm_close_req\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->clreq_conn); + dec_indent(); +} + +static void +spans_print_parm_close_ind(objp) + spans_parm_close_ind *objp; +{ + printf("%sspans_parm_close_ind\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->clind_conn); + dec_indent(); +} + +static void +spans_print_parm_close_rsp(objp) + spans_parm_close_rsp *objp; +{ + printf("%sspans_parm_close_rsp\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->clrsp_conn); + spans_print_result(&objp->clrsp_result); + dec_indent(); +} + +static void +spans_print_parm_close_cnf(objp) + spans_parm_close_cnf *objp; +{ + printf("%sspans_parm_close_cnf\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->clcnf_conn); + spans_print_result(&objp->clcnf_result); + dec_indent(); +} + +static void +spans_print_parm_rclose_req(objp) + spans_parm_rclose_req *objp; +{ + printf("%sspans_parm_rclose_req\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->rcreq_conn); + dec_indent(); +} + +static void +spans_print_parm_rclose_ind(objp) + spans_parm_rclose_ind *objp; +{ + printf("%sspans_parm_rclose_ind\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->rcind_conn); + dec_indent(); +} + +static void +spans_print_parm_rclose_rsp(objp) + spans_parm_rclose_rsp *objp; +{ + printf("%sspans_parm_rclose_rsp\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->rcrsp_conn); + spans_print_result(&objp->rcrsp_result); + dec_indent(); +} + +static void +spans_print_parm_rclose_cnf(objp) + spans_parm_rclose_cnf *objp; +{ + printf("%sspans_parm_rclose_cnf\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->rccnf_conn); + spans_print_result(&objp->rccnf_result); + dec_indent(); +} + +static void +spans_print_parm_multi_req(objp) + spans_parm_multi_req *objp; +{ + printf("%sspans_parm_multi_req\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->mureq_conn); + spans_print_aal(&objp->mureq_aal); + spans_print_resrc(&objp->mureq_desrsrc); + spans_print_resrc(&objp->mureq_minrsrc); + spans_print_vpvc(&objp->mureq_vpvc); + dec_indent(); +} + +static void +spans_print_parm_multi_ind(objp) + spans_parm_multi_ind *objp; +{ + printf("%sspans_parm_multi_ind\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->muind_conn); + spans_print_aal(&objp->muind_aal); + spans_print_resrc(&objp->muind_desrsrc); + spans_print_resrc(&objp->muind_minrsrc); + spans_print_vpvc(&objp->muind_vpvc); + dec_indent(); +} + +static void +spans_print_parm_multi_rsp(objp) + spans_parm_multi_rsp *objp; +{ + printf("%sspans_parm_multi_rsp\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->mursp_conn); + spans_print_result(&objp->mursp_result); + spans_print_resrc(&objp->mursp_rsrc); + spans_print_vpvc(&objp->mursp_vpvc); + dec_indent(); +} + +static void +spans_print_parm_multi_cnf(objp) + spans_parm_multi_cnf *objp; +{ + printf("%sspans_parm_multi_cnf\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->mucnf_conn); + spans_print_result(&objp->mucnf_result); + spans_print_resrc(&objp->mucnf_rsrc); + spans_print_vpvc(&objp->mucnf_vpvc); + dec_indent(); +} + +static void +spans_print_parm_add_req(objp) + spans_parm_add_req *objp; +{ + printf("%sspans_parm_add_req\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->adreq_desconn); + spans_print_atm_conn(&objp->adreq_xstconn); + dec_indent(); +} + +static void +spans_print_parm_add_ind(objp) + spans_parm_add_ind *objp; +{ + printf("%sspans_parm_add_ind\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->adind_desconn); + spans_print_atm_conn(&objp->adind_xstconn); + dec_indent(); +} + +static void +spans_print_parm_add_rsp(objp) + spans_parm_add_rsp *objp; +{ + printf("%sspans_parm_add_rsp\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->adrsp_conn); + spans_print_result(&objp->adrsp_result); + spans_print_resrc(&objp->adrsp_rsrc); + dec_indent(); +} + +static void +spans_print_parm_add_cnf(objp) + spans_parm_add_cnf *objp; +{ + printf("%sspans_parm_add_cnf\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->adcnf_conn); + spans_print_result(&objp->adcnf_result); + spans_print_resrc(&objp->adcnf_rsrc); + dec_indent(); +} + +static void +spans_print_parm_join_req(objp) + spans_parm_join_req *objp; +{ + printf("%sspans_parm_join_req\n", spans_indent); + inc_indent(); + spans_print_addr(&objp->jnreq_addr); + dec_indent(); +} + +static void +spans_print_parm_join_cnf(objp) + spans_parm_join_cnf *objp; +{ + printf("%sspans_print_parm_join_cnf\n", spans_indent); + inc_indent(); + spans_print_addr(&objp->jncnf_addr); + spans_print_result(&objp->jncnf_result); + dec_indent(); +} + +static void +spans_print_parm_leave_req(objp) + spans_parm_leave_req *objp; +{ + printf("%sspans_print_parm_leave_req\n", spans_indent); + inc_indent(); + spans_print_addr(&objp->lvreq_addr); + dec_indent(); +} + +static void +spans_print_parm_leave_cnf(objp) + spans_parm_leave_cnf *objp; +{ + printf("%sspans_parm_leave_cnf\n", spans_indent); + inc_indent(); + spans_print_addr(&objp->lvcnf_addr); + spans_print_result(&objp->lvcnf_result); + dec_indent(); +} + +static void +spans_print_parm_vcir_ind(objp) + spans_parm_vcir_ind *objp; +{ + printf("%sspans_parm_vcir_ind\n", spans_indent); + inc_indent(); + printf("%svrind_min %d\n", spans_indent, objp->vrind_min); + printf("%svrind_max %d\n", spans_indent, objp->vrind_max); + dec_indent(); +} + +static void +spans_print_parm_query_req(objp) + spans_parm_query_req *objp; +{ + char query_type_str[80]; + + printf("%sspans_parm_query_req\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->qyreq_conn); + spans_query_type_str(&objp->qyreq_type, query_type_str); + printf("%sqyreq_type %s\n", spans_indent, query_type_str); + dec_indent(); +} + +static void +spans_print_parm_query_rsp(objp) + spans_parm_query_rsp *objp; +{ + char query_type_str[80], state_type_str[80]; + + printf("%sspans_parm_query_rsp\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->qyrsp_conn); + spans_query_type_str(&objp->qyrsp_type, query_type_str); + printf("%sqyrsp_type %s\n", spans_indent, query_type_str); + spans_state_str(&objp->qyrsp_state, state_type_str); + printf("%sqyrsp_state %s\n", spans_indent, state_type_str); + printf("%sqyrsp_data 0x%x\n", spans_indent, + objp->qyrsp_data); + dec_indent(); +} + +static void +spans_print_msgbody(objp) + spans_msgbody *objp; +{ + printf("%sspans_msgbody\n", spans_indent); + inc_indent(); + spans_print_msgtype(&objp->mb_type); + switch (objp->mb_type) { + case SPANS_STAT_REQ: + spans_print_parm_stat_req(&objp->spans_msgbody_u.mb_stat_req); + break; + case SPANS_STAT_IND: + spans_print_parm_stat_ind(&objp->spans_msgbody_u.mb_stat_ind); + break; + case SPANS_STAT_RSP: + spans_print_parm_stat_rsp(&objp->spans_msgbody_u.mb_stat_rsp); + break; + case SPANS_OPEN_REQ: + spans_print_parm_open_req(&objp->spans_msgbody_u.mb_open_req); + break; + case SPANS_OPEN_IND: + spans_print_parm_open_ind(&objp->spans_msgbody_u.mb_open_ind); + break; + case SPANS_OPEN_RSP: + spans_print_parm_open_rsp(&objp->spans_msgbody_u.mb_open_rsp); + break; + case SPANS_OPEN_CNF: + spans_print_parm_open_cnf(&objp->spans_msgbody_u.mb_open_cnf); + break; + case SPANS_CLOSE_REQ: + spans_print_parm_close_req(&objp->spans_msgbody_u.mb_close_req); + break; + case SPANS_CLOSE_IND: + spans_print_parm_close_ind(&objp->spans_msgbody_u.mb_close_ind); + break; + case SPANS_CLOSE_RSP: + spans_print_parm_close_rsp(&objp->spans_msgbody_u.mb_close_rsp); + break; + case SPANS_CLOSE_CNF: + spans_print_parm_close_cnf(&objp->spans_msgbody_u.mb_close_cnf); + break; + case SPANS_RCLOSE_REQ: + spans_print_parm_rclose_req(&objp->spans_msgbody_u.mb_rclose_req); + break; + case SPANS_RCLOSE_IND: + spans_print_parm_rclose_ind(&objp->spans_msgbody_u.mb_rclose_ind); + break; + case SPANS_RCLOSE_RSP: + spans_print_parm_rclose_rsp(&objp->spans_msgbody_u.mb_rclose_rsp); + break; + case SPANS_RCLOSE_CNF: + spans_print_parm_rclose_cnf(&objp->spans_msgbody_u.mb_rclose_cnf); + break; + case SPANS_MULTI_REQ: + spans_print_parm_multi_req(&objp->spans_msgbody_u.mb_multi_req); + break; + case SPANS_MULTI_IND: + spans_print_parm_multi_ind(&objp->spans_msgbody_u.mb_multi_ind); + break; + case SPANS_MULTI_RSP: + spans_print_parm_multi_rsp(&objp->spans_msgbody_u.mb_multi_rsp); + break; + case SPANS_MULTI_CNF: + spans_print_parm_multi_cnf(&objp->spans_msgbody_u.mb_multi_cnf); + break; + case SPANS_ADD_REQ: + spans_print_parm_add_req(&objp->spans_msgbody_u.mb_add_req); + break; + case SPANS_ADD_IND: + spans_print_parm_add_ind(&objp->spans_msgbody_u.mb_add_ind); + break; + case SPANS_ADD_RSP: + spans_print_parm_add_rsp(&objp->spans_msgbody_u.mb_add_rsp); + break; + case SPANS_ADD_CNF: + spans_print_parm_add_cnf(&objp->spans_msgbody_u.mb_add_cnf); + break; + case SPANS_JOIN_REQ: + spans_print_parm_join_req(&objp->spans_msgbody_u.mb_join_req); + break; + case SPANS_JOIN_CNF: + spans_print_parm_join_cnf(&objp->spans_msgbody_u.mb_join_cnf); + break; + case SPANS_LEAVE_REQ: + spans_print_parm_leave_req(&objp->spans_msgbody_u.mb_leave_req); + break; + case SPANS_LEAVE_CNF: + spans_print_parm_leave_cnf(&objp->spans_msgbody_u.mb_leave_cnf); + break; + case SPANS_VCIR_IND: + spans_print_parm_vcir_ind(&objp->spans_msgbody_u.mb_vcir_ind); + break; + case SPANS_QUERY_REQ: + spans_print_parm_query_req(&objp->spans_msgbody_u.mb_query_req); + break; + case SPANS_QUERY_RSP: + spans_print_parm_query_rsp(&objp->spans_msgbody_u.mb_query_rsp); + break; + } + dec_indent(); +} + +void +spans_print_msg(objp) + spans_msg *objp; +{ + spans_indent = INIT_INDENT; + printf("%sspans_msg\n", spans_indent); + inc_indent(); + spans_print_version(&objp->sm_vers); + spans_print_msgbody(&objp->sm_body); + dec_indent(); +} + +#else /* ifdef LONGPRINT */ + +static void +spans_print_msgbody(objp) + spans_msgbody *objp; +{ + char daddr[80], msgtype_str[80], result_str[80], saddr[80]; + spans_parm_stat_req *streq_p; + spans_parm_stat_ind *stind_p; + spans_parm_stat_rsp *strsp_p; + spans_parm_open_req *opreq_p; + spans_parm_open_ind *opind_p; + spans_parm_open_rsp *oprsp_p; + spans_parm_open_cnf *opcnf_p; + spans_parm_close_req *clreq_p; + spans_parm_close_ind *clind_p; + spans_parm_close_rsp *clrsp_p; + spans_parm_close_cnf *clcnf_p; + spans_parm_rclose_req *rcreq_p; + spans_parm_rclose_ind *rcind_p; + spans_parm_rclose_rsp *rcrsp_p; + spans_parm_rclose_cnf *rccnf_p; + + spans_msgtype_str(&objp->mb_type, msgtype_str); + printf("%s: ", msgtype_str); + switch (objp->mb_type) { + case SPANS_STAT_REQ: + streq_p = &objp->spans_msgbody_u.mb_stat_req; + printf("es_epoch=0x%x", streq_p->streq_es_epoch); + break; + case SPANS_STAT_IND: + stind_p = &objp->spans_msgbody_u.mb_stat_ind; + strncpy(daddr, spans_addr_print(&stind_p->stind_es_addr), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&stind_p->stind_sw_addr), + sizeof(daddr)); + printf("sw_epoch=0x%x, es_addr=%s, sw_addr=0x%s", + stind_p->stind_sw_epoch, + daddr, saddr); + break; + case SPANS_STAT_RSP: + strsp_p = &objp->spans_msgbody_u.mb_stat_rsp; + strncpy(daddr, spans_addr_print(&strsp_p->strsp_es_addr), + sizeof(daddr)); + printf("es_epoch=0x%x, es_addr=%s", + strsp_p->strsp_es_epoch, daddr); + break; + case SPANS_OPEN_REQ: + opreq_p = &objp->spans_msgbody_u.mb_open_req; + strncpy(daddr, spans_addr_print(&opreq_p->opreq_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&opreq_p->opreq_conn.con_src), + sizeof(saddr)); + printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d, aal=%d", + daddr, saddr, + opreq_p->opreq_conn.con_dsap, + opreq_p->opreq_conn.con_ssap, + opreq_p->opreq_aal); + if (opreq_p->opreq_vpvc.vpf_valid) + printf(", vp.vc=%d.%d", + SPANS_EXTRACT_VPI(opreq_p->opreq_vpvc.vpf_vpvc), + SPANS_EXTRACT_VCI(opreq_p->opreq_vpvc.vpf_vpvc)); + break; + case SPANS_OPEN_IND: + opind_p = &objp->spans_msgbody_u.mb_open_ind; + strncpy(daddr, spans_addr_print(&opind_p->opind_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&opind_p->opind_conn.con_src), + sizeof(saddr)); + printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d, aal=%d", + daddr, saddr, + opind_p->opind_conn.con_dsap, + opind_p->opind_conn.con_ssap, + opind_p->opind_aal); + if (opind_p->opind_vpvc.vpf_valid) + printf(", vp.vc=%d.%d", + SPANS_EXTRACT_VPI(opind_p->opind_vpvc.vpf_vpvc), + SPANS_EXTRACT_VCI(opind_p->opind_vpvc.vpf_vpvc)); + break; + case SPANS_OPEN_RSP: + oprsp_p = &objp->spans_msgbody_u.mb_open_rsp; + strncpy(daddr, spans_addr_print(&oprsp_p->oprsp_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&oprsp_p->oprsp_conn.con_src), + sizeof(saddr)); + spans_result_str(&oprsp_p->oprsp_result, result_str); + printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d, vp.vc=%d.%d", + result_str, daddr, saddr, + oprsp_p->oprsp_conn.con_dsap, + oprsp_p->oprsp_conn.con_ssap, + SPANS_EXTRACT_VPI(oprsp_p->oprsp_vpvc), + SPANS_EXTRACT_VCI(oprsp_p->oprsp_vpvc)); + break; + case SPANS_OPEN_CNF: + opcnf_p = &objp->spans_msgbody_u.mb_open_cnf; + strncpy(daddr, spans_addr_print(&opcnf_p->opcnf_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&opcnf_p->opcnf_conn.con_src), + sizeof(saddr)); + spans_result_str(&opcnf_p->opcnf_result, result_str); + printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d, vp.vc=%d.%d", + result_str, daddr, saddr, + opcnf_p->opcnf_conn.con_dsap, + opcnf_p->opcnf_conn.con_ssap, + SPANS_EXTRACT_VPI(opcnf_p->opcnf_vpvc), + SPANS_EXTRACT_VCI(opcnf_p->opcnf_vpvc)); + break; + case SPANS_CLOSE_REQ: + clreq_p = &objp->spans_msgbody_u.mb_close_req; + strncpy(daddr, spans_addr_print(&clreq_p->clreq_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&clreq_p->clreq_conn.con_src), + sizeof(saddr)); + printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d", + daddr, saddr, + clreq_p->clreq_conn.con_dsap, + clreq_p->clreq_conn.con_ssap); + break; + case SPANS_CLOSE_IND: + clind_p = &objp->spans_msgbody_u.mb_close_ind; + strncpy(daddr, spans_addr_print(&clind_p->clind_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&clind_p->clind_conn.con_src), + sizeof(saddr)); + printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d", + daddr, saddr, + clind_p->clind_conn.con_dsap, + clind_p->clind_conn.con_ssap); + break; + case SPANS_CLOSE_RSP: + clrsp_p = &objp->spans_msgbody_u.mb_close_rsp; + strncpy(daddr, spans_addr_print(&clrsp_p->clrsp_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&clrsp_p->clrsp_conn.con_src), + sizeof(saddr)); + spans_result_str(&clrsp_p->clrsp_result, result_str); + printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d", + result_str, daddr, saddr, + clrsp_p->clrsp_conn.con_dsap, + clrsp_p->clrsp_conn.con_ssap); + break; + case SPANS_CLOSE_CNF: + clcnf_p = &objp->spans_msgbody_u.mb_close_cnf; + strncpy(daddr, spans_addr_print(&clcnf_p->clcnf_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&clcnf_p->clcnf_conn.con_src), + sizeof(saddr)); + spans_result_str(&clcnf_p->clcnf_result, result_str); + printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d", + result_str, daddr, saddr, + clcnf_p->clcnf_conn.con_dsap, + clcnf_p->clcnf_conn.con_ssap); + break; + case SPANS_RCLOSE_REQ: + rcreq_p = &objp->spans_msgbody_u.mb_rclose_req; + strncpy(daddr, spans_addr_print(&rcreq_p->rcreq_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&rcreq_p->rcreq_conn.con_src), + sizeof(saddr)); + printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d", + daddr, saddr, + rcreq_p->rcreq_conn.con_dsap, + rcreq_p->rcreq_conn.con_ssap); + break; + case SPANS_RCLOSE_IND: + rcind_p = &objp->spans_msgbody_u.mb_rclose_ind; + strncpy(daddr, spans_addr_print(&rcind_p->rcind_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&rcind_p->rcind_conn.con_src), + sizeof(saddr)); + printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d", + daddr, saddr, + rcind_p->rcind_conn.con_dsap, + rcind_p->rcind_conn.con_ssap); + break; + case SPANS_RCLOSE_RSP: + rcrsp_p = &objp->spans_msgbody_u.mb_rclose_rsp; + strncpy(daddr, spans_addr_print(&rcrsp_p->rcrsp_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&rcrsp_p->rcrsp_conn.con_src), + sizeof(saddr)); + spans_result_str(&rcrsp_p->rcrsp_result, result_str); + printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d", + result_str, daddr, saddr, + rcrsp_p->rcrsp_conn.con_dsap, + rcrsp_p->rcrsp_conn.con_ssap); + break; + case SPANS_RCLOSE_CNF: + rccnf_p = &objp->spans_msgbody_u.mb_rclose_cnf; + strncpy(daddr, spans_addr_print(&rccnf_p->rccnf_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&rccnf_p->rccnf_conn.con_src), + sizeof(saddr)); + spans_result_str(&rccnf_p->rccnf_result, result_str); + printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d", + result_str, daddr, saddr, + rccnf_p->rccnf_conn.con_dsap, + rccnf_p->rccnf_conn.con_ssap); + break; + } + printf("\n"); +} + +void +spans_print_msg(objp) + spans_msg *objp; +{ + spans_indent = INIT_INDENT; + spans_print_msgbody(&objp->sm_body); +} + +#endif /* ifdef LONGPRINT */ diff --git a/sys/netatm/spans/spans_proto.c b/sys/netatm/spans/spans_proto.c new file mode 100644 index 0000000..e298ed8 --- /dev/null +++ b/sys/netatm/spans/spans_proto.c @@ -0,0 +1,558 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: spans_proto.c,v 1.7 1998/08/26 23:29:10 mks Exp $ + * + */ + +/* + * SPANS Signalling Manager + * --------------------------- + * + * SPANS protocol processing module. + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: spans_proto.c,v 1.7 1998/08/26 23:29:10 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include "spans_xdr.h" +#include <netatm/spans/spans_var.h> + +/* + * Internal functions + */ +caddr_t spans_getname __P((void *)); +void spans_connected __P((void *)); +void spans_cleared __P((void *, struct t_atm_cause *)); +void spans_cpcs_data __P((void *, KBuffer *)); + + +/* + * ATM endpoint for SPANS signalling channel + */ +static Atm_endpoint spans_endpt = { + NULL, /* ep_next */ + ENDPT_SPANS_SIG, /* ep_id */ + NULL, /* ep_ioctl */ + spans_getname, /* ep_getname */ + spans_connected, /* ep_connected */ + spans_cleared, /* ep_cleared */ + NULL, /* ep_incoming */ + NULL, /* ep_addparty */ + NULL, /* ep_dropparty */ + NULL, /* ep_cpcs_ctl */ + spans_cpcs_data, /* ep_cpcs_data */ + NULL, /* ep_saal_ctl */ + NULL, /* ep_saal_data */ + NULL, /* ep_sscop_ctl */ + NULL /* ep_sscop_data */ +}; + + +/* + * ATM connection attributes for UNI signalling channel + */ +static Atm_attributes spans_attr = { + NULL, /* nif */ + CMAPI_CPCS, /* api */ + 0, /* api_init */ + 0, /* headin */ + 0, /* headout */ + { /* aal */ + T_ATM_PRESENT, /* aal.tag */ + ATM_AAL3_4 /* aal.aal_type */ + }, + { /* traffic */ + T_ATM_PRESENT, /* traffic.tag */ + { /* traffic.v */ + { /* traffic.v.forward */ + T_ATM_ABSENT, /* PCR_high */ + 0, /* PCR_all */ + T_ATM_ABSENT, /* SCR_high */ + T_ATM_ABSENT, /* SCR_all */ + T_ATM_ABSENT, /* MBS_high */ + T_ATM_ABSENT, /* MBS_all */ + T_NO, /* tagging */ + }, + { /* traffic.v.backward */ + T_ATM_ABSENT, /* PCR_high */ + 0, /* PCR_all */ + T_ATM_ABSENT, /* SCR_high */ + T_ATM_ABSENT, /* SCR_all */ + T_ATM_ABSENT, /* MBS_high */ + T_ATM_ABSENT, /* MBS_all */ + T_NO, /* tagging */ + }, + T_YES, /* best_effort */ + } + }, + { /* bearer */ + T_ATM_PRESENT, /* bearer.tag */ + { /* bearer.v */ + T_ATM_CLASS_X, /* class */ + T_ATM_NULL, /* traffic_type */ + T_ATM_NO_END_TO_END, /* timing_req */ + T_NO, /* clipping */ + T_ATM_1_TO_1, /* conn_conf */ + } + }, + { /* bhli */ + T_ATM_ABSENT, /* bhli.tag */ + }, + { /* blli */ + T_ATM_ABSENT, /* blli.tag_l2 */ + T_ATM_ABSENT, /* blli.tag_l3 */ + }, + { /* llc */ + T_ATM_ABSENT, /* llc.tag */ + }, + { /* called */ + T_ATM_PRESENT, /* called.tag */ + }, + { /* calling */ + T_ATM_ABSENT, /* calling.tag */ + }, + { /* qos */ + T_ATM_PRESENT, /* qos.tag */ + { /* qos.v */ + T_ATM_NETWORK_CODING, /* coding_standard */ + { /* qos.v.forward */ + T_ATM_QOS_CLASS_0, /* class */ + }, + { /* qos.v.backward */ + T_ATM_QOS_CLASS_0, /* class */ + } + } + }, + { /* transit */ + T_ATM_ABSENT, /* transit.tag */ + }, + { /* cause */ + T_ATM_ABSENT, /* cause.tag */ + } +}; + + +/* + * SPANS cause structre + */ +struct t_atm_cause spans_cause = { + T_ATM_ITU_CODING, /* coding_standard */ + T_ATM_LOC_USER, /* location */ + T_ATM_CAUSE_UNSPECIFIED_NORMAL, /* cause_value */ + { 0, 0, 0, 0 } /* diagnostics */ +}; + + +/* + * Process a SPANS timeout + * + * Called when a previously scheduled spans control block timer expires. + * Processing will based on the current SPANS state. + * + * Called at splnet. + * + * Arguments: + * tip pointer to spans timer control block + * + * Returns: + * none + * + */ +void +spans_timer(tip) + struct atm_time *tip; +{ + struct spans *spp; + spans_msg *msg; + Atm_addr_pvc *pvcp; + int err; + + /* + * Back-off to SPANS control block + */ + spp = (struct spans *) + ((caddr_t)tip - (int)(&((struct spans *)0)->sp_time)); + + ATM_DEBUG2("spans_timer: spp=0x%x,state=%d\n", + (int)spp, spp->sp_state); + + /* + * Process timeout based on protocol state + */ + switch (spp->sp_state) { + + case SPANS_INIT: + + /* + * Open signalling channel + */ + spans_attr.nif = spp->sp_pif->pif_nif; + + spans_attr.aal.v.aal4.forward_max_SDU_size = + ATM_NIF_MTU; + spans_attr.aal.v.aal4.backward_max_SDU_size = + ATM_NIF_MTU; + spans_attr.aal.v.aal4.SSCS_type = + T_ATM_SSCS_SSCOP_UNREL; + spans_attr.aal.v.aal4.mid_low = 0; + spans_attr.aal.v.aal4.mid_high = 0; + + spans_attr.called.tag = T_ATM_PRESENT; + spans_attr.called.addr.address_format = T_ATM_PVC_ADDR; + spans_attr.called.addr.address_length = + sizeof(Atm_addr_pvc); + pvcp = (Atm_addr_pvc *)spans_attr.called.addr.address; + ATM_PVC_SET_VPI(pvcp, SPANS_SIG_VPI); + ATM_PVC_SET_VCI(pvcp, SPANS_SIG_VCI); + spans_attr.called.subaddr.address_format = T_ATM_ABSENT; + spans_attr.called.subaddr.address_length = 0; + + spans_attr.traffic.v.forward.PCR_all_traffic = + spp->sp_pif->pif_pcr; + spans_attr.traffic.v.backward.PCR_all_traffic = + spp->sp_pif->pif_pcr; + + err = atm_cm_connect(&spans_endpt, spp, &spans_attr, + &spp->sp_conn); + if (err) { + log(LOG_CRIT, "spans: signalling channel setup failed\n"); + return; + } + + /* + * Signalling channel open, start probing + */ + spp->sp_state = SPANS_PROBE; + + /* FALLTHRU */ + + case SPANS_PROBE: + case SPANS_ACTIVE: + + /* + * Send out SPANS_STAT_REQ message + */ + msg = (spans_msg *)atm_allocate(&spans_msgpool); + if (msg == NULL) { + /* Retry later if no memory */ + SPANS_TIMER(spp, SPANS_PROBE_ERR_WAIT); + break; + } + msg->sm_vers = SPANS_VERS_1_0; + msg->sm_type = SPANS_STAT_REQ; + msg->sm_stat_req.streq_es_epoch = spp->sp_h_epoch; + if (spans_send_msg(spp, msg)) { + /* Retry later if send fails */ + SPANS_TIMER(spp, SPANS_PROBE_ERR_WAIT); + atm_free(msg); + break; + } + atm_free(msg); + spp->sp_probe_ct++; + + /* + * Check whether we're getting an answer to our probes + */ + if (spp->sp_state == SPANS_ACTIVE && + spp->sp_probe_ct > SPANS_PROBE_THRESH) { + /* + * Interface is down, notify VCC owners + */ + spans_switch_reset(spp, SPANS_UNI_DOWN); + + /* + * Set new state and increment host epoch so + * switch knows we reset everyting. + */ + spp->sp_state = SPANS_PROBE; + spp->sp_h_epoch++; + spp->sp_s_epoch = 0; + } + + /* + * Keep sending status requests + */ + SPANS_TIMER(spp, SPANS_PROBE_INTERVAL); + + break; + + case SPANS_DETACH: + /* + * Try to terminate the SPANS signalling PVC + */ + err = atm_cm_release(spp->sp_conn, &spans_cause); + if (err) { + log(LOG_ERR, "spans: can't close signalling channel\n"); + } + break; + + default: + log(LOG_ERR, "spans: timer state: spp=0x%x, state=%d\n", + (int)spp, spp->sp_state); + } +} + + +/* + * Process a SPANS VCC timeout + * + * Called when a previously scheduled SPANS VCCB timer expires. + * Processing will based on the current VCC state. + * + * Called at splnet. + * + * Arguments: + * tip pointer to vccb timer control block + * + * Returns: + * none + * + */ +void +spans_vctimer(tip) + struct atm_time *tip; +{ + int err; + struct spans *spp; + struct spans_vccb *svp; + + /* + * Get VCCB and SPANS control block addresses + */ + svp = (struct spans_vccb *) ((caddr_t)tip - + (int)(&((struct vccb *)0)->vc_time)); + spp = (struct spans *)svp->sv_pif->pif_siginst; + + ATM_DEBUG3("spans_vctimer: svp=0x%x, sstate=%d, ustate=%d\n", + (int)svp, svp->sv_sstate, svp->sv_ustate); + + /* + * Process timeout based on protocol state + */ + switch (svp->sv_sstate) { + + case SPANS_VC_ABORT: + /* + * Kill the VCCB and notify the owner + */ + err = spans_clear_vcc(spp, svp); + break; + + case SPANS_VC_FREE: + /* + * Free VCCB storage + */ + svp->sv_ustate = VCCU_CLOSED; + svp->sv_sstate = SPANS_VC_FREE; + spans_free((struct vccb *)svp); + break; + + case SPANS_VC_POPEN: + /* + * Issued open request, but didn't get response. + */ + if (svp->sv_retry < SV_MAX_RETRY) { + /* + * Retransmit the open request + */ + err = spans_send_open_req(spp, svp); + svp->sv_retry++; + SPANS_VC_TIMER((struct vccb *) svp, SV_TIMEOUT); + } else { + /* + * Retry limit exceeded--report the open failed + */ + svp->sv_ustate = VCCU_CLOSED; + svp->sv_sstate = SPANS_VC_FREE; + svp->sv_connvc->cvc_attr.cause.tag = + T_ATM_PRESENT; + svp->sv_connvc->cvc_attr.cause.v.coding_standard = + T_ATM_ITU_CODING; + svp->sv_connvc->cvc_attr.cause.v.location = + T_ATM_LOC_USER; + svp->sv_connvc->cvc_attr.cause.v.cause_value = + T_ATM_CAUSE_NO_USER_RESPONDING; + KM_ZERO(svp->sv_connvc->cvc_attr.cause.v.diagnostics, + sizeof(svp->sv_connvc->cvc_attr.cause.v.diagnostics)); + atm_cm_cleared(svp->sv_connvc); + } + break; + + case SPANS_VC_CLOSE: + /* + * Issued close request, but didn't get response. + */ + if (svp->sv_retry < SV_MAX_RETRY) { + /* + * Retransmit the close request + */ + err = spans_send_close_req(spp, svp); + svp->sv_retry++; + SPANS_VC_TIMER((struct vccb *) svp, SV_TIMEOUT); + } else { + /* + * Retry limit exceeded--just finish the close + */ + svp->sv_sstate = SPANS_VC_FREE; + svp->sv_connvc->cvc_attr.cause.tag = T_ATM_PRESENT; + svp->sv_connvc->cvc_attr.cause.v.coding_standard = + T_ATM_ITU_CODING; + svp->sv_connvc->cvc_attr.cause.v.location = + T_ATM_LOC_USER; + svp->sv_connvc->cvc_attr.cause.v.cause_value = + T_ATM_CAUSE_NO_USER_RESPONDING; + KM_ZERO(svp->sv_connvc->cvc_attr.cause.v.diagnostics, + sizeof(svp->sv_connvc->cvc_attr.cause.v.diagnostics)); + atm_cm_cleared(svp->sv_connvc); + } + break; + + case SPANS_VC_ACTIVE: + case SPANS_VC_ACT_DOWN: + /* + * Shouldn't happen + */ + log(LOG_ERR, "spans_vctimer: unexpected state %d\n", + svp->sv_sstate); + break; + + default: + log(LOG_ERR, "spans: vctimer state: svp=0x%x, sstate=%d\n", + (int)svp, svp->sv_sstate); + } +} + + +/* + * SPANS name routine + * + * Arguments: + * tok SPANS signalling channel token (ignored) + * + * Returns: + * pointer to a string identifying the SPANS signalling manager + * + */ +caddr_t +spans_getname(tok) + void *tok; +{ + return("SPANS"); +} + + +/* + * Process a VCC connection notification + * + * Should never be called + * + * Arguments: + * tok user's connection token (SPANS protocol block) + * + * Returns: + * none + * + */ +void +spans_connected(tok) + void *tok; +{ + struct spans *spp = (struct spans *)tok; + + ATM_DEBUG2("spans_connected: spp=0x%x,state=%d\n", + (int)spp, spp->sp_state); + + /* + * Connected routine shouldn't ever get called for a PVC + */ + log(LOG_ERR, "spans: connected function called, tok=0x%x\n", + (int)spp); +} + + +/* + * Process a VCC close notification + * + * Called when the SPANS signalling channel is closed + * + * Arguments: + * tok user's connection token (spans protocol block) + * cp pointer to cause structure + * + * Returns: + * none + * + */ +void +spans_cleared(tok, cp) + void *tok; + struct t_atm_cause *cp; +{ + struct spans *spp = (struct spans *)tok; + + /* + * VCC has been closed. + */ + log(LOG_ERR, "spans: signalling channel closed\n"); + SPANS_CANCEL(spp); + spp->sp_conn = 0; +} + + +/* + * SPANS CPCS data handler + * + * This is the module which receives data on the SPANS signalling + * channel. Processing is based on the indication received from the + * AAL and the protocol state. + * + * Arguments: + * tok session token (pointer to spans protocol control block) + * m pointer to buffer with data + * + * Returns: + * none + * + */ +void +spans_cpcs_data(tok, m) + void *tok; + KBuffer *m; +{ + struct spans *spp = tok; + + ATM_DEBUG3("spans_cpcs_data: spp=0x%x,state=%d,m=0x%x,\n", + (int)spp, spp->sp_state, m); + + /* + * Process data + */ + spans_rcv_msg(spp, m); +} diff --git a/sys/netatm/spans/spans_subr.c b/sys/netatm/spans/spans_subr.c new file mode 100644 index 0000000..48b9705 --- /dev/null +++ b/sys/netatm/spans/spans_subr.c @@ -0,0 +1,494 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: spans_subr.c,v 1.9 1998/08/26 23:29:10 mks Exp $ + * + */ + +/* + * SPANS Signalling Manager + * --------------------------- + * + * SPANS-related subroutines. + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: spans_subr.c,v 1.9 1998/08/26 23:29:10 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include "spans_xdr.h" +#include <netatm/spans/spans_var.h> + + +/* + * Open a SPANS VCC + * + * Called when a user wants to open a VC. This function will construct + * a VCCB, create the stack requested by the user, and, if we are + * opening an SVC, start the SPANS signalling message exchange. The + * user will have to wait for a notify event to be sure the SVC is fully + * open. + * + * Must be called at splnet. + * + * Arguments: + * spp pointer to SPANS protocol instance + * acp pointer to PVC's connection parameters + * + * Returns: + * 0 VCC creation successful + * errno VCC setup failed - reason indicated + * + */ +int +spans_open_vcc(spp, cvp) + struct spans *spp; + Atm_connvc *cvp; + +{ + struct atm_pif *pip = spp->sp_pif; + struct spans_vccb *svp; + Atm_addr_pvc *pvp; + spans_aal aal; + int err, pvc, vpi, vci; + + ATM_DEBUG2("spans_open_vcc: spp=0x%x, cvp=0x%x\n", spp, cvp); + + /* + * Validate user parameters. AAL and encapsulation are + * checked by the connection manager. + */ + + /* + * Check called party address(es) + */ + if (cvp->cvc_attr.called.tag != T_ATM_PRESENT || + cvp->cvc_attr.called.addr.address_format == + T_ATM_ABSENT || + cvp->cvc_attr.called.subaddr.address_format != + T_ATM_ABSENT) { + return(EINVAL); + } + switch (cvp->cvc_attr.called.addr.address_format) { + case T_ATM_PVC_ADDR: + /* + * Make sure VPI/VCI is valid + */ + pvc = 1; + pvp = (Atm_addr_pvc *)cvp->cvc_attr.called.addr.address; + vpi = ATM_PVC_GET_VPI(pvp); + vci = ATM_PVC_GET_VCI(pvp); + if ((vpi > pip->pif_maxvpi) || + (vci == 0) || + (vci > pip->pif_maxvci)) { + return(ERANGE); + } + + /* + * Make sure VPI/VCI is not already in use + */ + if (spans_find_vpvc(spp, vpi, vci, 0)) { + return(EADDRINUSE); + } + ATM_DEBUG2("spans_open_vcc: VPI.VCI=%d.%d\n", + vpi, vci); + break; + + case T_ATM_SPANS_ADDR: + pvc = 0; + vpi = vci = 0; + + /* + * Check signalling state + */ + if (spp->sp_state != SPANS_ACTIVE) { + return(ENETDOWN); + } + + /* + *Check destination address length + */ + if (cvp->cvc_attr.called.addr.address_length != + sizeof(spans_addr)) { + return(EINVAL); + } + break; + + default: + return(EINVAL); + } + + /* + * Check that this is for the same interface SPANS uses + */ + if (!cvp->cvc_attr.nif || + cvp->cvc_attr.nif->nif_pif != spp->sp_pif) { + return(EINVAL); + } + + /* + * Check AAL + */ + if (!spans_get_spans_aal(cvp->cvc_attr.aal.type, &aal)) { + return(EINVAL); + } + +#ifdef NOTDEF + /* + * Check encapsulation + */ + /* XXX -- How do we check encapsulation? */ + if (cvp->ac_encaps != ATM_ENC_NULL) { + return(EINVAL); + } +#endif + + /* + * Allocate control block for VCC + */ + svp = (struct spans_vccb *)atm_allocate(&spans_vcpool); + if (svp == NULL) { + return(ENOMEM); + } + + /* + * Fill in VCCB + */ + if (pvc) { + svp->sv_type = VCC_PVC | VCC_IN | VCC_OUT; + svp->sv_vpi = vpi; + svp->sv_vci = vci; + svp->sv_sstate = (spp->sp_state == SPANS_ACTIVE ? + SPANS_VC_ACTIVE : SPANS_VC_ACT_DOWN); + svp->sv_ustate = VCCU_OPEN; + } else { + svp->sv_type = VCC_SVC | VCC_OUT; + spans_addr_copy(cvp->cvc_attr.called.addr.address, + &svp->sv_conn.con_dst); + spans_addr_copy(spp->sp_addr.address, + &svp->sv_conn.con_src); + svp->sv_conn.con_dsap = SPANS_SAP_IP; + svp->sv_conn.con_ssap = spans_ephemeral_sap(spp); + svp->sv_sstate = SPANS_VC_POPEN; + svp->sv_ustate = VCCU_POPEN; + } + svp->sv_proto = ATM_SIG_SPANS; + svp->sv_pif = spp->sp_pif; + svp->sv_nif = cvp->cvc_attr.nif; + svp->sv_connvc = cvp; + svp->sv_spans_aal = aal; + svp->sv_tstamp = time_second; + + /* + * Put VCCB on SPANS queue + */ + ENQUEUE(svp, struct spans_vccb, sv_sigelem, spp->sp_vccq); + + /* + * Link VCCB to VCC connection block + */ + cvp->cvc_vcc = (struct vccb *) svp; + + /* + * Start the SPANS message exchange if this is an SVC + */ + if (!pvc) { + svp->sv_retry = 0; + svp->sv_spans_qos.rsc_peak = 1; + svp->sv_spans_qos.rsc_mean = 1; + svp->sv_spans_qos.rsc_burst = 1; + err = spans_send_open_req(spp, svp); + if (err) { + /* + * On error, delete the VCCB + */ + DEQUEUE(svp, struct spans_vccb, sv_sigelem, + spp->sp_vccq); + cvp->cvc_vcc = (struct vccb *)0; + atm_free((caddr_t)svp); + return(err); + } else { + /* + * VCCB is opening--set the retransmit timer + */ + SPANS_VC_TIMER((struct vccb *) svp, SV_TIMEOUT); + } + } + + return(0); +} + + +/* + * Close a SPANS VCC + * + * Called when a user wants to close a VCC. This function will clean + * up the VCCB and, for an SVC, send a close request. + * + * Must be called at splnet. + * + * Arguments: + * spp pointer to SPANS protocol instance + * svp pointer to VCCB for the VCC to be closed + * + * Returns: + * 0 VCC is now closed + * errno error encountered + */ +int +spans_close_vcc(spp, svp, force) + struct spans *spp; + struct spans_vccb *svp; + int force; + +{ + int err = 0; + + ATM_DEBUG2("spans_close_vcc: svp=0x%x, state=%d\n", svp, + svp->sv_sstate); + + /* + * Check that this is for the same interface SPANS uses + */ + if (svp->sv_pif != spp->sp_pif) { + return (EINVAL); + } + + /* + * Kill any possible timer + */ + SPANS_VC_CANCEL((struct vccb *) svp); + + /* + * Mark the close time. + */ + svp->sv_tstamp = time_second; + + /* + * Process based on the connection type + */ + if (svp->sv_type & VCC_PVC) { + svp->sv_sstate = SPANS_VC_FREE; + svp->sv_ustate = VCCU_CLOSED; + } else if (svp->sv_type & VCC_SVC) { + /* + * Update VCCB states + */ + svp->sv_ustate = VCCU_CLOSED; + + /* + * Send the appropriate SPANS close message + */ + switch (svp->sv_sstate) { + case SPANS_VC_R_POPEN: + err = spans_send_open_rsp(spp, svp, SPANS_FAIL); + svp->sv_sstate = SPANS_VC_FREE; + break; + case SPANS_VC_OPEN: + case SPANS_VC_POPEN: + case SPANS_VC_ABORT: + svp->sv_retry = 0; + err = spans_send_close_req(spp, svp); + if (force) { + svp->sv_sstate = SPANS_VC_FREE; + } else { + svp->sv_sstate = SPANS_VC_CLOSE; + SPANS_VC_TIMER((struct vccb *) svp, + SV_TIMEOUT); + } + break; + case SPANS_VC_CLOSE: + if (force) { + svp->sv_sstate = SPANS_VC_FREE; + } + break; + } + } + + /* + * Wait for user to free resources + */ + return(err); +} + + +/* + * Clear a SPANS VCC + * + * Called when the signalling manager wants to close a VCC immediately. + * This function will clean up the VCCB and notify the owner. + * + * Must be called at splnet. + * + * Arguments: + * spp pointer to SPANS protocol instance + * svp pointer to VCCB for the VCC to be closed + * + * Returns: + * 0 VCC is now closed + * errno error encountered + */ +int +spans_clear_vcc(spp, svp) + struct spans *spp; + struct spans_vccb *svp; + +{ + u_char outstate; + + ATM_DEBUG2("spans_clear_vcc: svp=0x%x, state=%d\n", svp, + svp->sv_sstate); + + /* + * Check that this is for the same interface SPANS uses + */ + if (svp->sv_pif != spp->sp_pif) { + return (EINVAL); + } + + /* + * Kill any possible timer + */ + SPANS_VC_CANCEL((struct vccb *) svp); + + /* + * Mark the close time + */ + svp->sv_tstamp = time_second; + + /* + * Mark the VCCB closed + */ + outstate = svp->sv_sstate; + svp->sv_sstate = SPANS_VC_FREE; + svp->sv_ustate = VCCU_CLOSED; + + /* + * Notify the user if old state indicates. + */ + switch (outstate) { + case SPANS_VC_ACTIVE: + case SPANS_VC_ACT_DOWN: + case SPANS_VC_POPEN: + case SPANS_VC_OPEN: + case SPANS_VC_CLOSE: + case SPANS_VC_ABORT: + /* XXX -- set cause */ + atm_cm_cleared(svp->sv_connvc); + break; + case SPANS_VC_NULL: + case SPANS_VC_R_POPEN: + case SPANS_VC_FREE: + break; + } + + /* + * Wait for user to free resources + */ + return(0); +} + + +/* + * Reset the switch state + * + * Called when the switch or host at the far end of the ATM link has + * gone away. This can be deteched either by a number of SPANS_STAT_REQ + * messages going unanswered or by the host epoch changing in a SPANS + * SPANS_STAT_IND or SPANS_STAT_REQ message. + * + * Arguments: + * spp pointer to SPANS protocol instance + * + * Returns: + * none + * + */ +void +spans_switch_reset(spp, cause) + struct spans *spp; + int cause; + +{ + int s; + struct vccb *vcp, *vnext; + + ATM_DEBUG2("spans_switch_reset: spp=0x%x, cause=%d\n", + spp, cause); + + /* + * Log the event + */ + log(LOG_INFO, "spans: signalling %s on interface %s%d\n", + (cause == SPANS_UNI_DOWN ? "down" : "up"), + spp->sp_pif->pif_name, + spp->sp_pif->pif_unit); + + /* + * Terminate all of our VCCs + */ + s = splnet(); + for (vcp = Q_HEAD(spp->sp_vccq, struct vccb); vcp; + vcp = vnext) { + + u_char outstate; + + vnext = Q_NEXT(vcp, struct vccb, vc_sigelem); + + if (vcp->vc_type & VCC_SVC) { + /* + * Close the SVC and notify the owner + */ + outstate = vcp->vc_sstate; + SPANS_VC_CANCEL((struct vccb *) vcp); + vcp->vc_ustate = VCCU_CLOSED; + vcp->vc_sstate = SPANS_VC_FREE; + if (outstate == SPANS_VC_OPEN || + outstate == SPANS_VC_POPEN) { + /* XXX -- set cause */ + atm_cm_cleared(vcp->vc_connvc); + } + } else if (vcp->vc_type & VCC_PVC) { + /* + * Note new state + */ + switch(cause) { + case SPANS_UNI_DOWN: + vcp->vc_sstate = SPANS_VC_ACT_DOWN; + break; + case SPANS_UNI_UP: + vcp->vc_sstate = SPANS_VC_ACTIVE; + break; + } + } else { + log(LOG_ERR, "spans: invalid VCC type: vccb=0x%x, type=%d\n", + vcp, vcp->vc_type); + } + } + (void) splx(s); +} diff --git a/sys/netatm/spans/spans_util.c b/sys/netatm/spans/spans_util.c new file mode 100644 index 0000000..6d470e1 --- /dev/null +++ b/sys/netatm/spans/spans_util.c @@ -0,0 +1,477 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: spans_util.c,v 1.6 1998/08/26 23:29:10 mks Exp $ + * + */ + +/* + * SPANS Signalling Manager + * --------------------------- + * + * SPANS-related utility routines. + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: spans_util.c,v 1.6 1998/08/26 23:29:10 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include "spans_xdr.h" +#include <netatm/spans/spans_var.h> + + +#ifdef NOTDEF +/* XXX -- Remove all SAP checks? */ +#define MAX_SAP_ENT 1 +static struct { + spans_sap spans_sap; + Sap_t local_sap; +} sap_table[MAX_SAP_ENT] = { + {SPANS_SAP_IP, SAP_IP}, +}; + + +/* + * Translate an internal SAP to a SPANS SAP + * + * Search the SAP table for the given SAP. Put the corresponding SPANS + * SAP into the indicated variable. + * + * Arguments: + * lsap the value of the internal SAP + * ssap a pointer to the variable to receive the SPANS SAP value + * + * Returns: + * TRUE the SAP was found; *ssap is valid + * FALSE the SAP was not found; *ssap is not valid + * + */ +int +spans_get_spans_sap(lsap, ssap) + Sap_t lsap; + spans_sap *ssap; +{ + int i; + + /* + * Search the SAP table for the given local SAP + */ + for (i=0; i< MAX_SAP_ENT; i++) { + if (sap_table[i].local_sap == lsap) { + *ssap = sap_table[i].spans_sap; + return(TRUE); + } + } + return(FALSE); +} + + +/* + * Translate a SPANS SAP to internal format + * + * Search the SAP table for the given SAP. Put the corresponding + * internal SAP into the indicated variable. + * + * Arguments: + * ssap the value of the SPANS SAP + * lsap a pointer to the variable to receive the internal + * SAP value + * + * Returns: + * TRUE the SAP was found; *lsap is valid + * FALSE the SAP was not found; *lsap is not valid + * + */ +int +spans_get_local_sap(ssap, lsap) + spans_sap ssap; + Sap_t *lsap; +{ + int i; + + /* + * Search the SAP table for the given SPANS SAP + */ + for (i=0; i< MAX_SAP_ENT; i++) { + if (sap_table[i].spans_sap == ssap) { + *lsap = sap_table[i].local_sap; + return(TRUE); + } + } + return(FALSE); +} +#endif + + +/* + * Allocate an ephemeral SPANS SAP + * + * Arguments: + * spp pointer to SPANS protocol instance + * + * Returns: + * a SPANS ephemeral SAP number + * + */ +int +spans_ephemeral_sap(spp) + struct spans *spp; +{ + return(SPANS_SAP_EPHEMERAL); +} + + +/* + * Translate an internal AAL designator to a SPANS AAL type + * + * Arguments: + * laal internal AAL designation + * saal a pointer to the variable to receive the SPANS AAL type + * + * Returns: + * TRUE the AAL was found; *saal is valid + * FALSE the AAL was not found; *saal is not valid + * + */ +int +spans_get_spans_aal(laal, saal) + Aal_t laal; + spans_aal *saal; +{ + /* + * + */ + switch (laal) { + case ATM_AAL0: + *saal = SPANS_AAL0; + return(TRUE); + case ATM_AAL1: + *saal = SPANS_AAL1; + return(TRUE); + case ATM_AAL2: + *saal = SPANS_AAL2; + return(TRUE); + case ATM_AAL3_4: + *saal = SPANS_AAL4; + return(TRUE); + case ATM_AAL5: + *saal = SPANS_AAL5; + return(TRUE); + default: + return(FALSE); + } +} + + +/* + * Translate a SPANS AAL type to an internal AAL designator + * + * Arguments: + * saal the SPANS AAL type + * laal a pointer to the variable to receive the internal + * AAL designation + * + * Returns: + * TRUE the AAL was found; *laal is valid + * FALSE the AAL was not found; *laal is not valid + * + */ +int +spans_get_local_aal(saal, laal) + spans_aal saal; + Aal_t *laal; +{ + /* + * + */ + switch (saal) { + case SPANS_AAL0: + *laal = ATM_AAL0; + return(TRUE); + case SPANS_AAL1: + *laal = ATM_AAL1; + return(TRUE); + case SPANS_AAL2: + *laal = ATM_AAL2; + return(TRUE); + case SPANS_AAL3: + case SPANS_AAL4: + *laal = ATM_AAL3_4; + return(TRUE); + case SPANS_AAL5: + *laal = ATM_AAL5; + return(TRUE); + default: + return(FALSE); + } +} + + +/* + * Verify a VCCB + * + * Search SPANS's VCCB queue to verify that a VCCB belongs to SPANS. + * + * Arguments: + * spp pointer to SPANS protocol instance + * svp pointer to a VCCB + * + * Returns: + * TRUE the VCCB belongs to SPANS + * FALSE the VCCB doesn't belong to SPANS + * + */ +int +spans_verify_vccb(spp, svp) + struct spans *spp; + struct spans_vccb *svp; + +{ + struct spans_vccb *vcp, *vcnext; + + for (vcp = Q_HEAD(spp->sp_vccq, struct spans_vccb); + vcp; vcp = vcnext){ + vcnext = Q_NEXT(vcp, struct spans_vccb, sv_sigelem); + if (svp == vcp) { + return(TRUE); + } + } + return(FALSE); +} + + +/* + * Find a VCCB + * + * Find a VCCB given the VPI and VCI. + * + * Arguments: + * spp pointer to SPANS protocol instance + * vpi the VPI to search for + * vci the VCI to search for + * dir the direction of the VCC (VCC_IN, VCC_OUT, or both). + * If dir is set to zero, return the address of any VCCB + * with the given VPI/VCI, regardless of direction. + * + * Returns: + * 0 there is no such VCCB + * address the address of the VCCB + * + */ +struct spans_vccb * +spans_find_vpvc(spp, vpi, vci, dir) + struct spans *spp; + int vpi, vci; + u_char dir; + +{ + struct spans_vccb *svp, *svnext; + + for (svp = Q_HEAD(spp->sp_vccq, struct spans_vccb); svp; + svp = svnext){ + svnext = Q_NEXT(svp, struct spans_vccb, sv_sigelem); + if (svp->sv_vpi == vpi && + svp->sv_vci == vci && + (svp->sv_type & dir) == dir) + break; + } + return(svp); +} + + +/* + * Find a connection + * + * Find a VCCB given the connection structure. + * + * Arguments: + * spp pointer to SPANS protocol instance + * p pointer to an spans_atm_conn structure + * + * Returns: + * 0 there is no such VCCB + * address the address of the VCCB + * + */ +struct spans_vccb * +spans_find_conn(spp, p) + struct spans *spp; + struct spans_atm_conn *p; +{ + struct spans_vccb *svp, *svnext; + + for (svp = Q_HEAD(spp->sp_vccq, struct spans_vccb); svp; svp = svnext){ + svnext = Q_NEXT(svp, struct spans_vccb, sv_sigelem); + if (!bcmp(p, &svp->sv_conn, sizeof (spans_atm_conn))) + break; + } + return(svp); +} + + +/* + * Allocate a VPI/VCI pair + * + * When we get an open request or indication from the network, we have + * allocate a VPI and VCI for the conection. This routine will allocate + * a VPI/VCI based on the next available VCI in the SPANS protocol block. + * The VPI/VCI chose must be within the range allowed by the interface and + * must not already be in use. + * + * Currently the Fore ATM interface only supports VPI 0, so this code only + * allocates a VCI. + * + * There's probably a more elegant way to do this. + * + * Arguments: + * spp pointer to connection's SPANS protocol instance + * + * Returns: + * 0 no VPI/VCI available + * vpvc the VPI/VCI for the connection + * + */ +spans_vpvc +spans_alloc_vpvc(spp) + struct spans *spp; +{ + int vpi, vci; + + /* + * Loop through the allowable VCIs, starting with the curent one, + * to find one that's not in use. + */ + while (spp->sp_alloc_vci <= spp->sp_max_vci) { + vpi = spp->sp_alloc_vpi; + vci = spp->sp_alloc_vci++; + if (!spans_find_vpvc(spp, vpi, vci, 0)) { + return(SPANS_PACK_VPIVCI(vpi, vci)); + } + } + + /* + * Reset the VCI to the minimum + */ + spp->sp_alloc_vci = spp->sp_min_vci; + + /* + * Try looping through again + */ + while (spp->sp_alloc_vci <= spp->sp_max_vci) { + vpi = spp->sp_alloc_vpi; + vci = spp->sp_alloc_vci++; + if (!spans_find_vpvc(spp, vpi, vci, 0)) { + return(SPANS_PACK_VPIVCI(vpi, vci)); + } + } + + /* + * All allowable VCIs are in use + */ + return(0); +} + + +/* + * Print a SPANS address + * + * Convert a SPANS address into an ASCII string suitable for printing. + * + * Arguments: + * p pointer to a struct spans_addr + * + * Returns: + * the address of a string with the ASCII representation of the + * address. + * + */ +char * +spans_addr_print(p) + struct spans_addr *p; +{ + static char strbuff[80]; + union { + int w; + char c[4]; + } u1, u2; + + + /* + * Clear the returned string + */ + KM_ZERO(strbuff, sizeof(strbuff)); + + /* + * Get address into integers + */ + u1.c[0] =p->addr[0]; + u1.c[1] =p->addr[1]; + u1.c[2] =p->addr[2]; + u1.c[3] =p->addr[3]; + u2.c[0] =p->addr[4]; + u2.c[1] =p->addr[5]; + u2.c[2] =p->addr[6]; + u2.c[3] =p->addr[7]; + + /* + * Print and return the string + */ + sprintf(strbuff, "%x.%x", ntohl(u1.w), ntohl(u2.w)); + return(strbuff); +} + + +/* + * Print a buffer chain + * + * Arguments: + * m pointer to a buffer chain + * + * Returns: + * none + * + */ +void +spans_dump_buffer(m) + KBuffer *m; +{ + int i; + caddr_t cp; + + printf("spans_dump_buffer:\n"); + while (m) { + KB_DATASTART(m, cp, caddr_t); + for (i = 0; i < KB_LEN(m); i++) { + if (i == 0) + printf(" bfr=0x%x: ", (int)m); + printf("%x ", (u_char)*cp++); + } + printf("<end_bfr>\n"); + m = KB_NEXT(m); + } +} diff --git a/sys/netatm/spans/spans_var.h b/sys/netatm/spans/spans_var.h new file mode 100644 index 0000000..8f9ac8a --- /dev/null +++ b/sys/netatm/spans/spans_var.h @@ -0,0 +1,259 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: spans_var.h,v 1.7 1998/04/09 14:24:18 johnc Exp $ + * + */ + +/* + * SPANS Signalling Manager + * --------------------------- + * + * Protocol control blocks + * + */ + +#ifndef _SPANS_SPANS_VAR_H +#define _SPANS_SPANS_VAR_H + +#ifdef ATM_KERNEL +/* + * Constants to indicate the state of the signalling interface + */ +#define SPANS_UNI_UP 1 +#define SPANS_UNI_DOWN -1 + + +/* + * Structure containing state information for each SPANS protocol + * instance. There will be one instance for each ATM device interface + * using the SPANS signalling manager. + */ +struct spans { + struct siginst sp_inst; /* Header */ + struct atm_time sp_time; /* Timer controls */ + void (*sp_lower) /* Lower command handler */ + __P((int, void *, int, int)); + Atm_connection *sp_conn; /* Signalling connection */ + long sp_s_epoch; /* Switch epoch */ + long sp_h_epoch; /* Host epoch */ + u_int sp_probe_ct; /* Status_req msgs unanswered */ + u_int sp_alloc_vci; /* Next VCI to allocate */ + u_int sp_alloc_vpi; /* Next VPI to allocate */ + u_int sp_min_vci; /* Lowest VCI to allocate */ + u_int sp_max_vci; /* Highest VCI to allocate */ + struct spanscls *sp_cls; /* CLS instance */ +}; + +#define sp_next sp_inst.si_next +#define sp_pif sp_inst.si_pif +#define sp_addr sp_inst.si_addr +#define sp_subaddr sp_inst.si_subaddr +#define sp_vccq sp_inst.si_vccq +#define sp_state sp_inst.si_state +#define sp_ipserv sp_inst.si_ipserv +#endif /* ATM_KERNEL */ + +/* + * SPANS Protocol States + */ +#define SPANS_ACTIVE 1 /* Active */ +#define SPANS_DETACH 2 /* Detach in progress */ +#define SPANS_INIT 3 /* Initializing */ +#define SPANS_PROBE 4 /* Exchanging status info */ + +#define SPANS_PROBE_INTERVAL (ATM_HZ) /* Interval between SPANS_STAT_REQs */ +#define SPANS_PROBE_THRESH 10 /* Probe time-out threshold */ +#define SPANS_PROBE_ERR_WAIT (3 * ATM_HZ) /* Time to wait if send probe fails */ + + +#ifdef ATM_KERNEL +/* + * SPANS Virtual Channel Connection control block. All information + * regarding the state of a SPANS-controlled VCC will be recorded here. + * There will be one SPANS VCC control block for each SPANS-controlled + * VCC. + */ +struct spans_vccb { + struct vccb vcp_hdr; /* Generic VCCB */ + u_short sv_retry; /* Xmit retry count */ + spans_atm_conn sv_conn; /* SPANS connection info */ + spans_resrc sv_spans_qos; /* QoS for VCC */ + spans_aal sv_spans_aal; /* AAL for VCC */ +}; + +#define sv_type vcp_hdr.vc_type +#define sv_proto vcp_hdr.vc_proto +#define sv_sstate vcp_hdr.vc_sstate +#define sv_ustate vcp_hdr.vc_ustate +#define sv_pif vcp_hdr.vc_pif +#define sv_nif vcp_hdr.vc_nif +#define sv_sigelem vcp_hdr.vc_sigelem +#define sv_time vcp_hdr.vc_time +#define sv_vpi vcp_hdr.vc_vpi +#define sv_vci vcp_hdr.vc_vci +#define sv_connvc vcp_hdr.vc_connvc +#define sv_ipdus vcp_hdr.vc_ipdus +#define sv_opdus vcp_hdr.vc_opdus +#define sv_ibytes vcp_hdr.vc_ibytes +#define sv_obytes vcp_hdr.vc_obytes +#define sv_ierrors vcp_hdr.vc_ierrors +#define sv_oerrors vcp_hdr.vc_oerrors +#define sv_tstamp vcp_hdr.vc_tstamp +#define sv_daddr sv_conn.daddr +#define sv_saddr sv_conn.saddr +#define sv_dsap sv_conn.dsap +#define sv_ssap sv_conn.ssap + +#define SV_MAX_RETRY 3 +#define SV_TIMEOUT (ATM_HZ) + +#endif /* ATM_KERNEL */ + + +/* + * SPANS VCC Signalling Protocol States + */ +#define SPANS_VC_NULL 0 /* No state */ +#define SPANS_VC_ACTIVE 1 /* Active */ +#define SPANS_VC_ACT_DOWN 2 /* Active - Interface down */ +#define SPANS_VC_POPEN 3 /* VCC open in progress */ +#define SPANS_VC_R_POPEN 4 /* VCC rmt open in progress */ +#define SPANS_VC_OPEN 5 /* VCC open */ +#define SPANS_VC_CLOSE 6 /* VCC close in progress */ +#define SPANS_VC_ABORT 7 /* VCC abort in progress */ +#define SPANS_VC_FREE 8 /* Waiting for user to free resources */ + + +#ifdef ATM_KERNEL +/* + * Macro to compare two SPANS addresses. + * + * Returns 0 if the addresses are equal. + */ +#define spans_addr_cmp(a, b) \ + (bcmp((caddr_t)a, (caddr_t)b, sizeof(struct spans_addr))) + +/* + * Macro to copy a SPANS address from a to b. + */ +#define spans_addr_copy(a, b) \ + (KM_COPY((caddr_t)a, (caddr_t)b, sizeof(struct spans_addr))) + + +/* + * Timer macros + */ +#define SPANS_TIMER(s, t) atm_timeout(&(s)->sp_time, (t), spans_timer) +#define SPANS_CANCEL(s) atm_untimeout(&(s)->sp_time) +#define SPANS_VC_TIMER(v, t) atm_timeout(&(v)->vc_time, (t), spans_vctimer) +#define SPANS_VC_CANCEL(v) atm_untimeout(&(v)->vc_time) + + +/* + * Global function declarations + */ +struct ipvcc; + + /* spans_arp.c */ +int spansarp_svcout __P((struct ipvcc *, struct in_addr *)); +int spansarp_svcin __P((struct ipvcc *, Atm_addr *, Atm_addr *)); +int spansarp_svcactive __P((struct ipvcc *)); +void spansarp_vcclose __P((struct ipvcc *)); +void spansarp_ipact __P((struct spanscls *)); +void spansarp_ipdact __P((struct spanscls *)); +void spansarp_stop __P((void)); +void spansarp_input __P((struct spanscls *, KBuffer *)); +int spansarp_ioctl __P((int, caddr_t, caddr_t)); + + /* spans_cls.c */ +int spanscls_start __P((void)); +void spanscls_stop __P((void)); +int spanscls_attach __P((struct spans *)); +void spanscls_detach __P((struct spans *)); +void spanscls_closevc __P((struct spanscls *, + struct t_atm_cause *)); + + /* spans_if.c */ +int spans_abort __P((struct vccb *)); +int spans_free __P((struct vccb *)); + + /* spans_msg.c */ +int spans_send_msg __P((struct spans *, spans_msg *)); +int spans_send_open_req __P((struct spans *, + struct spans_vccb *)); +int spans_send_open_rsp __P((struct spans *, + struct spans_vccb *, + spans_result)); +int spans_send_close_req __P((struct spans *, + struct spans_vccb *)); +void spans_rcv_msg __P((struct spans *, KBuffer *)); + + /* spans_print.c */ +void spans_print_msg __P((spans_msg *)); + + /* spans_proto.c */ +void spans_timer __P((struct atm_time *)); +void spans_vctimer __P((struct atm_time *)); +void spans_upper __P((int, void *, int, int)); +void spans_notify __P((void *, int, int)); + + /* spans_subr.c */ +int spans_open_vcc __P((struct spans *, Atm_connvc *)); +int spans_close_vcc __P((struct spans *, + struct spans_vccb *, int)); +int spans_clear_vcc __P((struct spans *, + struct spans_vccb *)); +void spans_switch_reset __P((struct spans *, int)); + + /* spans_util.c */ +int spans_get_spans_sap __P((Sap_t, spans_sap *)); +int spans_get_local_sap __P((spans_sap, Sap_t *)); +int spans_ephemeral_sap __P((struct spans *)); +int spans_get_spans_aal __P((Aal_t, spans_aal *)); +int spans_get_local_aal __P((spans_aal, Aal_t *)); +int spans_verify_vccb __P((struct spans *, + struct spans_vccb *)); +struct spans_vccb * + spans_find_vpvc __P((struct spans *, int, int, u_char)); +struct spans_vccb * + spans_find_conn __P((struct spans *, + struct spans_atm_conn *)); +spans_vpvc spans_alloc_vpvc __P((struct spans *)); +char * spans_addr_print __P((struct spans_addr *)); +void spans_dump_buffer __P((KBuffer *)); + + +/* + * External variables + */ +extern struct spans_addr spans_bcastaddr; +extern struct sp_info spans_vcpool; +extern struct sp_info spans_msgpool; +extern struct t_atm_cause spans_cause; + +#endif /* ATM_KERNEL */ + +#endif /* _SPANS_SPANS_VAR_H */ diff --git a/sys/netatm/spans/spans_xdr.x b/sys/netatm/spans/spans_xdr.x new file mode 100644 index 0000000..7e53f53 --- /dev/null +++ b/sys/netatm/spans/spans_xdr.x @@ -0,0 +1,513 @@ +%/* +% * +% * =================================== +% * HARP | Host ATM Research Platform +% * =================================== +% * +% * +% * This Host ATM Research Platform ("HARP") file (the "Software") is +% * made available by Network Computing Services, Inc. ("NetworkCS") +% * "AS IS". NetworkCS does not provide maintenance, improvements or +% * support of any kind. +% * +% * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, +% * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY +% * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE +% * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. +% * In no event shall NetworkCS be responsible for any damages, including +% * but not limited to consequential damages, arising from or relating to +% * any use of the Software or related support. +% * +% * Copyright 1994-1998 Network Computing Services, Inc. +% * +% * Copies of this Software may be made, however, the above copyright +% * notice must be reproduced on all copies. +% * +% * @(#) $Id: spans_xdr.x,v 1.4 1997/05/06 22:17:36 mks Exp $ +% * +% */ +% +/* + * SPANS Signalling Manager + * --------------------------- + * + * SPANS Protocol Message XDR Specification + * + */ + +#ifdef RPC_HDR +%/* +% * SPANS Signalling Manager +% * --------------------------- +% * +% * SPANS Protocol Message Definitions +% * +% */ +% +%#ifndef _SPANS_SPANS_XDR_H +%#define _SPANS_SPANS_XDR_H +% +%#include <rpc/types.h> +% +#endif + +#ifdef RPC_XDR +%/* +% * SPANS Signalling Manager +% * --------------------------- +% * +% * SPANS Protocol Message XDR Routines +% * +% */ +% +%#ifndef lint +%static char *RCSid = "@(#) $Id: spans_xdr.x,v 1.4 1997/05/06 22:17:36 mks Exp $"; +%#endif +% +#endif + + +/* + * SPANS Signalling + */ +const SPANS_SIG_VPI = 0; /* Signalling VPI */ +const SPANS_SIG_VCI = 15; /* Signalling VCI */ +const SPANS_CLS_VPI = 0; /* Connectionless VPI */ +const SPANS_CLS_VCI = 14; /* Connectionless VCI */ + +const SPANS_MIN_VCI = 32; /* Lowest VCI to allocate */ +const SPANS_MAX_VCI = 1023; /* Highest VCI to allocate */ +const SPANS_VPI = 0; /* Only VPI to allocate */ + +/* + * SPANS Protocol Version + * + * Major_version * 256 + Minor_version + */ +typedef u_int spans_version; + +const SPANS_VERS_1_0 = 0x0100; /* Version 1.0 */ + + +/* + * VPI/VCI + * + * Format: + * 4 bits - unused + * 12 bits - VPI value + * 16 bits - VCI value + */ +typedef u_int spans_vpvc; /* VPI/VCI value */ + +#ifdef RPC_HDR +%#define SPANS_EXTRACT_VPI(p) (((p) >> 16) & 0x0FFF) +%#define SPANS_EXTRACT_VCI(p) ((p) & 0x0FFFF) +%#define SPANS_PACK_VPIVCI(p, c) ((((p) & 0x0FFF) << 16) | ((c) & 0x0FFFF)) +#endif + + +/* + * VPI/VCI Preference + */ +struct spans_vpvc_pref { + bool vpf_valid; /* VPI/VCI values valid */ + spans_vpvc vpf_vpvc; /* VPI/VCI value */ +}; + + +/* + * SPANS ATM Address + */ +struct spans_addr { + opaque addr[8]; /* SPANS ATM address */ +}; + + +/* + * Service Access Point (SAP) + */ +typedef u_int spans_sap; /* SAP value */ + +const SPANS_SAP_IP = 1025; /* TCP/IP */ +const SPANS_SAP_EPHEMERAL = 2048; /* Start of ephemeral SAPs*/ + + +/* + * ATM Connection Identifier + */ +struct spans_atm_conn { + spans_addr con_dst; /* Destination ATM address */ + spans_addr con_src; /* Source ATM address */ + spans_sap con_dsap; /* Destination SAP */ + spans_sap con_ssap; /* Source SAP */ +}; + + +/* + * Connection Resources + */ +struct spans_resrc { + u_int rsc_peak; /* Peak bandwidth (Kbps) */ + u_int rsc_mean; /* Mean bandwidth (Kbps) */ + u_int rsc_burst; /* Mean burst (Kb) */ +}; + + +/* + * ATM Adaptation Layer (AAL) Types + */ +enum spans_aal { + SPANS_AAL0 = 0, /* NULL AAL */ + SPANS_AAL1 = 1, /* AAL 1 */ + SPANS_AAL2 = 2, /* AAL 2 */ + SPANS_AAL3 = 3, /* AAL 3 */ + SPANS_AAL4 = 4, /* AAL 4 */ + SPANS_AAL5 = 5 /* AAL 5 */ +}; + + +/* + * Result Codes + */ +enum spans_result { + SPANS_OK = 0, /* Success */ + SPANS_FAIL = 1, /* Failure */ + SPANS_NOVPVC = 2, /* No VP/VC */ + SPANS_NORSC = 3, /* No resources */ + SPANS_BADDEST = 4 /* Bad destination */ +}; + + +/* + * Message Types + */ +enum spans_msgtype { + /* + * SPANS UNI message types + */ + SPANS_STAT_REQ = 0, /* Status request */ + SPANS_STAT_IND = 1, /* Status indication */ + SPANS_STAT_RSP = 2, /* Status response */ + SPANS_OPEN_REQ = 3, /* Open request */ + SPANS_OPEN_IND = 4, /* Open indication */ + SPANS_OPEN_RSP = 5, /* Open response */ + SPANS_OPEN_CNF = 6, /* Open confirmation */ + SPANS_CLOSE_REQ = 7, /* Close request */ + SPANS_CLOSE_IND = 8, /* Close indication */ + SPANS_CLOSE_RSP = 9, /* Close response */ + SPANS_CLOSE_CNF = 10, /* Close confirmation */ + SPANS_RCLOSE_REQ = 11, /* Reverse close request */ + SPANS_RCLOSE_IND = 12, /* Reverse close indication */ + SPANS_RCLOSE_RSP = 13, /* Reverse close response */ + SPANS_RCLOSE_CNF = 14, /* Reverse close confirmation */ + SPANS_MULTI_REQ = 15, /* Multicast request */ + SPANS_MULTI_IND = 16, /* Multicast indication */ + SPANS_MULTI_RSP = 17, /* Multicast response */ + SPANS_MULTI_CNF = 18, /* Multicast confirmation */ + SPANS_ADD_REQ = 19, /* Add request */ + SPANS_ADD_IND = 20, /* Add indication */ + SPANS_ADD_RSP = 21, /* Add response */ + SPANS_ADD_CNF = 22, /* Add confirmation */ + SPANS_JOIN_REQ = 23, /* Join request */ + SPANS_JOIN_CNF = 24, /* Join confirmation */ + SPANS_LEAVE_REQ = 25, /* Leave request */ + SPANS_LEAVE_CNF = 26, /* Leave confirmation */ + + /* + * SPANS NNI message types + */ + SPANS_NSAP_IND = 99, /* NSAP routing message */ + SPANS_MAP_IND = 100, /* Topology message */ + SPANS_SETUP_REQ = 101, /* Setup request */ + SPANS_SETUP_RSP = 102, /* Setup response */ + SPANS_CHANGE_REQ = 103, /* Change request */ + SPANS_CHANGE_RSP = 104, /* Change response */ + SPANS_RELOC_REQ = 105, /* Relocation request */ + SPANS_RELOC_RSP = 106, /* Relocation response */ + SPANS_HELLO_IND = 107, /* Hello message */ + + SPANS_VCIR_IND = 108, /* VCI range indication */ + SPANS_QUERY_REQ = 110, /* Conn. state query request */ + SPANS_QUERY_RSP = 111 /* Conn. state query response */ +}; + + +/* + * Query types + */ +enum spans_query_type { + SPANS_QUERY_NORMAL, /* Normal--respond */ + SPANS_QUERY_DEBUG, /* Debug--respond with state */ + SPANS_QUERY_END_TO_END /* Not implemented */ +}; + + +/* + * SPANS connection states + */ +enum spans_conn_state { + SPANS_CONN_OPEN, /* Connection is open */ + SPANS_CONN_OPEN_PEND, /* Connection is being opened */ + SPANS_CONN_CLOSE_PEND, /* Connection is being closed */ + SPANS_CONN_CLOSED /* Connection does not exist */ +}; + + +/* + * Message Parameters + * + * There is a separate message parameter structure for each + * message type. + */ +struct spans_parm_stat_req { + u_long streq_es_epoch; /* End system epoch */ +}; + +struct spans_parm_stat_ind { + u_long stind_sw_epoch; /* Switch epoch */ + spans_addr stind_es_addr; /* End system ATM address */ + spans_addr stind_sw_addr; /* Switch ATM address */ +}; + +struct spans_parm_stat_rsp { + u_long strsp_es_epoch; /* End system epoch */ + spans_addr strsp_es_addr; /* End system ATM address */ +}; + +struct spans_parm_open_req { + spans_atm_conn opreq_conn; /* Connection identity */ + spans_aal opreq_aal; /* AAL type */ + spans_resrc opreq_desrsrc; /* Desired resources */ + spans_resrc opreq_minrsrc; /* Minimum resources */ + spans_vpvc_pref opreq_vpvc; /* VPI/VCI preference */ +}; + +struct spans_parm_open_ind { + spans_atm_conn opind_conn; /* Connection identity */ + spans_aal opind_aal; /* AAL type */ + spans_resrc opind_desrsrc; /* Desired resources */ + spans_resrc opind_minrsrc; /* Minimum resources */ + spans_vpvc_pref opind_vpvc; /* VPI/VCI preference */ +}; + +struct spans_parm_open_rsp { + spans_atm_conn oprsp_conn; /* Connection identity */ + spans_result oprsp_result; /* Open result */ + spans_resrc oprsp_rsrc; /* Allocated resources */ + spans_vpvc oprsp_vpvc; /* Allocated VPI/VCI */ +}; + +struct spans_parm_open_cnf { + spans_atm_conn opcnf_conn; /* Connection identity */ + spans_result opcnf_result; /* Open result */ + spans_resrc opcnf_rsrc; /* Allocated resources */ + spans_vpvc opcnf_vpvc; /* Allocated VPI/VCI */ +}; + +struct spans_parm_close_req { + spans_atm_conn clreq_conn; /* Connection identity */ +}; + +struct spans_parm_close_ind { + spans_atm_conn clind_conn; /* Connection identity */ +}; + +struct spans_parm_close_rsp { + spans_atm_conn clrsp_conn; /* Connection identity */ + spans_result clrsp_result; /* Close result */ +}; + +struct spans_parm_close_cnf { + spans_atm_conn clcnf_conn; /* Connection identity */ + spans_result clcnf_result; /* Close result */ +}; + +struct spans_parm_rclose_req { + spans_atm_conn rcreq_conn; /* Connection identity */ +}; + +struct spans_parm_rclose_ind { + spans_atm_conn rcind_conn; /* Connection identity */ +}; + +struct spans_parm_rclose_rsp { + spans_atm_conn rcrsp_conn; /* Connection identity */ + spans_result rcrsp_result; /* Rclose result */ +}; + +struct spans_parm_rclose_cnf { + spans_atm_conn rccnf_conn; /* Connection identity */ + spans_result rccnf_result; /* Rclose result */ +}; + +struct spans_parm_multi_req { + spans_atm_conn mureq_conn; /* Connection identity */ + spans_aal mureq_aal; /* AAL type */ + spans_resrc mureq_desrsrc; /* Desired resources */ + spans_resrc mureq_minrsrc; /* Minimum resources */ + spans_vpvc mureq_vpvc; /* VPI/VCI preference */ +}; + +struct spans_parm_multi_ind { + spans_atm_conn muind_conn; /* Connection identity */ + spans_aal muind_aal; /* AAL type */ + spans_resrc muind_desrsrc; /* Desired resources */ + spans_resrc muind_minrsrc; /* Minimum resources */ + spans_vpvc muind_vpvc; /* VPI/VCI preference */ +}; + +struct spans_parm_multi_rsp { + spans_atm_conn mursp_conn; /* Connection identity */ + spans_result mursp_result; /* Multi result */ + spans_resrc mursp_rsrc; /* Allocated resources */ + spans_vpvc mursp_vpvc; /* Allocated VPI/VCI */ +}; + +struct spans_parm_multi_cnf { + spans_atm_conn mucnf_conn; /* Connection identity */ + spans_result mucnf_result; /* Multi result */ + spans_resrc mucnf_rsrc; /* Allocated resources */ + spans_vpvc mucnf_vpvc; /* Allocated VPI/VCI */ +}; + +struct spans_parm_add_req { + spans_atm_conn adreq_desconn; /* Desired connection identity */ + spans_atm_conn adreq_xstconn; /* Existing connection identity */ +}; + +struct spans_parm_add_ind { + spans_atm_conn adind_desconn; /* Desired connection identity */ + spans_atm_conn adind_xstconn; /* Existing connection identity */ +}; + +struct spans_parm_add_rsp { + spans_atm_conn adrsp_conn; /* Connection identity */ + spans_result adrsp_result; /* Add result */ + spans_resrc adrsp_rsrc; /* Allocated resources */ +}; + +struct spans_parm_add_cnf { + spans_atm_conn adcnf_conn; /* Connection identity */ + spans_result adcnf_result; /* Add result */ + spans_resrc adcnf_rsrc; /* Allocated resources */ +}; + +struct spans_parm_join_req { + spans_addr jnreq_addr; /* Group address */ +}; + +struct spans_parm_join_cnf { + spans_addr jncnf_addr; /* Group address */ + spans_result jncnf_result; /* Join result */ +}; + +struct spans_parm_leave_req { + spans_addr lvreq_addr; /* Group address */ +}; + +struct spans_parm_leave_cnf { + spans_addr lvcnf_addr; /* Group address */ + spans_result lvcnf_result; /* Leave result */ +}; + +struct spans_parm_vcir_ind { + u_int vrind_min; /* Lowest VCI available */ + u_int vrind_max; /* Highest VCI available */ +}; + +struct spans_parm_query_req { + spans_atm_conn qyreq_conn; /* Conn. being queried */ + spans_query_type qyreq_type; /* Query type */ +}; + +struct spans_parm_query_rsp { + spans_atm_conn qyrsp_conn; /* Conn. being queried */ + spans_query_type qyrsp_type; /* Query type */ + spans_conn_state qyrsp_state; /* Conn. state */ + u_int qyrsp_data; /* Extra state data */ +}; + + +/* + * Message Body + */ +union spans_msgbody switch (spans_msgtype mb_type) { + +case SPANS_STAT_REQ: spans_parm_stat_req mb_stat_req; +case SPANS_STAT_IND: spans_parm_stat_ind mb_stat_ind; +case SPANS_STAT_RSP: spans_parm_stat_rsp mb_stat_rsp; +case SPANS_OPEN_REQ: spans_parm_open_req mb_open_req; +case SPANS_OPEN_IND: spans_parm_open_ind mb_open_ind; +case SPANS_OPEN_RSP: spans_parm_open_rsp mb_open_rsp; +case SPANS_OPEN_CNF: spans_parm_open_cnf mb_open_cnf; +case SPANS_CLOSE_REQ: spans_parm_close_req mb_close_req; +case SPANS_CLOSE_IND: spans_parm_close_ind mb_close_ind; +case SPANS_CLOSE_RSP: spans_parm_close_rsp mb_close_rsp; +case SPANS_CLOSE_CNF: spans_parm_close_cnf mb_close_cnf; +case SPANS_RCLOSE_REQ: spans_parm_rclose_req mb_rclose_req; +case SPANS_RCLOSE_IND: spans_parm_rclose_ind mb_rclose_ind; +case SPANS_RCLOSE_RSP: spans_parm_rclose_rsp mb_rclose_rsp; +case SPANS_RCLOSE_CNF: spans_parm_rclose_cnf mb_rclose_cnf; +case SPANS_MULTI_REQ: spans_parm_multi_req mb_multi_req; +case SPANS_MULTI_IND: spans_parm_multi_ind mb_multi_ind; +case SPANS_MULTI_RSP: spans_parm_multi_rsp mb_multi_rsp; +case SPANS_MULTI_CNF: spans_parm_multi_cnf mb_multi_cnf; +case SPANS_ADD_REQ: spans_parm_add_req mb_add_req; +case SPANS_ADD_IND: spans_parm_add_ind mb_add_ind; +case SPANS_ADD_RSP: spans_parm_add_rsp mb_add_rsp; +case SPANS_ADD_CNF: spans_parm_add_cnf mb_add_cnf; +case SPANS_JOIN_REQ: spans_parm_join_req mb_join_req; +case SPANS_JOIN_CNF: spans_parm_join_cnf mb_join_cnf; +case SPANS_LEAVE_REQ: spans_parm_leave_req mb_leave_req; +case SPANS_LEAVE_CNF: spans_parm_leave_cnf mb_leave_cnf; +case SPANS_VCIR_IND: spans_parm_vcir_ind mb_vcir_ind; +case SPANS_QUERY_REQ: spans_parm_query_req mb_query_req; +case SPANS_QUERY_RSP: spans_parm_query_rsp mb_query_rsp; +}; + + +/* + * Message Format + */ +struct spans_msg { + spans_version sm_vers; + spans_msgbody sm_body; +}; + +#ifdef RPC_HDR +%#define sm_type sm_body.mb_type +%#define sm_stat_req sm_body.spans_msgbody_u.mb_stat_req +%#define sm_stat_ind sm_body.spans_msgbody_u.mb_stat_ind +%#define sm_stat_rsp sm_body.spans_msgbody_u.mb_stat_rsp +%#define sm_open_req sm_body.spans_msgbody_u.mb_open_req +%#define sm_open_ind sm_body.spans_msgbody_u.mb_open_ind +%#define sm_open_rsp sm_body.spans_msgbody_u.mb_open_rsp +%#define sm_open_cnf sm_body.spans_msgbody_u.mb_open_cnf +%#define sm_close_req sm_body.spans_msgbody_u.mb_close_req +%#define sm_close_ind sm_body.spans_msgbody_u.mb_close_ind +%#define sm_close_rsp sm_body.spans_msgbody_u.mb_close_rsp +%#define sm_close_cnf sm_body.spans_msgbody_u.mb_close_cnf +%#define sm_rclose_req sm_body.spans_msgbody_u.mb_rclose_req +%#define sm_rclose_ind sm_body.spans_msgbody_u.mb_rclose_ind +%#define sm_rclose_rsp sm_body.spans_msgbody_u.mb_rclose_rsp +%#define sm_rclose_cnf sm_body.spans_msgbody_u.mb_rclose_cnf +%#define sm_multi_req sm_body.spans_msgbody_u.mb_multi_req +%#define sm_multi_ind sm_body.spans_msgbody_u.mb_multi_ind +%#define sm_multi_rsp sm_body.spans_msgbody_u.mb_multi_rsp +%#define sm_multi_cnf sm_body.spans_msgbody_u.mb_multi_cnf +%#define sm_add_req sm_body.spans_msgbody_u.mb_add_req +%#define sm_add_ind sm_body.spans_msgbody_u.mb_add_ind +%#define sm_add_rsp sm_body.spans_msgbody_u.mb_add_rsp +%#define sm_add_cnf sm_body.spans_msgbody_u.mb_add_cnf +%#define sm_join_req sm_body.spans_msgbody_u.mb_join_req +%#define sm_join_cnf sm_body.spans_msgbody_u.mb_join_cnf +%#define sm_leave_req sm_body.spans_msgbody_u.mb_leave_req +%#define sm_leave_cnf sm_body.spans_msgbody_u.mb_leave_cnf +%#define sm_vcir_ind sm_body.spans_msgbody_u.mb_vcir_ind +%#define sm_query_req sm_body.spans_msgbody_u.mb_query_req +%#define sm_query_rsp sm_body.spans_msgbody_u.mb_query_rsp +#endif + +#ifdef RPC_HDR +%#endif /* _SPANS_SPANS_XDR_H */ +#endif diff --git a/sys/netatm/uni/Makefile b/sys/netatm/uni/Makefile new file mode 100644 index 0000000..5b769b4 --- /dev/null +++ b/sys/netatm/uni/Makefile @@ -0,0 +1,93 @@ +# +# +# =================================== +# HARP | Host ATM Research Platform +# =================================== +# +# +# This Host ATM Research Platform ("HARP") file (the "Software") is +# made available by Network Computing Services, Inc. ("NetworkCS") +# "AS IS". NetworkCS does not provide maintenance, improvements or +# support of any kind. +# +# NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, +# INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY +# AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE +# SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. +# In no event shall NetworkCS be responsible for any damages, including +# but not limited to consequential damages, arising from or relating to +# any use of the Software or related support. +# +# Copyright 1994-1998 Network Computing Services, Inc. +# +# Copies of this Software may be made, however, the above copyright +# notice must be reproduced on all copies. +# +# @(#) $Id: Makefile,v 1.6 1998/08/26 23:29:17 mks Exp $ +# +# + +# +# ATM Forum UNI Support +# --------------------- +# +# Source directory Makefile +# +# + +DEFS= + +UNI_HDRS= uni.h +UNI_SRCS= uni_load.c +UNI_OBJS= uni_load.o + +SIG_HDRS= unisig.h unisig_decode.h unisig_mbuf.h \ + unisig_msg.h unisig_print.h unisig_var.h +SIG_SRCS= unisig_decode.c unisig_encode.c unisig_if.c \ + unisig_mbuf.c unisig_msg.c \ + unisig_print.c unisig_proto.c \ + unisig_sigmgr_state.c unisig_subr.c \ + unisig_util.c unisig_vc_state.c +SIG_OBJS= unisig_decode.o unisig_encode.o unisig_if.o \ + unisig_mbuf.o unisig_msg.o \ + unisig_print.o unisig_proto.o \ + unisig_sigmgr_state.o unisig_subr.o \ + unisig_util.o unisig_vc_state.o + +SAAL_HDRS= sscop.h sscop_misc.h sscop_pdu.h sscop_var.h \ + sscf_uni.h sscf_uni_var.h +SAAL_SRCS= sscop.c sscop_lower.c sscop_pdu.c sscop_sigaa.c \ + sscop_sigcpcs.c sscop_subr.c sscop_timer.c sscop_upper.c \ + qsaal1_sigaa.c qsaal1_sigcpcs.c qsaal1_subr.c \ + q2110_sigaa.c q2110_sigcpcs.c q2110_subr.c \ + sscf_uni.c sscf_uni_lower.c sscf_uni_upper.c +SAAL_OBJS= sscop.o sscop_lower.o sscop_pdu.o sscop_sigaa.o \ + sscop_sigcpcs.o sscop_subr.o sscop_timer.o sscop_upper.o \ + qsaal1_sigaa.o qsaal1_sigcpcs.o qsaal1_subr.o \ + q2110_sigaa.o q2110_sigcpcs.o q2110_subr.o \ + sscf_uni.o sscf_uni_lower.o sscf_uni_upper.o + +IP_HDRS= uniip_var.h +IP_SRCS= uniip.c uniarp.c uniarp_cache.c uniarp_input.c \ + uniarp_output.c uniarp_timer.c uniarp_vcm.c +IP_OBJS= uniip.o uniarp.o uniarp_cache.o uniarp_input.o \ + uniarp_output.o uniarp_timer.o uniarp_vcm.o + +HDRS= $(UNI_HDRS) $(SIG_HDRS) $(SAAL_HDRS) $(IP_HDRS) +SRCS= $(UNI_SRCS) $(SIG_SRCS) $(SAAL_SRCS) $(IP_SRCS) +OBJS= $(UNI_OBJS) $(SIG_OBJS) $(SAAL_OBJS) $(IP_OBJS) +MOD= uni_mod.o + +OBJDIR= ../../`../../config/mkobjname -d`/uni + +all $(OBJS) $(MOD) config install clean depend lint load unload: + @if [ -d $(OBJDIR) ]; then \ + echo "cd $(OBJDIR); $(MAKE) $@"; \ + cd $(OBJDIR); \ + $(MAKE) $(MFLAGS) DEFS='$(DEFS)' HDRS='$(HDRS)' SRCS='$(SRCS)' OBJS='$(OBJS)' $@; \ + exit $$?; \ + else \ + echo "Object directory \"$(OBJDIR)\" does not exist."; \ + exit 1; \ + fi + diff --git a/sys/netatm/uni/q2110_sigaa.c b/sys/netatm/uni/q2110_sigaa.c new file mode 100644 index 0000000..357df71 --- /dev/null +++ b/sys/netatm/uni/q2110_sigaa.c @@ -0,0 +1,516 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: q2110_sigaa.c,v 1.6 1998/08/26 23:29:18 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * ITU-T Q.2110 - Process AA-signals (SAP_SSCOP) + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: q2110_sigaa.c,v 1.6 1998/08/26 23:29:18 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscop_misc.h> +#include <netatm/uni/sscop_pdu.h> +#include <netatm/uni/sscop_var.h> + + +/* + * Local functions + */ +static void sscop_resreq_ready __P((struct sscop *, int, int)); +static void sscop_resrsp_inresyn __P((struct sscop *, int, int)); +static void sscop_recrsp_recovrsp __P((struct sscop *, int, int)); +static void sscop_recrsp_inrecov __P((struct sscop *, int, int)); + + +/* + * Stack command state lookup tables + */ +/* SSCOP_INIT */ +static void (*sscop_init_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + sscop_init_inst, /* SOS_INST */ + NULL, /* SOS_IDLE */ + NULL, /* SOS_OUTCONN */ + NULL, /* SOS_INCONN */ + NULL, /* SOS_OUTDISC */ + NULL, /* SOS_OUTRESYN */ + NULL, /* SOS_INRESYN */ + NULL, /* SOS_OUTRECOV */ + NULL, /* SOS_RECOVRSP */ + NULL, /* SOS_INRECOV */ + NULL, /* SOS_READY */ + NULL /* SOS_TERM */ +}; + +/* SSCOP_TERM */ +static void (*sscop_term_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + sscop_term_all, /* SOS_INST */ + sscop_term_all, /* SOS_IDLE */ + sscop_term_all, /* SOS_OUTCONN */ + sscop_term_all, /* SOS_INCONN */ + sscop_term_all, /* SOS_OUTDISC */ + sscop_term_all, /* SOS_OUTRESYN */ + sscop_term_all, /* SOS_INRESYN */ + sscop_term_all, /* SOS_OUTRECOV */ + sscop_term_all, /* SOS_RECOVRSP */ + sscop_term_all, /* SOS_INRECOV */ + sscop_term_all, /* SOS_READY */ + sscop_term_all /* SOS_TERM */ +}; + +/* SSCOP_ESTABLISH_REQ */ +static void (*sscop_estreq_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + sscop_estreq_idle, /* SOS_IDLE */ + NULL, /* SOS_OUTCONN */ + NULL, /* SOS_INCONN */ + sscop_estreq_idle, /* SOS_OUTDISC */ + NULL, /* SOS_OUTRESYN */ + NULL, /* SOS_INRESYN */ + NULL, /* SOS_OUTRECOV */ + NULL, /* SOS_RECOVRSP */ + NULL, /* SOS_INRECOV */ + NULL, /* SOS_READY */ + sscop_aa_noop_1 /* SOS_TERM */ +}; + +/* SSCOP_ESTABLISH_RSP */ +static void (*sscop_estrsp_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + NULL, /* SOS_IDLE */ + NULL, /* SOS_OUTCONN */ + sscop_estrsp_inconn, /* SOS_INCONN */ + NULL, /* SOS_OUTDISC */ + NULL, /* SOS_OUTRESYN */ + NULL, /* SOS_INRESYN */ + NULL, /* SOS_OUTRECOV */ + NULL, /* SOS_RECOVRSP */ + NULL, /* SOS_INRECOV */ + NULL, /* SOS_READY */ + sscop_aa_noop_1 /* SOS_TERM */ +}; + +/* SSCOP_RELEASE_REQ */ +static void (*sscop_relreq_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + NULL, /* SOS_IDLE */ + sscop_relreq_outconn, /* SOS_OUTCONN */ + sscop_relreq_inconn, /* SOS_INCONN */ + NULL, /* SOS_OUTDISC */ + sscop_relreq_outconn, /* SOS_OUTRESYN */ + sscop_relreq_outconn, /* SOS_INRESYN */ + sscop_relreq_ready, /* SOS_OUTRECOV */ + sscop_relreq_outconn, /* SOS_RECOVRSP */ + sscop_relreq_outconn, /* SOS_INRECOV */ + sscop_relreq_ready, /* SOS_READY */ + sscop_aa_noop_1 /* SOS_TERM */ +}; + +/* SSCOP_DATA_REQ */ +static void (*sscop_datreq_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + NULL, /* SOS_IDLE */ + NULL, /* SOS_OUTCONN */ + NULL, /* SOS_INCONN */ + NULL, /* SOS_OUTDISC */ + NULL, /* SOS_OUTRESYN */ + NULL, /* SOS_INRESYN */ + sscop_aa_noop_1, /* SOS_OUTRECOV */ + NULL, /* SOS_RECOVRSP */ + NULL, /* SOS_INRECOV */ + sscop_datreq_ready, /* SOS_READY */ + sscop_aa_noop_1 /* SOS_TERM */ +}; + +/* SSCOP_RESYNC_REQ */ +static void (*sscop_resreq_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + NULL, /* SOS_IDLE */ + NULL, /* SOS_OUTCONN */ + NULL, /* SOS_INCONN */ + NULL, /* SOS_OUTDISC */ + NULL, /* SOS_OUTRESYN */ + NULL, /* SOS_INRESYN */ + sscop_resreq_ready, /* SOS_OUTRECOV */ + sscop_resreq_ready, /* SOS_RECOVRSP */ + sscop_resreq_ready, /* SOS_INRECOV */ + sscop_resreq_ready, /* SOS_READY */ + sscop_aa_noop_1 /* SOS_TERM */ +}; + +/* SSCOP_RESYNC_RSP */ +static void (*sscop_resrsp_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + NULL, /* SOS_IDLE */ + NULL, /* SOS_OUTCONN */ + NULL, /* SOS_INCONN */ + NULL, /* SOS_OUTDISC */ + NULL, /* SOS_OUTRESYN */ + sscop_resrsp_inresyn, /* SOS_INRESYN */ + NULL, /* SOS_OUTRECOV */ + NULL, /* SOS_RECOVRSP */ + NULL, /* SOS_INRECOV */ + NULL, /* SOS_READY */ + sscop_aa_noop_0 /* SOS_TERM */ +}; + +/* SSCOP_RECOVER_RSP */ +static void (*sscop_recrsp_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + NULL, /* SOS_IDLE */ + NULL, /* SOS_OUTCONN */ + NULL, /* SOS_INCONN */ + NULL, /* SOS_OUTDISC */ + NULL, /* SOS_OUTRESYN */ + NULL, /* SOS_INRESYN */ + NULL, /* SOS_OUTRECOV */ + sscop_recrsp_recovrsp, /* SOS_RECOVRSP */ + sscop_recrsp_inrecov, /* SOS_INRECOV */ + NULL, /* SOS_READY */ + sscop_aa_noop_0 /* SOS_TERM */ +}; + +/* SSCOP_UNITDATA_REQ */ +static void (*sscop_udtreq_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + sscop_udtreq_all, /* SOS_IDLE */ + sscop_udtreq_all, /* SOS_OUTCONN */ + sscop_udtreq_all, /* SOS_INCONN */ + sscop_udtreq_all, /* SOS_OUTDISC */ + sscop_udtreq_all, /* SOS_OUTRESYN */ + sscop_udtreq_all, /* SOS_INRESYN */ + sscop_udtreq_all, /* SOS_OUTRECOV */ + sscop_udtreq_all, /* SOS_RECOVRSP */ + sscop_udtreq_all, /* SOS_INRECOV */ + sscop_udtreq_all, /* SOS_READY */ + sscop_aa_noop_1 /* SOS_TERM */ +}; + +/* SSCOP_RETRIEVE_REQ */ +static void (*sscop_retreq_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + NULL, /* SOS_IDLE */ + NULL, /* SOS_OUTCONN */ + NULL, /* SOS_INCONN */ + NULL, /* SOS_OUTDISC */ + NULL, /* SOS_OUTRESYN */ + NULL, /* SOS_INRESYN */ + NULL, /* SOS_OUTRECOV */ + NULL, /* SOS_RECOVRSP */ + NULL, /* SOS_INRECOV */ + NULL, /* SOS_READY */ + NULL /* SOS_TERM */ +}; + + +/* + * Stack command lookup table + */ +void (*(*sscop_q2110_aatab[SSCOP_CMD_SIZE])) + __P((struct sscop *, int, int)) = { + NULL, + sscop_init_tab, + sscop_term_tab, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + sscop_estreq_tab, + NULL, + sscop_estrsp_tab, + NULL, + sscop_relreq_tab, + NULL, + NULL, + sscop_datreq_tab, + NULL, + sscop_resreq_tab, + NULL, + sscop_resrsp_tab, + NULL, + NULL, + sscop_recrsp_tab, + sscop_udtreq_tab, + NULL, + sscop_retreq_tab, + NULL, + NULL +}; + + +/* + * SSCOP_RESYNC_REQ / SOS_READY Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 pointer to buffer containing SSCOP-UU data + * arg2 unused + * + * Returns: + * none + * + */ +static void +sscop_resreq_ready(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + + /* + * We don't support SSCOP-UU data + */ + if (arg1 != SSCOP_UU_NULL) + KB_FREEALL((KBuffer *)arg1); + + /* + * Stop data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_timer[SSCOP_T_NORESP] = 0; + sop->so_timer[SSCOP_T_IDLE] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Initialize receiver window + */ + SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin); + + /* + * Send first RS PDU + */ + sop->so_connctl = 1; + SEQ_INCR(sop->so_sendconn, 1); + (void) sscop_send_rs(sop); + + /* + * Drain transmit and receive queues + */ + sscop_xmit_drain(sop); + sscop_rcvr_drain(sop); + + /* + * Set retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = sop->so_parm.sp_timecc; + + /* + * Wait for RSAK + */ + sop->so_state = SOS_OUTRESYN; + + return; +} + + +/* + * SSCOP_RESYNC_RSP / SOS_INRESYN Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 unused + * arg2 unused + * + * Returns: + * none + * + */ +static void +sscop_resrsp_inresyn(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + + /* + * Clear transmitter buffers + */ + q2110_clear_xmit(sop); + + /* + * Initialize state variables + */ + SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin); + q2110_init_state(sop); + + /* + * Send RSAK PDU + */ + (void) sscop_send_rsak(sop); + + /* + * Start data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll; + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + + /* + * Back to data transfer state + */ + sop->so_state = SOS_READY; + + return; +} + + +/* + * SSCOP_RECOVER_RSP / SOS_RECOVRSP Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 unused + * arg2 unused + * + * Returns: + * none + * + */ +static void +sscop_recrsp_recovrsp(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + + /* + * Clear transmitter buffers, if not done earlier + */ + if (sop->so_flags & SOF_NOCLRBUF) + q2110_clear_xmit(sop); + + /* + * Initialize state variables + */ + q2110_init_state(sop); + + /* + * Start data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll; + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + + /* + * Back to data transfer state + */ + sop->so_state = SOS_READY; + + /* + * See if transmit queues need servicing + */ + if (sop->so_flags & SOF_XMITSRVC) + sscop_service_xmit(sop); + + return; +} + + +/* + * SSCOP_RECOVER_RSP / SOS_INRECOV Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 unused + * arg2 unused + * + * Returns: + * none + * + */ +static void +sscop_recrsp_inrecov(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + + /* + * Clear transmitter buffers, if not done earlier + */ + if (sop->so_flags & SOF_NOCLRBUF) + q2110_clear_xmit(sop); + + /* + * Initialize state variables + */ + SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin); + q2110_init_state(sop); + + /* + * Send ERAK PDU + */ + (void) sscop_send_erak(sop); + + /* + * Start data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll; + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + + /* + * Back to data transfer state + */ + sop->so_state = SOS_READY; + + /* + * See if transmit queues need servicing + */ + if (sop->so_flags & SOF_XMITSRVC) + sscop_service_xmit(sop); + + return; +} + diff --git a/sys/netatm/uni/q2110_sigcpcs.c b/sys/netatm/uni/q2110_sigcpcs.c new file mode 100644 index 0000000..0fa5555 --- /dev/null +++ b/sys/netatm/uni/q2110_sigcpcs.c @@ -0,0 +1,1760 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: q2110_sigcpcs.c,v 1.7 1998/08/26 23:29:18 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * ITU-T Q.2110 - Process CPCS-signals (SSCOP PDUs) + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: q2110_sigcpcs.c,v 1.7 1998/08/26 23:29:18 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscop_misc.h> +#include <netatm/uni/sscop_pdu.h> +#include <netatm/uni/sscop_var.h> + + +/* + * Local functions + */ +static void sscop_bgn_outconn __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_bgn_inconn __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_bgn_ready __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_bgrej_outrecov __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_end_outrecov __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_end_ready __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_endak_outrecov __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_rs_outresyn __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_rs_inresyn __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_rs_outrecov __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_rs_ready __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_er_error __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_er_idle __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_er_outrecov __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_er_recovrsp __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_er_inrecov __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_er_ready __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_erak_error __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_erak_idle __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_erak_outrecov __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_sd_ready __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_poll_ready __P((struct sscop *, KBuffer *, caddr_t)); + + +/* + * PDU type state lookup tables + */ +/* BGN PDU */ +static void (*sscop_bgn_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_bgn_idle, /* SOS_IDLE */ + sscop_bgn_outconn, /* SOS_OUTCONN */ + sscop_bgn_inconn, /* SOS_INCONN */ + sscop_bgn_outdisc, /* SOS_OUTDISC */ + sscop_bgn_outresyn, /* SOS_OUTRESYN */ + sscop_bgn_inresyn, /* SOS_INRESYN */ + sscop_bgn_inresyn, /* SOS_OUTRECOV */ + sscop_bgn_inresyn, /* SOS_RECOVRSP */ + sscop_bgn_inresyn, /* SOS_INRECOV */ + sscop_bgn_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* BGAK PDU */ +static void (*sscop_bgak_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_bgak_idle, /* SOS_IDLE */ + sscop_bgak_outconn, /* SOS_OUTCONN */ + sscop_bgak_error, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_noop, /* SOS_OUTRESYN */ + sscop_bgak_error, /* SOS_INRESYN */ + sscop_bgak_error, /* SOS_OUTRECOV */ + sscop_bgak_error, /* SOS_RECOVRSP */ + sscop_bgak_error, /* SOS_INRECOV */ + sscop_noop, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* BGREJ PDU */ +static void (*sscop_bgrej_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_bgrej_error, /* SOS_IDLE */ + sscop_bgrej_outconn, /* SOS_OUTCONN */ + sscop_bgrej_inconn, /* SOS_INCONN */ + sscop_endak_outdisc, /* SOS_OUTDISC */ + sscop_bgrej_outresyn, /* SOS_OUTRESYN */ + sscop_bgrej_inconn, /* SOS_INRESYN */ + sscop_bgrej_outrecov, /* SOS_OUTRECOV */ + sscop_bgrej_inconn, /* SOS_RECOVRSP */ + sscop_bgrej_inconn, /* SOS_INRECOV */ + sscop_bgrej_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* END PDU */ +static void (*sscop_end_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_end_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_end_inconn, /* SOS_INCONN */ + sscop_end_outdisc, /* SOS_OUTDISC */ + sscop_end_inconn, /* SOS_OUTRESYN */ + sscop_end_inconn, /* SOS_INRESYN */ + sscop_end_outrecov, /* SOS_OUTRECOV */ + sscop_end_inconn, /* SOS_RECOVRSP */ + sscop_end_inconn, /* SOS_INRECOV */ + sscop_end_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* ENDAK PDU */ +static void (*sscop_endak_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_noop, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_endak_inconn, /* SOS_INCONN */ + sscop_endak_outdisc, /* SOS_OUTDISC */ + sscop_endak_inconn, /* SOS_OUTRESYN */ + sscop_endak_inconn, /* SOS_INRESYN */ + sscop_endak_outrecov, /* SOS_OUTRECOV */ + sscop_endak_inconn, /* SOS_RECOVRSP */ + sscop_endak_inconn, /* SOS_INRECOV */ + sscop_endak_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* RS PDU */ +static void (*sscop_rs_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_rs_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_rs_error, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_rs_outresyn, /* SOS_OUTRESYN */ + sscop_rs_inresyn, /* SOS_INRESYN */ + sscop_rs_outrecov, /* SOS_OUTRECOV */ + sscop_rs_outrecov, /* SOS_RECOVRSP */ + sscop_rs_outrecov, /* SOS_INRECOV */ + sscop_rs_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* RSAK PDU */ +static void (*sscop_rsak_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_rsak_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_rsak_error, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_rsak_outresyn, /* SOS_OUTRESYN */ + sscop_rsak_error, /* SOS_INRESYN */ + sscop_rsak_error, /* SOS_OUTRECOV */ + sscop_rsak_error, /* SOS_RECOVRSP */ + sscop_rsak_error, /* SOS_INRECOV */ + sscop_noop, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* ER PDU */ +static void (*sscop_er_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_er_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_er_error, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_noop, /* SOS_OUTRESYN */ + sscop_er_error, /* SOS_INRESYN */ + sscop_er_outrecov, /* SOS_OUTRECOV */ + sscop_er_recovrsp, /* SOS_RECOVRSP */ + sscop_er_inrecov, /* SOS_INRECOV */ + sscop_er_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* ERAK PDU */ +static void (*sscop_erak_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_erak_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_erak_error, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_noop, /* SOS_OUTRESYN */ + sscop_erak_error, /* SOS_INRESYN */ + sscop_erak_outrecov, /* SOS_OUTRECOV */ + sscop_noop, /* SOS_RECOVRSP */ + sscop_erak_error, /* SOS_INRECOV */ + sscop_noop, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* SD PDU */ +static void (*sscop_sd_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_sd_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_sd_inconn, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_noop, /* SOS_OUTRESYN */ + sscop_sd_inconn, /* SOS_INRESYN */ + sscop_noop, /* SOS_OUTRECOV */ + sscop_noop, /* SOS_RECOVRSP */ + sscop_sd_inconn, /* SOS_INRECOV */ + sscop_sd_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* POLL PDU */ +static void (*sscop_poll_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_poll_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_poll_inconn, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_noop, /* SOS_OUTRESYN */ + sscop_poll_inconn, /* SOS_INRESYN */ + sscop_noop, /* SOS_OUTRECOV */ + sscop_noop, /* SOS_RECOVRSP */ + sscop_poll_inconn, /* SOS_INRECOV */ + sscop_poll_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* STAT PDU */ +static void (*sscop_stat_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_stat_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_stat_inconn, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_noop, /* SOS_OUTRESYN */ + sscop_stat_inconn, /* SOS_INRESYN */ + sscop_noop, /* SOS_OUTRECOV */ + sscop_stat_inconn, /* SOS_RECOVRSP */ + sscop_stat_inconn, /* SOS_INRECOV */ + sscop_stat_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* USTAT PDU */ +static void (*sscop_ustat_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_ustat_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_ustat_inconn, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_noop, /* SOS_OUTRESYN */ + sscop_ustat_inconn, /* SOS_INRESYN */ + sscop_noop, /* SOS_OUTRECOV */ + sscop_ustat_inconn, /* SOS_RECOVRSP */ + sscop_ustat_inconn, /* SOS_INRECOV */ + sscop_ustat_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* UD PDU */ +static void (*sscop_ud_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_ud_all, /* SOS_IDLE */ + sscop_ud_all, /* SOS_OUTCONN */ + sscop_ud_all, /* SOS_INCONN */ + sscop_ud_all, /* SOS_OUTDISC */ + sscop_ud_all, /* SOS_OUTRESYN */ + sscop_ud_all, /* SOS_INRESYN */ + sscop_ud_all, /* SOS_OUTRECOV */ + sscop_ud_all, /* SOS_RECOVRSP */ + sscop_ud_all, /* SOS_INRECOV */ + sscop_ud_all, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* MD PDU */ +static void (*sscop_md_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_md_all, /* SOS_IDLE */ + sscop_md_all, /* SOS_OUTCONN */ + sscop_md_all, /* SOS_INCONN */ + sscop_md_all, /* SOS_OUTDISC */ + sscop_md_all, /* SOS_OUTRESYN */ + sscop_md_all, /* SOS_INRESYN */ + sscop_md_all, /* SOS_OUTRECOV */ + sscop_md_all, /* SOS_RECOVRSP */ + sscop_md_all, /* SOS_INRECOV */ + sscop_md_all, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + + +/* + * PDU type lookup table + */ +void (*(*sscop_q2110_pdutab[])) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, + sscop_bgn_tab, + sscop_bgak_tab, + sscop_end_tab, + sscop_endak_tab, + sscop_rs_tab, + sscop_rsak_tab, + sscop_bgrej_tab, + sscop_sd_tab, + sscop_er_tab, + sscop_poll_tab, + sscop_stat_tab, + sscop_ustat_tab, + sscop_ud_tab, + sscop_md_tab, + sscop_erak_tab +}; + + +/* + * BGN PDU / SOS_OUTCONN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_bgn_outconn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct bgn_pdu *bp = (struct bgn_pdu *)trlr; + int err; + + /* + * If retransmitted BGN, ignore it + */ + if (sscop_is_rexmit(sop, bp->bgn_nsq)) { + KB_FREEALL(m); + return; + } + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Initialize state variables + */ + SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr)); + SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin); + q2110_init_state(sop); + + /* + * Return an ACK to peer + */ + (void) sscop_send_bgak(sop); + + /* + * Notify user of connection establishment + */ + STACK_CALL(SSCOP_ESTABLISH_CNF, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, 0, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Start data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll; + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + + /* + * OK, we're ready for data + */ + sop->so_state = SOS_READY; + + /* + * See if transmit queues need servicing + */ + if (sop->so_flags & SOF_XMITSRVC) + sscop_service_xmit(sop); + + return; +} + + +/* + * BGN PDU / SOS_INCONN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_bgn_inconn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct bgn_pdu *bp = (struct bgn_pdu *)trlr; + int err; + + /* + * If retransmitted BGN, ignore it + */ + if (sscop_is_rexmit(sop, bp->bgn_nsq)) { + KB_FREEALL(m); + return; + } + + /* + * Initialize transmit window + */ + SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr)); + + /* + * First, tell user current connection has been released + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_USER, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Now, tell user of new connection establishment + */ + STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, 0, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + return; +} + + +/* + * BGN PDU / SOS_READY Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_bgn_ready(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct bgn_pdu *bp = (struct bgn_pdu *)trlr; + int err; + + /* + * If retransmitted BGN, just ACK it again + */ + if (sscop_is_rexmit(sop, bp->bgn_nsq)) { + KB_FREEALL(m); + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + (void) sscop_send_bgak(sop); + return; + } + + /* + * Stop data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_timer[SSCOP_T_NORESP] = 0; + sop->so_timer[SSCOP_T_IDLE] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Initialize transmit window + */ + SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr)); + + /* + * Clear out appropriate queues + */ + q2110_prep_retrieve(sop); + + /* + * Tell user current connection has been released + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_USER, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Tell user of incoming connection + */ + STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, 0, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Wait for user's response + */ + sop->so_state = SOS_INCONN; + + return; +} + + +/* + * BGREJ PDU / SOS_OUTRECOV Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_bgrej_outrecov(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Report protocol error + */ + sscop_bgrej_error(sop, m, trlr); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Clear receiver buffer + */ + sscop_rcvr_drain(sop); + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * END PDU / SOS_OUTRECOV Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_end_outrecov(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct end_pdu *ep = (struct end_pdu *)trlr; + int err, source; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Acknowledge END + */ + (void) sscop_send_endak(sop); + + /* + * Get Source value + */ + if (ep->end_type & PT_SOURCE_SSCOP) + source = SSCOP_SOURCE_SSCOP; + else + source = SSCOP_SOURCE_USER; + + /* + * Notify user of connection termination + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, source, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Clear receiver buffer + */ + sscop_rcvr_drain(sop); + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * END PDU / SOS_READY Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_end_ready(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct end_pdu *ep = (struct end_pdu *)trlr; + int err, source; + + /* + * Stop data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_timer[SSCOP_T_NORESP] = 0; + sop->so_timer[SSCOP_T_IDLE] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Acknowledge END + */ + (void) sscop_send_endak(sop); + + /* + * Get Source value + */ + if (ep->end_type & PT_SOURCE_SSCOP) + source = SSCOP_SOURCE_SSCOP; + else + source = SSCOP_SOURCE_USER; + + /* + * Notify user of connection termination + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, source, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Clear out appropriate queues + */ + q2110_prep_retrieve(sop); + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * ENDAK PDU / SOS_OUTRECOV Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_endak_outrecov(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Report protocol error + */ + sscop_endak_error(sop, m, trlr); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Clear receiver buffer + */ + sscop_rcvr_drain(sop); + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * RS PDU / SOS_OUTRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_rs_outresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct rs_pdu *rp = (struct rs_pdu *)trlr; + int err; + + /* + * If retransmitted RS, ignore it + */ + if (sscop_is_rexmit(sop, rp->rs_nsq)) { + KB_FREEALL(m); + return; + } + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Initialize state variables + */ + SEQ_SET(sop->so_sendmax, ntohl(rp->rs_nmr)); + SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin); + q2110_init_state(sop); + + /* + * Free PDU buffers + */ + KB_FREEALL(m); + + /* + * Return an ACK to peer + */ + (void) sscop_send_rsak(sop); + + /* + * Notify user of connection resynchronization + */ + STACK_CALL(SSCOP_RESYNC_CNF, sop->so_upper, sop->so_toku, + sop->so_connvc, 0, 0, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Start data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll; + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + + /* + * OK, we're ready for data + */ + sop->so_state = SOS_READY; + + /* + * See if transmit queues need servicing + */ + if (sop->so_flags & SOF_XMITSRVC) + sscop_service_xmit(sop); + + return; +} + + +/* + * RS PDU / SOS_INRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_rs_inresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct rs_pdu *rp = (struct rs_pdu *)trlr; + + /* + * If retransmitted RS, ignore it + */ + if (sscop_is_rexmit(sop, rp->rs_nsq)) { + KB_FREEALL(m); + return; + } + + /* + * Report error condition + */ + sscop_rs_error(sop, m, trlr); + + return; +} + + +/* + * RS PDU / SOS_OUTRECOV Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_rs_outrecov(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct rs_pdu *rp = (struct rs_pdu *)trlr; + int err; + + /* + * If retransmitted RS, report an error + */ + if (sscop_is_rexmit(sop, rp->rs_nsq)) { + sscop_rs_error(sop, m, trlr); + return; + } + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Initialize transmit window + */ + SEQ_SET(sop->so_sendmax, ntohl(rp->rs_nmr)); + + /* + * Notify user of connection resynchronization + */ + STACK_CALL(SSCOP_RESYNC_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, 0, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Clear receiver buffer + */ + sscop_rcvr_drain(sop); + + /* + * Wait for user response + */ + sop->so_state = SOS_INRESYN; + + return; +} + + +/* + * RS PDU / SOS_READY Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_rs_ready(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct rs_pdu *rp = (struct rs_pdu *)trlr; + int err; + + /* + * If retransmitted RS, just ACK it + */ + if (sscop_is_rexmit(sop, rp->rs_nsq)) { + KB_FREEALL(m); + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + sscop_send_rsak(sop); + return; + } + + /* + * Stop data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_timer[SSCOP_T_NORESP] = 0; + sop->so_timer[SSCOP_T_IDLE] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Initialize transmit window + */ + SEQ_SET(sop->so_sendmax, ntohl(rp->rs_nmr)); + + /* + * Notify user of connection resynchronization + */ + STACK_CALL(SSCOP_RESYNC_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, 0, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Clear out appropriate queues + */ + q2110_prep_retrieve(sop); + + /* + * Wait for user response + */ + sop->so_state = SOS_INRESYN; + + return; +} + +/* + * ER PDU / Protocol Error + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_er_error(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Record error condition + */ + sscop_maa_error(sop, 'L'); + KB_FREEALL(m); + + return; +} + + +/* + * ER PDU / SOS_IDLE Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_er_idle(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Record error condition + */ + sscop_er_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + return; +} + + +/* + * ER PDU / SOS_OUTRECOV Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_er_outrecov(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct er_pdu *ep = (struct er_pdu *)trlr; + int err; + + /* + * If retransmitted ER, report an error + */ + if (sscop_is_rexmit(sop, ep->er_nsq)) { + sscop_er_error(sop, m, trlr); + return; + } + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Initialize transmit window + */ + SEQ_SET(sop->so_sendmax, ntohl(ep->er_nmr)); + + /* + * Initialize receiver window + */ + SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin); + + /* + * Free PDU buffers + */ + KB_FREEALL(m); + + /* + * Acknowledge ER + */ + (void) sscop_send_erak(sop); + + /* + * Deliver any outstanding data to user + */ + q2110_deliver_data(sop); + + /* + * Notify user of connection recovery + */ + STACK_CALL(SSCOP_RECOVER_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, 0, 0, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Wait for user response + */ + sop->so_state = SOS_RECOVRSP; + + return; +} + + +/* + * ER PDU / SOS_RECOVRSP Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_er_recovrsp(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct er_pdu *ep = (struct er_pdu *)trlr; + + /* + * If retransmitted ER, just ACK it + */ + if (sscop_is_rexmit(sop, ep->er_nsq)) { + KB_FREEALL(m); + (void) sscop_send_erak(sop); + return; + } + + /* + * Report error condition + */ + sscop_er_error(sop, m, trlr); + + return; +} + + +/* + * ER PDU / SOS_INRECOV Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_er_inrecov(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct er_pdu *ep = (struct er_pdu *)trlr; + + /* + * If retransmitted ER, just ignore it + */ + if (sscop_is_rexmit(sop, ep->er_nsq)) { + KB_FREEALL(m); + return; + } + + /* + * Report error condition + */ + sscop_er_error(sop, m, trlr); + + return; +} + + +/* + * ER PDU / SOS_READY Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_er_ready(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct er_pdu *ep = (struct er_pdu *)trlr; + int err; + + /* + * If retransmitted ER, just ACK it + */ + if (sscop_is_rexmit(sop, ep->er_nsq)) { + KB_FREEALL(m); + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + sscop_send_erak(sop); + return; + } + + /* + * Stop data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_timer[SSCOP_T_NORESP] = 0; + sop->so_timer[SSCOP_T_IDLE] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Initialize transmit window + */ + SEQ_SET(sop->so_sendmax, ntohl(ep->er_nmr)); + + /* + * Free PDU buffers + */ + KB_FREEALL(m); + + /* + * Clear out appropriate queues + */ + q2110_prep_recovery(sop); + + /* + * Deliver any outstanding data to user + */ + q2110_deliver_data(sop); + + /* + * Notify user of connection recovery + */ + STACK_CALL(SSCOP_RECOVER_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, 0, 0, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Wait for user response + */ + sop->so_state = SOS_INRECOV; + + return; +} + + +/* + * ERAK PDU / Protocol Error + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_erak_error(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Record error condition + */ + sscop_maa_error(sop, 'M'); + KB_FREEALL(m); + + return; +} + + +/* + * ERAK PDU / SOS_IDLE Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_erak_idle(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Record error condition + */ + sscop_erak_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + return; +} + + +/* + * ERAK PDU / SOS_OUTRECOV Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_erak_outrecov(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct erak_pdu *ep = (struct erak_pdu *)trlr; + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Initialize transmit window + */ + SEQ_SET(sop->so_sendmax, ntohl(ep->erak_nmr)); + + /* + * Free PDU buffers + */ + KB_FREEALL(m); + + /* + * Deliver any outstanding data to user + */ + q2110_deliver_data(sop); + + /* + * Notify user of connection recovery + */ + STACK_CALL(SSCOP_RECOVER_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, 0, 0, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Wait for user response + */ + sop->so_state = SOS_RECOVRSP; + + return; +} + + +/* + * SD PDU / SOS_READY Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_sd_ready(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct sd_pdu *sp = (struct sd_pdu *)trlr; + struct pdu_hdr *php; + KBuffer *n; + sscop_seq ns; + int err, space; + + /* + * Get PDU sequence number + */ + SEQ_SET(ns, ntohl(sp->sd_ns)); + + /* + * Ensure that the sequence number fits within the window + */ + if (SEQ_GEQ(ns, sop->so_rcvmax, sop->so_rcvnext)) { + /* + * It doesn't, drop received data + */ + KB_FREEALL(m); + + /* + * If next highest PDU hasn't reached window end yet, + * then send a USTAT to inform transmitter of this gap + */ + if (SEQ_LT(sop->so_rcvhigh, sop->so_rcvmax, sop->so_rcvnext)) { + (void) sscop_send_ustat(sop, sop->so_rcvmax); + sop->so_rcvhigh = sop->so_rcvmax; + } + return; + } + + /* + * If this is the next in-sequence PDU, hand it to user + */ + if (ns == sop->so_rcvnext) { + STACK_CALL(SSCOP_DATA_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, ns, err); + if (err) { + KB_FREEALL(m); + return; + } + + /* + * Bump next expected sequence number + */ + SEQ_INCR(sop->so_rcvnext, 1); + + /* + * Slide receive window down + */ + SEQ_INCR(sop->so_rcvmax, 1); + + /* + * Is this the highest sequence PDU we've received?? + */ + if (ns == sop->so_rcvhigh) { + /* + * Yes, bump the limit and exit + */ + sop->so_rcvhigh = sop->so_rcvnext; + return; + } + + /* + * This is a retransmitted PDU, so see if we have + * more in-sequence PDUs already queued up + */ + while ((php = sop->so_recv_hd) && + (php->ph_ns == sop->so_rcvnext)) { + + /* + * Yup we do, so remove next PDU from queue and + * pass it up to the user as well + */ + sop->so_recv_hd = php->ph_recv_lk; + if (sop->so_recv_hd == NULL) + sop->so_recv_tl = NULL; + STACK_CALL(SSCOP_DATA_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)php->ph_buf, php->ph_ns, + err); + if (err) { + /* + * Should never happen, but... + */ + KB_FREEALL(php->ph_buf); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Bump next expected sequence number + */ + SEQ_INCR(sop->so_rcvnext, 1); + + /* + * Slide receive window down + */ + SEQ_INCR(sop->so_rcvmax, 1); + } + + /* + * Finished with data delivery... + */ + return; + } + + /* + * We're gonna have to queue this PDU, so find space + * for the PDU header + */ + KB_HEADROOM(m, space); + + /* + * If there's not enough room in the received buffer, + * allocate & link a new buffer for the header + */ + if (space < sizeof(struct pdu_hdr)) { + + KB_ALLOC(n, sizeof(struct pdu_hdr), KB_F_NOWAIT, KB_T_HEADER); + if (n == NULL) { + KB_FREEALL(m); + return; + } + KB_HEADSET(n, sizeof(struct pdu_hdr)); + KB_LEN(n) = 0; + KB_LINKHEAD(n, m); + m = n; + } + + /* + * Build PDU header + * + * We can at least assume/require that the start of + * the user data is aligned. Also note that we don't + * include this header in the buffer len/offset fields. + */ + KB_DATASTART(m, php, struct pdu_hdr *); + php--; + php->ph_ns = ns; + php->ph_buf = m; + + /* + * Insert PDU into the receive queue + */ + if (sscop_recv_insert(sop, php)) { + /* + * Oops, a duplicate sequence number PDU is already on + * the queue, somethings wrong here. + */ + sscop_maa_error(sop, 'Q'); + + /* + * Free buffers + */ + KB_FREEALL(m); + + /* + * Go into recovery mode + */ + q2110_error_recovery(sop); + + return; + } + + /* + * Are we at the high-water mark?? + */ + if (ns == sop->so_rcvhigh) { + /* + * Yes, just bump the mark + */ + SEQ_INCR(sop->so_rcvhigh, 1); + + return; + } + + /* + * Are we beyond the high-water mark?? + */ + if (SEQ_GT(ns, sop->so_rcvhigh, sop->so_rcvnext)) { + /* + * Yes, then there's a missing PDU, so inform the transmitter + */ + (void) sscop_send_ustat(sop, ns); + + /* + * Update high-water mark + */ + sop->so_rcvhigh = SEQ_ADD(ns, 1); + } + + return; +} + + +/* + * POLL PDU / SOS_READY Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_poll_ready(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct poll_pdu *pp = (struct poll_pdu *)trlr; + sscop_seq nps; + + NTOHL(pp->poll_ns); + + /* + * If the poll sequence number is less than highest number + * we've already seen, something's wrong + */ + if (SEQ_LT(pp->poll_ns, sop->so_rcvhigh, sop->so_rcvnext)) { + /* + * Record error condition + */ + sscop_maa_error(sop, 'Q'); + + /* + * Free buffers + */ + KB_FREEALL(m); + + /* + * Go into recovery mode + */ + q2110_error_recovery(sop); + + return; + } + + /* + * Set a new "next highest" sequence number expected + */ + if (SEQ_LT(pp->poll_ns, sop->so_rcvmax, sop->so_rcvnext)) + SEQ_SET(sop->so_rcvhigh, pp->poll_ns); + else + sop->so_rcvhigh = sop->so_rcvmax; + + /* + * Return a STAT PDU to peer + */ + SEQ_SET(nps, ntohl(pp->poll_nps)); + KB_FREEALL(m); + (void) sscop_send_stat(sop, nps); + + return; +} + diff --git a/sys/netatm/uni/q2110_subr.c b/sys/netatm/uni/q2110_subr.c new file mode 100644 index 0000000..4c6036b --- /dev/null +++ b/sys/netatm/uni/q2110_subr.c @@ -0,0 +1,239 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: q2110_subr.c,v 1.1 1998/04/07 23:15:20 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * ITU-T Q.2110 - Subroutines + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: q2110_subr.c,v 1.1 1998/04/07 23:15:20 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscop_misc.h> +#include <netatm/uni/sscop_pdu.h> +#include <netatm/uni/sscop_var.h> + + +/* + * Conditionally Clear Transmission Queues + * + * Arguments: + * sop pointer to sscop connection block + * + * Returns: + * none + * + */ +void +q2110_clear_xmit(sop) + struct sscop *sop; +{ + /* + * Only clear queues if 'Clear Buffers' == No + */ + if (sop->so_flags & SOF_NOCLRBUF) + sscop_xmit_drain(sop); +} + + +/* + * Initialize Data Transfer State Variables + * + * Arguments: + * sop pointer to sscop connection block + * + * Returns: + * none + * + */ +void +q2110_init_state(sop) + struct sscop *sop; +{ + /* + * Initialize for entry into Data Transfer Ready state + */ + sop->so_send = 0; + sop->so_pollsend = 0; + sop->so_ack = 0; + sop->so_pollack = 1; + sop->so_polldata = 0; + sop->so_rcvhigh = 0; + sop->so_rcvnext = 0; +} + + +/* + * Prepare Queues for Data Retrieval + * + * Arguments: + * sop pointer to sscop connection block + * + * Returns: + * none + * + */ +void +q2110_prep_retrieve(sop) + struct sscop *sop; +{ + /* + * If 'Clear Buffers' == No, just clear retransmit queue, + * else clear all transmission queues + */ + if (sop->so_flags & SOF_NOCLRBUF) { + sop->so_rexmit_hd = NULL; + sop->so_rexmit_tl = NULL; + } else + sscop_xmit_drain(sop); + + /* + * Clear receiver queue + */ + sscop_rcvr_drain(sop); +} + + +/* + * Prepare Queues for Error Recovery + * + * Arguments: + * sop pointer to sscop connection block + * + * Returns: + * none + * + */ +void +q2110_prep_recovery(sop) + struct sscop *sop; +{ + /* + * If 'Clear Buffers' == No, just clear retransmit queue, + * else clear all transmission queues + */ + if (sop->so_flags & SOF_NOCLRBUF) { + sop->so_rexmit_hd = NULL; + sop->so_rexmit_tl = NULL; + } else + sscop_xmit_drain(sop); +} + + +/* + * Conditionally Deliver Received Data to User + * + * Arguments: + * sop pointer to sscop connection block + * + * Returns: + * none + * + */ +void +q2110_deliver_data(sop) + struct sscop *sop; +{ + /* + * If 'Clear Buffers' == No, give data to user + */ + if (sop->so_flags & SOF_NOCLRBUF) { + /* + * We don't support 'Clear Buffers' == No, so don't bother + */ + } + + /* + * Clear receiver queue + */ + sscop_rcvr_drain(sop); +} + + +/* + * Enter Connection Recovery Mode + * + * Arguments: + * sop pointer to sscop connection block + * + * Returns: + * none + * + */ +void +q2110_error_recovery(sop) + struct sscop *sop; +{ + + /* + * Stop data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_timer[SSCOP_T_NORESP] = 0; + sop->so_timer[SSCOP_T_IDLE] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Initialize receiver window + */ + SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin); + + /* + * Send first ER PDU + */ + sop->so_connctl = 1; + SEQ_INCR(sop->so_sendconn, 1); + (void) sscop_send_er(sop); + + /* + * Set retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = sop->so_parm.sp_timecc; + + /* + * Clear out appropriate queues + */ + q2110_prep_recovery(sop); + + /* + * Wait for ERAK + */ + sop->so_state = SOS_OUTRECOV; + + return; +} + diff --git a/sys/netatm/uni/qsaal1_sigaa.c b/sys/netatm/uni/qsaal1_sigaa.c new file mode 100644 index 0000000..f3b0097 --- /dev/null +++ b/sys/netatm/uni/qsaal1_sigaa.c @@ -0,0 +1,518 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: qsaal1_sigaa.c,v 1.7 1998/08/26 23:29:18 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * ITU-T Q.SAAL1 - Process AA-signals (SAP_SSCOP) + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: qsaal1_sigaa.c,v 1.7 1998/08/26 23:29:18 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscop_misc.h> +#include <netatm/uni/sscop_pdu.h> +#include <netatm/uni/sscop_var.h> + + +/* + * Local functions + */ +static void sscop_estreq_ready __P((struct sscop *, int, int)); +static void sscop_datreq_outconn __P((struct sscop *, int, int)); +static void sscop_resreq_ready __P((struct sscop *, int, int)); +static void sscop_resrsp_inresyn __P((struct sscop *, int, int)); +static void sscop_resrsp_conresyn __P((struct sscop *, int, int)); + + +/* + * Stack command state lookup tables + */ +/* SSCOP_INIT */ +static void (*sscop_init_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + sscop_init_inst, /* SOS_INST */ + NULL, /* SOS_IDLE */ + NULL, /* SOS_OUTCONN */ + NULL, /* SOS_INCONN */ + NULL, /* SOS_OUTDISC */ + NULL, /* SOS_OUTRESYN */ + NULL, /* SOS_INRESYN */ + NULL, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + NULL, /* SOS_READY */ + NULL /* SOS_TERM */ +}; + +/* SSCOP_TERM */ +static void (*sscop_term_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + sscop_term_all, /* SOS_INST */ + sscop_term_all, /* SOS_IDLE */ + sscop_term_all, /* SOS_OUTCONN */ + sscop_term_all, /* SOS_INCONN */ + sscop_term_all, /* SOS_OUTDISC */ + sscop_term_all, /* SOS_OUTRESYN */ + sscop_term_all, /* SOS_INRESYN */ + sscop_term_all, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_term_all, /* SOS_READY */ + sscop_term_all /* SOS_TERM */ +}; + +/* SSCOP_ESTABLISH_REQ */ +static void (*sscop_estreq_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + sscop_estreq_idle, /* SOS_IDLE */ + NULL, /* SOS_OUTCONN */ + NULL, /* SOS_INCONN */ + sscop_estreq_ready, /* SOS_OUTDISC */ + sscop_estreq_ready, /* SOS_OUTRESYN */ + sscop_estreq_ready, /* SOS_INRESYN */ + sscop_estreq_ready, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_estreq_ready, /* SOS_READY */ + sscop_aa_noop_1 /* SOS_TERM */ +}; + +/* SSCOP_ESTABLISH_RSP */ +static void (*sscop_estrsp_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + NULL, /* SOS_IDLE */ + NULL, /* SOS_OUTCONN */ + sscop_estrsp_inconn, /* SOS_INCONN */ + NULL, /* SOS_OUTDISC */ + NULL, /* SOS_OUTRESYN */ + NULL, /* SOS_INRESYN */ + NULL, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_aa_noop_1, /* SOS_READY */ + sscop_aa_noop_1 /* SOS_TERM */ +}; + +/* SSCOP_RELEASE_REQ */ +static void (*sscop_relreq_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + NULL, /* SOS_IDLE */ + sscop_relreq_outconn, /* SOS_OUTCONN */ + sscop_relreq_inconn, /* SOS_INCONN */ + NULL, /* SOS_OUTDISC */ + sscop_relreq_outconn, /* SOS_OUTRESYN */ + sscop_relreq_ready, /* SOS_INRESYN */ + sscop_relreq_outconn, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_relreq_ready, /* SOS_READY */ + sscop_aa_noop_1 /* SOS_TERM */ +}; + +/* SSCOP_DATA_REQ */ +static void (*sscop_datreq_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + NULL, /* SOS_IDLE */ + sscop_datreq_outconn, /* SOS_OUTCONN */ + NULL, /* SOS_INCONN */ + NULL, /* SOS_OUTDISC */ + NULL, /* SOS_OUTRESYN */ + sscop_datreq_ready, /* SOS_INRESYN */ + NULL, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_datreq_ready, /* SOS_READY */ + sscop_aa_noop_1 /* SOS_TERM */ +}; + +/* SSCOP_RESYNC_REQ */ +static void (*sscop_resreq_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + NULL, /* SOS_IDLE */ + NULL, /* SOS_OUTCONN */ + NULL, /* SOS_INCONN */ + NULL, /* SOS_OUTDISC */ + NULL, /* SOS_OUTRESYN */ + NULL, /* SOS_INRESYN */ + NULL, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_resreq_ready, /* SOS_READY */ + sscop_aa_noop_1 /* SOS_TERM */ +}; + +/* SSCOP_RESYNC_RSP */ +static void (*sscop_resrsp_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + NULL, /* SOS_IDLE */ + NULL, /* SOS_OUTCONN */ + NULL, /* SOS_INCONN */ + NULL, /* SOS_OUTDISC */ + NULL, /* SOS_OUTRESYN */ + sscop_resrsp_inresyn, /* SOS_INRESYN */ + sscop_resrsp_conresyn, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + NULL, /* SOS_READY */ + sscop_aa_noop_0 /* SOS_TERM */ +}; + +/* SSCOP_UNITDATA_REQ */ +static void (*sscop_udtreq_tab[SOS_NUMSTATES]) + __P((struct sscop *, int, int)) = { + NULL, /* SOS_INST */ + sscop_udtreq_all, /* SOS_IDLE */ + sscop_udtreq_all, /* SOS_OUTCONN */ + sscop_udtreq_all, /* SOS_INCONN */ + sscop_udtreq_all, /* SOS_OUTDISC */ + sscop_udtreq_all, /* SOS_OUTRESYN */ + sscop_udtreq_all, /* SOS_INRESYN */ + sscop_udtreq_all, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_udtreq_all, /* SOS_READY */ + sscop_aa_noop_1 /* SOS_TERM */ +}; + + +/* + * Stack command lookup table + */ +void (*(*sscop_qsaal_aatab[SSCOP_CMD_SIZE])) + __P((struct sscop *, int, int)) = { + NULL, + sscop_init_tab, + sscop_term_tab, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + sscop_estreq_tab, + NULL, + sscop_estrsp_tab, + NULL, + sscop_relreq_tab, + NULL, + NULL, + sscop_datreq_tab, + NULL, + sscop_resreq_tab, + NULL, + sscop_resrsp_tab, + NULL, + NULL, + NULL, + sscop_udtreq_tab, + NULL, + NULL, + NULL, + NULL +}; + + +/* + * SSCOP_ESTABLISH_REQ / SOS_READY Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 pointer to buffer containing SSCOP-UU data + * arg2 buffer release parameter + * + * Returns: + * none + * + */ +static void +sscop_estreq_ready(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + + /* + * We don't support SSCOP-UU data + */ + if (arg1 != SSCOP_UU_NULL) + KB_FREEALL((KBuffer *)arg1); + + /* + * We currently only support BR=YES + */ + if (arg2 != SSCOP_BR_YES) { + sscop_abort(sop, "sscop: BR != YES\n"); + return; + } + + /* + * Stop poll timer + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Stop lost poll/stat timer + */ + sop->so_timer[SSCOP_T_NORESP] = 0; + + /* + * Initialize receiver window + */ + SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin); + + /* + * Send first BGN PDU + */ + sop->so_connctl = 1; + (void) sscop_send_bgn(sop, SSCOP_SOURCE_USER); + + /* + * Reset transmitter state + */ + qsaal1_reset_xmit(sop); + + /* + * Set retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = sop->so_parm.sp_timecc; + + /* + * Wait for BGAK + */ + sop->so_state = SOS_OUTCONN; + + return; +} + + +/* + * SSCOP_DATA_REQ / SOS_OUTCONN Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 pointer to buffer containing assured user data + * arg2 unused + * + * Returns: + * none + * + */ +static void +sscop_datreq_outconn(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + KBuffer *m = (KBuffer *)arg1; + + /* + * We must have a buffer (even if it contains no data) + */ + if (m == NULL) { + sscop_abort(sop, "sscop_datreq_outconn: no buffer\n"); + return; + } + + /* + * Only accept data here if in the middle of an SSCOP-initiated + * session reestablishment + */ + if ((sop->so_flags & SOF_REESTAB) == 0) { + KB_FREEALL(m); + sscop_abort(sop, "sscop_datreq_outconn: data not allowed\n"); + return; + } + + /* + * Place data at end of transmission queue + */ + KB_QNEXT(m) = NULL; + if (sop->so_xmit_hd == NULL) + sop->so_xmit_hd = m; + else + KB_QNEXT(sop->so_xmit_tl) = m; + sop->so_xmit_tl = m; + + /* + * Note that the transmit queues need to be serviced + */ + sop->so_flags |= SOF_XMITSRVC; + + return; +} + + +/* + * SSCOP_RESYNC_REQ / SOS_READY Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 pointer to buffer containing SSCOP-UU data + * arg2 unused + * + * Returns: + * none + * + */ +static void +sscop_resreq_ready(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + + /* + * We don't support SSCOP-UU data + */ + if (arg1 != SSCOP_UU_NULL) + KB_FREEALL((KBuffer *)arg1); + + /* + * Stop poll timer + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Stop lost poll/stat timer + */ + sop->so_timer[SSCOP_T_NORESP] = 0; + + /* + * Send first RS PDU + */ + sop->so_connctl = 1; + (void) sscop_send_rs(sop); + + /* + * Reset transmitter state + */ + qsaal1_reset_xmit(sop); + + /* + * Set retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = sop->so_parm.sp_timecc; + + /* + * Wait for RSAK + */ + sop->so_state = SOS_OUTRESYN; + + return; +} + + +/* + * SSCOP_RESYNC_RSP / SOS_INRESYN Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 unused + * arg2 unused + * + * Returns: + * none + * + */ +static void +sscop_resrsp_inresyn(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + + /* + * Send RSAK PDU + */ + (void) sscop_send_rsak(sop); + + /* + * Back to data transfer state + */ + sop->so_state = SOS_READY; + + return; +} + + +/* + * SSCOP_RESYNC_RSP / SOS_CONRESYN Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 unused + * arg2 unused + * + * Returns: + * none + * + */ +static void +sscop_resrsp_conresyn(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + + /* + * Send RSAK PDU + */ + (void) sscop_send_rsak(sop); + + /* + * Back to waiting for peer's RSAK + */ + sop->so_state = SOS_OUTRESYN; + + return; +} + diff --git a/sys/netatm/uni/qsaal1_sigcpcs.c b/sys/netatm/uni/qsaal1_sigcpcs.c new file mode 100644 index 0000000..1d62165 --- /dev/null +++ b/sys/netatm/uni/qsaal1_sigcpcs.c @@ -0,0 +1,1545 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: qsaal1_sigcpcs.c,v 1.7 1998/04/07 23:21:03 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * ITU-T Q.SAAL1 - Process CPCS-signals (SSCOP PDUs) + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: qsaal1_sigcpcs.c,v 1.7 1998/04/07 23:21:03 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscop_misc.h> +#include <netatm/uni/sscop_pdu.h> +#include <netatm/uni/sscop_var.h> + + +/* + * Local functions + */ +static void sscop_bgn_outconn __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_end_outresyn __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_end_conresyn __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_end_ready __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_endak_outresyn __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_rs_outresyn __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_rs_ready __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_rsak_conresyn __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_sd_inresyn __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_sd_conresyn __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_sd_process __P((struct sscop *, KBuffer *, caddr_t, int)); +static void sscop_sd_ready __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_sdp_ready __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_poll_inresyn __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_poll_conresyn __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_poll_ready __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_stat_conresyn __P((struct sscop *, KBuffer *, caddr_t)); +static void sscop_ustat_conresyn __P((struct sscop *, KBuffer *, caddr_t)); + + +/* + * PDU type state lookup tables + */ +/* BGN PDU */ +static void (*sscop_bgn_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_bgn_idle, /* SOS_IDLE */ + sscop_bgn_outconn, /* SOS_OUTCONN */ + sscop_noop, /* SOS_INCONN */ + sscop_bgn_outdisc, /* SOS_OUTDISC */ + sscop_bgn_outresyn, /* SOS_OUTRESYN */ + sscop_bgn_inresyn, /* SOS_INRESYN */ + sscop_bgn_outresyn, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_bgn_inresyn, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* BGAK PDU */ +static void (*sscop_bgak_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_bgak_idle, /* SOS_IDLE */ + sscop_bgak_outconn, /* SOS_OUTCONN */ + sscop_bgak_error, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_bgak_error, /* SOS_OUTRESYN */ + sscop_bgak_error, /* SOS_INRESYN */ + sscop_bgak_error, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_noop, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* BGREJ PDU */ +static void (*sscop_bgrej_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_bgrej_error, /* SOS_IDLE */ + sscop_bgrej_outconn, /* SOS_OUTCONN */ + sscop_bgrej_inconn, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_bgrej_outresyn, /* SOS_OUTRESYN */ + sscop_bgrej_ready, /* SOS_INRESYN */ + sscop_bgrej_outresyn, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_bgrej_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* END PDU */ +static void (*sscop_end_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_end_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_end_inconn, /* SOS_INCONN */ + sscop_end_outdisc, /* SOS_OUTDISC */ + sscop_end_outresyn, /* SOS_OUTRESYN */ + sscop_end_ready, /* SOS_INRESYN */ + sscop_end_conresyn, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_end_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* ENDAK PDU */ +static void (*sscop_endak_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_noop, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_endak_inconn, /* SOS_INCONN */ + sscop_endak_outdisc, /* SOS_OUTDISC */ + sscop_endak_outresyn, /* SOS_OUTRESYN */ + sscop_endak_ready, /* SOS_INRESYN */ + sscop_endak_outresyn, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_endak_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* RS PDU */ +static void (*sscop_rs_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_rs_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_rs_error, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_rs_outresyn, /* SOS_OUTRESYN */ + sscop_noop, /* SOS_INRESYN */ + sscop_noop, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_rs_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* RSAK PDU */ +static void (*sscop_rsak_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_rsak_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_rsak_error, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_rsak_outresyn, /* SOS_OUTRESYN */ + sscop_rsak_error, /* SOS_INRESYN */ + sscop_rsak_conresyn, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_rsak_error, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* SD PDU */ +static void (*sscop_sd_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_sd_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_sd_inconn, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_sd_ready, /* SOS_OUTRESYN */ + sscop_sd_inresyn, /* SOS_INRESYN */ + sscop_sd_conresyn, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_sd_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* SDP PDU */ +static void (*sscop_sdp_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_sd_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_sd_inconn, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_sdp_ready, /* SOS_OUTRESYN */ + sscop_sd_inresyn, /* SOS_INRESYN */ + sscop_sd_conresyn, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_sdp_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* POLL PDU */ +static void (*sscop_poll_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_poll_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_poll_inconn, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_poll_ready, /* SOS_OUTRESYN */ + sscop_poll_inresyn, /* SOS_INRESYN */ + sscop_poll_conresyn, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_poll_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* STAT PDU */ +static void (*sscop_stat_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_stat_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_stat_inconn, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_noop, /* SOS_OUTRESYN */ + sscop_stat_ready, /* SOS_INRESYN */ + sscop_stat_conresyn, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_stat_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* USTAT PDU */ +static void (*sscop_ustat_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_ustat_idle, /* SOS_IDLE */ + sscop_noop, /* SOS_OUTCONN */ + sscop_ustat_inconn, /* SOS_INCONN */ + sscop_noop, /* SOS_OUTDISC */ + sscop_noop, /* SOS_OUTRESYN */ + sscop_ustat_ready, /* SOS_INRESYN */ + sscop_ustat_conresyn, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_ustat_ready, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* UD PDU */ +static void (*sscop_ud_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_ud_all, /* SOS_IDLE */ + sscop_ud_all, /* SOS_OUTCONN */ + sscop_ud_all, /* SOS_INCONN */ + sscop_ud_all, /* SOS_OUTDISC */ + sscop_ud_all, /* SOS_OUTRESYN */ + sscop_ud_all, /* SOS_INRESYN */ + sscop_ud_all, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_ud_all, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + +/* MD PDU */ +static void (*sscop_md_tab[SOS_NUMSTATES]) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, /* SOS_INST */ + sscop_md_all, /* SOS_IDLE */ + sscop_md_all, /* SOS_OUTCONN */ + sscop_md_all, /* SOS_INCONN */ + sscop_md_all, /* SOS_OUTDISC */ + sscop_md_all, /* SOS_OUTRESYN */ + sscop_md_all, /* SOS_INRESYN */ + sscop_md_all, /* SOS_CONRESYN */ + NULL, /* invalid */ + NULL, /* invalid */ + sscop_md_all, /* SOS_READY */ + sscop_noop /* SOS_TERM */ +}; + + +/* + * PDU type lookup table + */ +void (*(*sscop_qsaal_pdutab[])) + __P((struct sscop *, KBuffer *, caddr_t)) = { + NULL, + sscop_bgn_tab, + sscop_bgak_tab, + sscop_end_tab, + sscop_endak_tab, + sscop_rs_tab, + sscop_rsak_tab, + sscop_bgrej_tab, + sscop_sd_tab, + sscop_sdp_tab, + sscop_poll_tab, + sscop_stat_tab, + sscop_ustat_tab, + sscop_ud_tab, + sscop_md_tab, + NULL +}; + + +/* + * BGN PDU / SOS_OUTCONN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_bgn_outconn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct bgn_pdu *bp = (struct bgn_pdu *)trlr; + int err; + + /* + * Initialize transmit window + */ + SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr)); + + /* + * Notify user of connection establishment + */ + if (sop->so_flags & SOF_REESTAB) { + KB_FREEALL(m); + STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "sscop_bgn_outconn: stack memory\n"); + return; + } + sop->so_flags &= ~SOF_REESTAB; + } else { + STACK_CALL(SSCOP_ESTABLISH_CNF, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, 0, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "sscop_bgn_outconn: stack memory\n"); + return; + } + } + + /* + * Return an ACK to peer + */ + (void) sscop_send_bgak(sop); + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Reset receiver variables + */ + qsaal1_reset_rcvr(sop); + + /* + * Start polling timer + */ + sscop_set_poll(sop); + + /* + * Start lost poll/stat timer + */ + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + + /* + * OK, we're ready for data + */ + sop->so_state = SOS_READY; + + /* + * See if transmit queues need servicing + */ + if (sop->so_flags & SOF_XMITSRVC) + sscop_service_xmit(sop); + + return; +} + + +/* + * END PDU / SOS_OUTRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_end_outresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct end_pdu *ep = (struct end_pdu *)trlr; + int err, source; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Acknowledge END + */ + (void) sscop_send_endak(sop); + + /* + * Get Source value + */ + if (ep->end_type & PT_SOURCE_SSCOP) + source = SSCOP_SOURCE_SSCOP; + else + source = SSCOP_SOURCE_USER; + + /* + * Notify user of connection termination + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, source, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "sscop_end_outresyn: stack memory\n"); + return; + } + + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * END PDU / SOS_CONRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_end_conresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Free up buffers + */ + KB_FREEALL(m); + + /* + * Acknowledge END + */ + (void) sscop_send_endak(sop); + + /* + * Notify user of connection termination + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "sscop_end_conresyn: stack memory\n"); + return; + } + + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * END PDU / SOS_READY Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_end_ready(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct end_pdu *ep = (struct end_pdu *)trlr; + int err, source; + + /* + * Stop poll timer + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Stop lost poll/stat timer + */ + sop->so_timer[SSCOP_T_NORESP] = 0; + + /* + * Acknowledge END + */ + (void) sscop_send_endak(sop); + + /* + * Get Source value + */ + if (ep->end_type & PT_SOURCE_SSCOP) + source = SSCOP_SOURCE_SSCOP; + else + source = SSCOP_SOURCE_USER; + + /* + * Notify user of connection termination + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, source, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "sscop_end_ready: stack memory\n"); + return; + } + + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * ENDAK PDU / SOS_OUTRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_endak_outresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Report protocol error + */ + sscop_endak_error(sop, m, trlr); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "sscop_endak_outresyn: stack memory\n"); + return; + } + + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * RS PDU / SOS_OUTRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_rs_outresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Notify user of resynchronization + */ + STACK_CALL(SSCOP_RESYNC_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, 0, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "sscop_rs_outresyn: stack memory\n"); + return; + } + + /* + * Reset receiver state variables + */ + qsaal1_reset_rcvr(sop); + + /* + * Wait for both peer and user responses + */ + sop->so_state = SOS_CONRESYN; + + return; +} + + +/* + * RS PDU / SOS_READY Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_rs_ready(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Notify user of resynchronization + */ + STACK_CALL(SSCOP_RESYNC_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, 0, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "sscop_rs_ready: stack memory\n"); + return; + } + + /* + * Reset receiver state variables + */ + qsaal1_reset_rcvr(sop); + + /* + * Wait for user response + */ + sop->so_state = SOS_INRESYN; + + return; +} + + +/* + * RSAK PDU / SOS_CONRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_rsak_conresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Free buffers + */ + KB_FREEALL(m); + + /* + * Notify user of resynchronization completion + */ + STACK_CALL(SSCOP_RESYNC_CNF, sop->so_upper, sop->so_toku, + sop->so_connvc, 0, 0, err); + if (err) { + sscop_abort(sop, "sscop_rsak_conresyn: stack memory\n"); + return; + } + + /* + * Start the polling timer + */ + sscop_set_poll(sop); + + /* + * Start lost poll/stat timer + */ + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + + /* + * Continue waiting for user response + */ + sop->so_state = SOS_INRESYN; + + /* + * See if transmit queues need servicing + */ + if (sop->so_flags & SOF_XMITSRVC) + sscop_service_xmit(sop); + + return; +} + + +/* + * SD PDU / SOS_INRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_sd_inresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop poll timer + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Stop lost poll/stat timer + */ + sop->so_timer[SSCOP_T_NORESP] = 0; + + /* + * Record error condition + */ + sscop_sd_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "sscop_sd_inresyn: stack memory\n"); + return; + } + + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + + /* + * Go back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * SD PDU / SOS_CONRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_sd_conresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Record error condition + */ + sscop_sd_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "sscop_sd_conresyn: stack memory\n"); + return; + } + + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + + /* + * Go back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * SD/SDP PDU Common Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU user data buffer chain + * trlr pointer to PDU trailer + * type PDU type (SD or SDP) + * + * Returns: + * none + * + */ +static void +sscop_sd_process(sop, m, trlr, type) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; + int type; +{ + struct sd_pdu *sp; + struct sdp_pdu *spp; + struct poll_pdu poll; + struct pdu_hdr *php; + KBuffer *n; + sscop_seq ns, nps; + int err, space; + + /* + * Get PDU sequence number(s) + */ + if (type == PT_SD) { + sp = (struct sd_pdu *)trlr; + SEQ_SET(ns, ntohl(sp->sd_ns)); + SEQ_SET(nps, 0); + } else { + spp = (struct sdp_pdu *)trlr; + SEQ_SET(ns, ntohl(spp->sdp_ns)); + SEQ_SET(nps, ntohl(spp->sdp_nps)); + } + + /* + * Ensure that the sequence number fits within the window + */ + if (SEQ_GEQ(ns, sop->so_rcvmax, sop->so_rcvnext)) { + KB_FREEALL(m); + return; + } + + /* + * If this is the next in-sequence PDU, hand it to user + */ + if (ns == sop->so_rcvnext) { + STACK_CALL(SSCOP_DATA_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, ns, err); + if (err) { + KB_FREEALL(m); + return; + } + + /* + * Bump next expected sequence number + */ + SEQ_INCR(sop->so_rcvnext, 1); + + /* + * Slide receive window down + */ + SEQ_INCR(sop->so_rcvmax, 1); + + /* + * Is this the highest sequence PDU we've received?? + */ + if (ns == sop->so_rcvhigh) { + /* + * Yes, bump the limit and exit + */ + sop->so_rcvhigh = sop->so_rcvnext; + if (type == PT_SDP) + goto dopoll; + return; + } + + /* + * This is a retransmitted PDU, so see if we have + * more in-sequence PDUs already queued up + */ + while ((php = sop->so_recv_hd) && + (php->ph_ns == sop->so_rcvnext)) { + + /* + * Yup we do, so remove next PDU from queue and + * pass it up to the user as well + */ + sop->so_recv_hd = php->ph_recv_lk; + if (sop->so_recv_hd == NULL) + sop->so_recv_tl = NULL; + STACK_CALL(SSCOP_DATA_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)php->ph_buf, php->ph_ns, + err); + if (err) { + /* + * Should never happen, but... + */ + KB_FREEALL(php->ph_buf); + sscop_abort(sop, + "sscop_sd_process: stack memory\n"); + return; + } + + /* + * Bump next expected sequence number + */ + SEQ_INCR(sop->so_rcvnext, 1); + + /* + * Slide receive window down + */ + SEQ_INCR(sop->so_rcvmax, 1); + } + + /* + * Finished with data...see if we need to poll + */ + if (type == PT_SDP) + goto dopoll; + return; + } + + /* + * We're gonna have to queue this PDU, so find space + * for the PDU header + */ + KB_HEADROOM(m, space); + + /* + * If there's not enough room in the received buffer, + * allocate & link a new buffer for the header + */ + if (space < sizeof(struct pdu_hdr)) { + + KB_ALLOC(n, sizeof(struct pdu_hdr), KB_F_NOWAIT, KB_T_HEADER); + if (n == NULL) { + KB_FREEALL(m); + return; + } + KB_HEADSET(n, sizeof(struct pdu_hdr)); + KB_LEN(n) = 0; + KB_LINKHEAD(n, m); + m = n; + } + + /* + * Build PDU header + * + * We can at least assume/require that the start of + * the user data is aligned. Also note that we don't + * include this header in the buffer len/offset fields. + */ + KB_DATASTART(m, php, struct pdu_hdr *); + php--; + php->ph_ns = ns; + php->ph_buf = m; + + /* + * Insert PDU into the receive queue + */ + if (sscop_recv_insert(sop, php)) { + /* + * Oops, a duplicate sequence number PDU is already on + * the queue, somethings wrong here. + */ + sscop_maa_error(sop, 'Q'); + + /* + * Free buffers + */ + KB_FREEALL(m); + + /* + * Reestablish a new connection + */ + qsaal1_reestablish(sop); + + return; + } + + /* + * Are we at the high-water mark?? + */ + if (ns == sop->so_rcvhigh) { + /* + * Yes, just bump the mark + */ + SEQ_INCR(sop->so_rcvhigh, 1); + + if (type == PT_SDP) + goto dopoll; + return; + } + + /* + * Are we beyond the high-water mark?? + */ + if (SEQ_GT(ns, sop->so_rcvhigh, sop->so_rcvnext)) { + /* + * Yes, then there's a missing PDU, so inform the transmitter + */ + if (type == PT_SD) + (void) sscop_send_ustat(sop, ns); + + /* + * Update high-water mark + */ + sop->so_rcvhigh = SEQ_ADD(ns, 1); + } + + if (type == PT_SD) + return; + +dopoll: + /* + * Do the "poll" part of an SDP PDU + */ + poll.poll_nps = htonl(nps); + poll.poll_ns = htonl((PT_POLL << PT_TYPE_SHIFT) | ns); + sscop_poll_ready(sop, NULL, (caddr_t)&poll); + return; +} + + +/* + * SD PDU / SOS_READY Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_sd_ready(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + /* + * Just call common SD/SDP processor + */ + sscop_sd_process(sop, m, trlr, PT_SD); + + return; +} + + +/* + * SDP PDU / SOS_READY Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_sdp_ready(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + /* + * Just call common SD/SDP processor + */ + sscop_sd_process(sop, m, trlr, PT_SDP); + + return; +} + + +/* + * POLL PDU / SOS_INRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_poll_inresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop poll timer + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Stop lost poll/stat timer + */ + sop->so_timer[SSCOP_T_NORESP] = 0; + + /* + * Report protocol error + */ + sscop_poll_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "sscop_poll_inresyn: stack memory\n"); + return; + } + + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * POLL PDU / SOS_CONRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_poll_conresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Record error condition + */ + sscop_poll_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "sscop_poll_conresyn: stack memory\n"); + return; + } + + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + + /* + * Go back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * POLL PDU / SOS_READY Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_poll_ready(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct poll_pdu *pp = (struct poll_pdu *)trlr; + sscop_seq nps; + + NTOHL(pp->poll_ns); + + /* + * If the poll sequence number is less than highest number + * we've already seen, something's wrong - so attempt to + * reestablish a new connection. + */ + if (SEQ_LT(pp->poll_ns, sop->so_rcvhigh, sop->so_rcvnext)) { + /* + * Record error condition + */ + sscop_maa_error(sop, 'Q'); + + /* + * Free buffers + */ + KB_FREEALL(m); + + /* + * Reestablish a new connection + */ + qsaal1_reestablish(sop); + + return; + } + + /* + * Set a new "next highest" sequence number expected + */ + if (SEQ_LT(pp->poll_ns, sop->so_rcvmax, sop->so_rcvnext)) + SEQ_SET(sop->so_rcvhigh, pp->poll_ns); + else + sop->so_rcvhigh = sop->so_rcvmax; + + /* + * Return a STAT PDU to peer + */ + SEQ_SET(nps, ntohl(pp->poll_nps)); + KB_FREEALL(m); + (void) sscop_send_stat(sop, nps); + + return; +} + + +/* + * STAT PDU / SOS_CONRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_stat_conresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Record error condition + */ + sscop_stat_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "sscop_stat_conresyn: stack memory\n"); + return; + } + + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + + /* + * Go back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * USTAT PDU / SOS_CONRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +static void +sscop_ustat_conresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Record error condition + */ + sscop_ustat_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "sscop_ustat_conresyn: stack memory\n"); + return; + } + + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + + /* + * Go back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + diff --git a/sys/netatm/uni/qsaal1_subr.c b/sys/netatm/uni/qsaal1_subr.c new file mode 100644 index 0000000..ed4b43c --- /dev/null +++ b/sys/netatm/uni/qsaal1_subr.c @@ -0,0 +1,206 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: qsaal1_subr.c,v 1.6 1998/04/07 23:21:17 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * ITU-T Q.SAAL1 - Subroutines + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: qsaal1_subr.c,v 1.6 1998/04/07 23:21:17 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscop_misc.h> +#include <netatm/uni/sscop_pdu.h> +#include <netatm/uni/sscop_var.h> + + +/* + * Re-establish a new SSCOP Connection + * + * Arguments: + * sop pointer to sscop connection block + * + * Returns: + * none + * + */ +void +qsaal1_reestablish(sop) + struct sscop *sop; +{ + + /* + * Stop polling timers + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_timer[SSCOP_T_NORESP] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Note that we're reestablishing a connection + */ + sop->so_flags |= SOF_REESTAB; + + /* + * Send first BGN PDU + */ + sop->so_connctl = 1; + (void) sscop_send_bgn(sop, SSCOP_SOURCE_SSCOP); + + /* + * Reset transmit variables + */ + qsaal1_reset_xmit(sop); + + /* + * Set retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = sop->so_parm.sp_timecc; + + /* + * Wait for BGAK + */ + sop->so_state = SOS_OUTCONN; + + return; +} + + +/* + * Reset connection's transmitter state + * + * Arguments: + * sop pointer to sscop connection block + * + * Returns: + * none + * + */ +void +qsaal1_reset_xmit(sop) + struct sscop *sop; +{ + + /* + * Drain the transmission queues + */ + sscop_xmit_drain(sop); + + /* + * Reset transmit variables + */ + SEQ_SET(sop->so_send, 0); + SEQ_SET(sop->so_pollsend, 0); + SEQ_SET(sop->so_ack, 0); + SEQ_SET(sop->so_pollack, 0); + if (sop->so_state != SOS_INCONN) + SEQ_SET(sop->so_sendmax, 0); + sop->so_polldata = 0; + + return; +} + + +/* + * Reset connection's receiver state + * + * Arguments: + * sop pointer to sscop connection block + * + * Returns: + * none + * + */ +void +qsaal1_reset_rcvr(sop) + struct sscop *sop; +{ + + /* + * Drain the receiver queues + */ + sscop_rcvr_drain(sop); + + /* + * Reset transmit variables + */ + SEQ_SET(sop->so_rcvnext, 0); + SEQ_SET(sop->so_rcvhigh, 0); + SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin); + + return; +} + + +/* + * Clear connection's connection data + * + * Arguments: + * sop pointer to sscop connection block + * + * Returns: + * none + * + */ +void +qsaal1_clear_connection(sop) + struct sscop *sop; +{ + + /* + * Can we clear transmit buffers ?? + */ + if ((sop->so_flags & SOF_NOCLRBUF) == 0) { + /* + * Yes, drain the transmission queues + */ + sscop_xmit_drain(sop); + } + + /* + * Clear service required flag + */ + sop->so_flags &= ~SOF_XMITSRVC; + + /* + * Drain receive queue buffers + */ + sscop_rcvr_drain(sop); + + return; +} + diff --git a/sys/netatm/uni/sscf_uni.c b/sys/netatm/uni/sscf_uni.c new file mode 100644 index 0000000..b5fd7fb --- /dev/null +++ b/sys/netatm/uni/sscf_uni.c @@ -0,0 +1,317 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscf_uni.c,v 1.6 1998/03/24 21:10:38 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * Signalling AAL SSCF at the UNI + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: sscf_uni.c,v 1.6 1998/03/24 21:10:38 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscf_uni.h> +#include <netatm/uni/sscf_uni_var.h> + + +/* + * Global variables + */ +int sscf_uni_vccnt = 0; + +/* + * Local functions + */ +static int sscf_uni_inst __P((struct stack_defn **, Atm_connvc *)); + +/* + * Local variables + */ +static struct sp_info sscf_uni_pool = { + "sscf uni pool", /* si_name */ + sizeof(struct univcc), /* si_blksiz */ + 5, /* si_blkcnt */ + 100 /* si_maxallow */ +}; + +static struct stack_defn sscf_uni_service = { + NULL, + SAP_SSCF_UNI, + 0, + sscf_uni_inst, + sscf_uni_lower, + sscf_uni_upper, + 0 +}; + +static struct t_atm_cause sscf_uni_cause = { + T_ATM_ITU_CODING, + T_ATM_LOC_USER, + T_ATM_CAUSE_TEMPORARY_FAILURE, + {0, 0, 0, 0} +}; + + +/* + * Initialize SSCF UNI processing + * + * This will be called during module loading. We will register our stack + * service and wait for someone to talk to us. + * + * Arguments: + * none + * + * Returns: + * 0 initialization was successful + * errno initialization failed - reason indicated + * + */ +int +sscf_uni_start() +{ + int err = 0; + + /* + * Register stack service + */ + if (err = atm_stack_register(&sscf_uni_service)) + goto done; + +done: + return (err); +} + + +/* + * Terminate SSCF UNI processing + * + * This will be called just prior to unloading the module from memory. All + * signalling instances should have been terminated by now, so we just free + * up all of our resources. + * + * Called at splnet. + * + * Arguments: + * none + * + * Returns: + * 0 termination was successful + * errno termination failed - reason indicated + * + */ +int +sscf_uni_stop() +{ + /* + * Any connections still exist?? + */ + if (sscf_uni_vccnt) { + + /* + * Yes, can't stop yet + */ + return (EBUSY); + } + + /* + * Deregister the stack service + */ + (void) atm_stack_deregister(&sscf_uni_service); + + /* + * Free our storage pools + */ + atm_release_pool(&sscf_uni_pool); + + return (0); +} + + +/* + * SSCF_UNI Stack Instantiation + * + * Called at splnet. + * + * Arguments: + * ssp pointer to array of stack definition pointers for connection + * ssp[0] points to upper layer's stack service definition + * ssp[1] points to this layer's stack service definition + * ssp[2] points to lower layer's stack service definition + * cvp pointer to connection vcc for this stack + * + * Returns: + * 0 instantiation successful + * errno instantiation failed - reason indicated + * + */ +static int +sscf_uni_inst(ssp, cvp) + struct stack_defn **ssp; + Atm_connvc *cvp; +{ + struct stack_defn *sdp_up = ssp[0], + *sdp_me = ssp[1], + *sdp_low = ssp[2]; + struct univcc *uvp; + int err; + + ATM_DEBUG2("sscf_uni_inst: ssp=0x%x, cvp=0x%x\n", ssp, cvp); + + /* + * Validate lower SAP + */ + if (sdp_low->sd_sap != SAP_SSCOP) + return (EINVAL); + + /* + * Allocate our control block + */ + uvp = (struct univcc *)atm_allocate(&sscf_uni_pool); + if (uvp == NULL) + return (ENOMEM); + + uvp->uv_ustate = UVU_INST; + uvp->uv_lstate = UVL_INST; + uvp->uv_connvc = cvp; + uvp->uv_toku = sdp_up->sd_toku; + uvp->uv_upper = sdp_up->sd_upper; + sscf_uni_vccnt++; + + /* + * Store my token into service definition + */ + sdp_me->sd_toku = uvp; + + /* + * Update and save input buffer headroom + */ + HEADIN(cvp, 0, 0); + /* uvp->uv_headin = cvp->cvc_attr.headin; */ + + /* + * Pass instantiation down the stack + */ + err = sdp_low->sd_inst(ssp + 1, cvp); + if (err) { + /* + * Lower layer instantiation failed, free our resources + */ + atm_free((caddr_t)uvp); + sscf_uni_vccnt--; + return (err); + } + + /* + * Save and update output buffer headroom + */ + /* uvp->uv_headout = cvp->cvc_attr.headout; */ + HEADOUT(cvp, 0, 0); + + /* + * Save lower layer's interface info + */ + uvp->uv_lower = sdp_low->sd_lower; + uvp->uv_tokl = sdp_low->sd_toku; + + return (0); +} + + +/* + * Abort an SSCF_UNI connection + * + * Called when an unrecoverable or "should never happen" error occurs. + * We just log a message and request the signalling manager to abort the + * connection. + * + * Arguments: + * uvp pointer to univcc control block + * msg pointer to error message + * + * Returns: + * none + * + */ +void +sscf_uni_abort(uvp, msg) + struct univcc *uvp; + char *msg; +{ + /* + * Log error message + */ + log(LOG_ERR, msg); + + /* + * Set termination states + */ + uvp->uv_ustate = UVU_TERM; + uvp->uv_lstate = UVL_TERM; + + /* + * Tell Connection Manager to abort this connection + */ + (void) atm_cm_abort(uvp->uv_connvc, &sscf_uni_cause); +} + + +/* + * Print an SSCF PDU + * + * Arguments: + * uvp pointer to univcc control block + * m pointer to pdu buffer chain + * msg pointer to message string + * + * Returns: + * none + * + */ +void +sscf_uni_pdu_print(uvp, m, msg) + struct univcc *uvp; + KBuffer *m; + char *msg; +{ + char buf[128]; + struct vccb *vcp; + + vcp = uvp->uv_connvc->cvc_vcc; + sprintf(buf, "sscf_uni %s: vcc=(%d,%d)\n", + msg, vcp->vc_vpi, vcp->vc_vci); + atm_pdu_print(m, buf); +} + diff --git a/sys/netatm/uni/sscf_uni.h b/sys/netatm/uni/sscf_uni.h new file mode 100644 index 0000000..cf24446 --- /dev/null +++ b/sys/netatm/uni/sscf_uni.h @@ -0,0 +1,47 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscf_uni.h,v 1.2 1997/05/06 22:19:34 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * SSCF UNI protocol definitions + * + */ + +#ifndef _UNI_SSCF_UNI_H +#define _UNI_SSCF_UNI_H + +/* + * SSCF_UNI API definitions + */ +#define SSCF_UNI_ESTIND_YES 1 /* Allow new ESTABLISH_IND */ +#define SSCF_UNI_ESTIND_NO 2 /* Disallow new ESTABLISH_IND */ + +#endif /* _UNI_SSCF_UNI_H */ diff --git a/sys/netatm/uni/sscf_uni_lower.c b/sys/netatm/uni/sscf_uni_lower.c new file mode 100644 index 0000000..fe2d839 --- /dev/null +++ b/sys/netatm/uni/sscf_uni_lower.c @@ -0,0 +1,379 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscf_uni_lower.c,v 1.6 1998/04/07 23:23:26 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * SSCF UNI - SSCF_UNI SAP interface processing + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: sscf_uni_lower.c,v 1.6 1998/04/07 23:23:26 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscf_uni.h> +#include <netatm/uni/sscf_uni_var.h> + + +/* + * Local variables + */ +static struct sscop_parms sscf_uni_sscop_parms = { + 4096, /* sp_maxinfo */ + 4096, /* sp_maxuu */ + 4, /* sp_maxcc */ + 25, /* sp_maxpd */ + 1 * ATM_HZ, /* sp_timecc */ + 2 * ATM_HZ, /* sp_timekeep */ + 7 * ATM_HZ, /* sp_timeresp */ + 1 * ATM_HZ, /* sp_timepoll */ + 15 * ATM_HZ, /* sp_timeidle */ + 80 /* sp_rcvwin */ +}; + + +/* + * SSCF_UNI Lower Stack Command Handler + * + * This function will receive all of the stack commands issued from the + * layer above SSCF UNI (ie. Q.2931). + * + * Arguments: + * cmd stack command code + * tok session token + * arg1 command specific argument + * arg2 command specific argument + * + * Returns: + * none + * + */ +void +sscf_uni_lower(cmd, tok, arg1, arg2) + int cmd; + void *tok; + int arg1; + int arg2; +{ + struct univcc *uvp = (struct univcc *)tok; + Atm_connvc *cvp = uvp->uv_connvc; + enum sscop_vers vers; + int err; + + ATM_DEBUG5("sscf_uni_lower: cmd=0x%x, uvp=0x%x, ustate=%d, arg1=0x%x, arg2=0x%x\n", + cmd, (int)uvp, uvp->uv_ustate, arg1, arg2); + + switch (cmd) { + + case SSCF_UNI_INIT: + /* + * Validate state + */ + if (uvp->uv_ustate != UVU_INST) { + log(LOG_ERR, "sscf_uni_lower: SSCF_INIT in ustate=%d\n", + uvp->uv_ustate); + sscf_uni_abort(uvp, "sscf_uni: sequence err\n"); + break; + } + + /* + * Validate UNI version + */ + if ((enum uni_vers)arg1 == UNI_VERS_3_0) + vers = SSCOP_VERS_QSAAL; + else if ((enum uni_vers)arg1 == UNI_VERS_3_1) + vers = SSCOP_VERS_Q2110; + else { + sscf_uni_abort(uvp, "sscf_uni: bad version\n"); + break; + } + uvp->uv_vers = (enum uni_vers)arg1; + + /* + * Make ourselves ready and pass on the INIT + */ + uvp->uv_ustate = UVU_RELEASED; + uvp->uv_lstate = UVL_IDLE; + + STACK_CALL(SSCOP_INIT, uvp->uv_lower, uvp->uv_tokl, cvp, + (int)vers, (int)&sscf_uni_sscop_parms, err); + if (err) { + /* + * Should never happen + */ + sscf_uni_abort(uvp, "sscf_uni: INIT failure\n"); + } + break; + + case SSCF_UNI_TERM: + /* + * Set termination states + */ + uvp->uv_ustate = UVU_TERM; + uvp->uv_lstate = UVL_TERM; + + /* + * Pass the TERM down the stack + */ + STACK_CALL(SSCOP_TERM, uvp->uv_lower, uvp->uv_tokl, cvp, + 0, 0, err); + if (err) { + /* + * Should never happen + */ + sscf_uni_abort(uvp, "sscf_uni: TERM failure\n"); + return; + } + atm_free((caddr_t)uvp); + sscf_uni_vccnt--; + break; + + case SSCF_UNI_ESTABLISH_REQ: + /* + * Validation based on user state + */ + switch (uvp->uv_ustate) { + + case UVU_RELEASED: + case UVU_PRELEASE: + /* + * Establishing a new connection + */ + uvp->uv_ustate = UVU_PACTIVE; + uvp->uv_lstate = UVL_OUTCONN; + STACK_CALL(SSCOP_ESTABLISH_REQ, uvp->uv_lower, + uvp->uv_tokl, cvp, + SSCOP_UU_NULL, SSCOP_BR_YES, err); + if (err) { + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + break; + + case UVU_ACTIVE: + /* + * Resynchronizing a connection + */ + uvp->uv_ustate = UVU_PACTIVE; + if (uvp->uv_vers == UNI_VERS_3_0) { + uvp->uv_lstate = UVL_OUTCONN; + STACK_CALL(SSCOP_ESTABLISH_REQ, uvp->uv_lower, + uvp->uv_tokl, cvp, + SSCOP_UU_NULL, SSCOP_BR_YES, err); + } else { + uvp->uv_lstate = UVL_OUTRESYN; + STACK_CALL(SSCOP_RESYNC_REQ, uvp->uv_lower, + uvp->uv_tokl, cvp, + SSCOP_UU_NULL, 0, err); + } + if (err) { + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + break; + + case UVU_TERM: + /* Ignore */ + break; + + case UVU_INST: + case UVU_PACTIVE: + default: + log(LOG_ERR, "sscf_uni_lower: cmd=0x%x, ustate=%d\n", + cmd, uvp->uv_ustate); + sscf_uni_abort(uvp, "sscf_uni: sequence err\n"); + } + break; + + case SSCF_UNI_RELEASE_REQ: + /* + * Validate re-establishment parameter + */ + switch (arg1) { + + case SSCF_UNI_ESTIND_YES: + uvp->uv_flags &= ~UVF_NOESTIND; + break; + + case SSCF_UNI_ESTIND_NO: + uvp->uv_flags |= UVF_NOESTIND; + break; + + default: + sscf_uni_abort(uvp, "sscf_uni: bad estind value\n"); + return; + } + + /* + * Validation based on user state + */ + switch (uvp->uv_ustate) { + + case UVU_RELEASED: + /* + * Releasing a non-existant connection + */ + STACK_CALL(SSCF_UNI_RELEASE_CNF, uvp->uv_upper, + uvp->uv_toku, cvp, + 0, 0, err); + if (err) { + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + break; + + case UVU_PACTIVE: + case UVU_ACTIVE: + /* + * Releasing a connection + */ + uvp->uv_ustate = UVU_PRELEASE; + uvp->uv_lstate = UVL_OUTDISC; + STACK_CALL(SSCOP_RELEASE_REQ, uvp->uv_lower, + uvp->uv_tokl, cvp, + SSCOP_UU_NULL, 0, err); + if (err) { + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + break; + + case UVU_TERM: + /* Ignore */ + break; + + case UVU_INST: + case UVU_PRELEASE: + default: + log(LOG_ERR, "sscf_uni_lower: cmd=0x%x, ustate=%d\n", + cmd, uvp->uv_ustate); + sscf_uni_abort(uvp, "sscf_uni: sequence err\n"); + } + break; + + case SSCF_UNI_DATA_REQ: +#ifdef notdef + sscf_uni_pdu_print(uvp, (KBuffer *)arg1, "DATA_REQ"); +#endif + + /* + * Validation based on user state + */ + switch (uvp->uv_ustate) { + + case UVU_ACTIVE: + /* + * Send assured data on connection + */ + STACK_CALL(SSCOP_DATA_REQ, uvp->uv_lower, + uvp->uv_tokl, cvp, + arg1, 0, err); + if (err) { + KB_FREEALL((KBuffer *)arg1); + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + break; + + case UVU_RELEASED: + case UVU_TERM: + /* + * Release supplied buffers and ignore + */ + KB_FREEALL((KBuffer *)arg1); + break; + + case UVU_INST: + case UVU_PACTIVE: + case UVU_PRELEASE: + default: + KB_FREEALL((KBuffer *)arg1); + log(LOG_ERR, "sscf_uni_lower: cmd=0x%x, ustate=%d\n", + cmd, uvp->uv_ustate); + sscf_uni_abort(uvp, "sscf_uni: sequence err\n"); + } + break; + + case SSCF_UNI_UNITDATA_REQ: +#ifdef notdef + sscf_uni_pdu_print(uvp, (KBuffer *)arg1, "UNITDATA_REQ"); +#endif + + /* + * Validation based on user state + */ + switch (uvp->uv_ustate) { + + case UVU_RELEASED: + case UVU_PACTIVE: + case UVU_PRELEASE: + case UVU_ACTIVE: + /* + * Send unassured data on connection + */ + STACK_CALL(SSCOP_UNITDATA_REQ, uvp->uv_lower, + uvp->uv_tokl, cvp, + arg1, 0, err); + if (err) { + KB_FREEALL((KBuffer *)arg1); + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + break; + + case UVU_TERM: + /* + * Release supplied buffers and ignore + */ + KB_FREEALL((KBuffer *)arg1); + break; + + case UVU_INST: + default: + KB_FREEALL((KBuffer *)arg1); + log(LOG_ERR, "sscf_uni_lower: cmd=0x%x, ustate=%d\n", + cmd, uvp->uv_ustate); + sscf_uni_abort(uvp, "sscf_uni: sequence err\n"); + } + break; + + default: + log(LOG_ERR, "sscf_uni_lower: unknown cmd 0x%x, uvp=0x%x\n", + cmd, (int)uvp); + } + + return; +} + diff --git a/sys/netatm/uni/sscf_uni_upper.c b/sys/netatm/uni/sscf_uni_upper.c new file mode 100644 index 0000000..2febb5c --- /dev/null +++ b/sys/netatm/uni/sscf_uni_upper.c @@ -0,0 +1,625 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscf_uni_upper.c,v 1.7 1998/06/29 22:15:31 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * SSCF UNI - SSCOP SAP interface processing + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: sscf_uni_upper.c,v 1.7 1998/06/29 22:15:31 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscf_uni.h> +#include <netatm/uni/sscf_uni_var.h> + + +/* + * SSCF_UNI Upper Stack Command Handler + * + * This function will receive all of the stack commands issued from the + * layer below SSCF UNI (ie. SSCOP). + * + * Arguments: + * cmd stack command code + * tok session token + * arg1 command specific argument + * arg2 command specific argument + * + * Returns: + * none + * + */ +void +sscf_uni_upper(cmd, tok, arg1, arg2) + int cmd; + void *tok; + int arg1; + int arg2; +{ + struct univcc *uvp = (struct univcc *)tok; + Atm_connvc *cvp = uvp->uv_connvc; + int err; + + ATM_DEBUG5("sscf_uni_upper: cmd=0x%x, uvp=0x%x, lstate=%d, arg1=0x%x, arg2=0x%x\n", + cmd, (int)uvp, uvp->uv_lstate, arg1, arg2); + + switch (cmd) { + + case SSCOP_ESTABLISH_IND: + /* + * We don't support SSCOP User-to-User data, so just + * get rid of any supplied to us + */ + if (arg1 != SSCOP_UU_NULL) + KB_FREEALL((KBuffer *)arg1); + + /* + * Validation based on sscop state + */ + switch (uvp->uv_lstate) { + + case UVL_READY: + if (uvp->uv_vers != UNI_VERS_3_0) { + goto seqerr; + } + goto doestind; + + case UVL_IDLE: + /* + * Incoming connection establishment request + */ + + /* + * If user doesn't want any more incoming sessions + * accepted, then refuse request + */ + if (uvp->uv_flags & UVF_NOESTIND) { + STACK_CALL(SSCOP_RELEASE_REQ, uvp->uv_lower, + uvp->uv_tokl, cvp, + SSCOP_UU_NULL, 0, err); + if (err) { + sscf_uni_abort(uvp, + "sscf_uni: stack memory\n"); + return; + } + break; + } + +doestind: + /* + * Tell sscop we've accepted the new connection + */ + uvp->uv_lstate = UVL_READY; + STACK_CALL(SSCOP_ESTABLISH_RSP, uvp->uv_lower, + uvp->uv_tokl, cvp, + SSCOP_UU_NULL, SSCOP_BR_YES, err); + if (err) { + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + + /* + * Now notify the user of the new connection + */ + uvp->uv_ustate = UVU_ACTIVE; + STACK_CALL(SSCF_UNI_ESTABLISH_IND, uvp->uv_upper, + uvp->uv_toku, cvp, + SSCOP_UU_NULL, 0, err); + if (err) { + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + break; + + case UVL_TERM: + /* + * Ignoring everything + */ + break; + + case UVL_INST: + case UVL_OUTCONN: + case UVL_INCONN: + case UVL_OUTDISC: + case UVL_OUTRESYN: + case UVL_INRESYN: + case UVL_RECOVERY: + default: +seqerr: + log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n", + cmd, uvp->uv_lstate); + sscf_uni_abort(uvp, "sscf_uni: sequence err\n"); + } + break; + + case SSCOP_ESTABLISH_CNF: + /* + * We don't support SSCOP User-to-User data, so just + * get rid of any supplied to us + */ + if (arg1 != SSCOP_UU_NULL) + KB_FREEALL((KBuffer *)arg1); + + /* + * Validation based on sscop state + */ + switch (uvp->uv_lstate) { + + case UVL_OUTCONN: + /* + * Outgoing connection establishment completed + */ + + /* + * Tell the user that the connection is established + */ + uvp->uv_ustate = UVU_ACTIVE; + uvp->uv_lstate = UVL_READY; + STACK_CALL(SSCF_UNI_ESTABLISH_CNF, uvp->uv_upper, + uvp->uv_toku, cvp, + SSCOP_UU_NULL, 0, err); + if (err) { + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + break; + + case UVL_TERM: + /* + * Ignoring everything + */ + break; + + case UVL_INST: + case UVL_IDLE: + case UVL_INCONN: + case UVL_OUTDISC: + case UVL_OUTRESYN: + case UVL_INRESYN: + case UVL_RECOVERY: + case UVL_READY: + default: + log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n", + cmd, uvp->uv_lstate); + sscf_uni_abort(uvp, "sscf_uni: sequence err\n"); + } + break; + + case SSCOP_RELEASE_IND: + /* + * We don't support SSCOP User-to-User data, so just + * get rid of any supplied to us + */ + if (arg1 != SSCOP_UU_NULL) + KB_FREEALL((KBuffer *)arg1); + + /* + * Validation based on sscop state + */ + switch (uvp->uv_lstate) { + + case UVL_OUTCONN: + case UVL_OUTRESYN: + case UVL_READY: + /* + * Peer requesting connection termination + */ + + /* + * Notify the user that the connection + * has been terminated + */ + uvp->uv_ustate = UVU_RELEASED; + uvp->uv_lstate = UVL_IDLE; + STACK_CALL(SSCF_UNI_RELEASE_IND, uvp->uv_upper, + uvp->uv_toku, cvp, + SSCOP_UU_NULL, 0, err); + if (err) { + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + break; + + case UVL_TERM: + /* + * Ignoring everything + */ + break; + + case UVL_INST: + case UVL_IDLE: + case UVL_INCONN: + case UVL_OUTDISC: + case UVL_INRESYN: + case UVL_RECOVERY: + default: + log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n", + cmd, uvp->uv_lstate); + sscf_uni_abort(uvp, "sscf_uni: sequence err\n"); + } + break; + + case SSCOP_RELEASE_CNF: + /* + * Validation based on sscop state + */ + switch (uvp->uv_lstate) { + + case UVL_OUTDISC: + /* + * Peer acknowledging connection termination + */ + + /* + * Notify the user that the connection + * termination is completed + */ + uvp->uv_ustate = UVU_RELEASED; + uvp->uv_lstate = UVL_IDLE; + STACK_CALL(SSCF_UNI_RELEASE_CNF, uvp->uv_upper, + uvp->uv_toku, cvp, + SSCOP_UU_NULL, 0, err); + if (err) { + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + break; + + case UVL_TERM: + /* + * Ignoring everything + */ + break; + + case UVL_INST: + case UVL_IDLE: + case UVL_OUTCONN: + case UVL_INCONN: + case UVL_OUTRESYN: + case UVL_INRESYN: + case UVL_RECOVERY: + case UVL_READY: + default: + log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n", + cmd, uvp->uv_lstate); + sscf_uni_abort(uvp, "sscf_uni: sequence err\n"); + } + break; + + case SSCOP_DATA_IND: +#ifdef notdef + sscf_uni_pdu_print(uvp, (KBuffer *)arg1, "DATA_IND"); +#endif + + /* + * Validation based on sscop state + */ + switch (uvp->uv_lstate) { + + case UVL_READY: + /* + * Incoming assured data from peer + */ + + /* + * Pass the data up to the user + */ + STACK_CALL(SSCF_UNI_DATA_IND, uvp->uv_upper, + uvp->uv_toku, cvp, + arg1, 0, err); + if (err) { + KB_FREEALL((KBuffer *)arg1); + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + break; + + case UVL_TERM: + /* + * Ignoring everything + */ + KB_FREEALL((KBuffer *)arg1); + break; + + case UVL_INST: + case UVL_IDLE: + case UVL_OUTCONN: + case UVL_INCONN: + case UVL_OUTDISC: + case UVL_OUTRESYN: + case UVL_INRESYN: + case UVL_RECOVERY: + default: + KB_FREEALL((KBuffer *)arg1); + log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n", + cmd, uvp->uv_lstate); + sscf_uni_abort(uvp, "sscf_uni: sequence err\n"); + } + break; + + case SSCOP_RESYNC_IND: + /* + * We don't support SSCOP User-to-User data, so just + * get rid of any supplied to us + */ + if (arg1 != SSCOP_UU_NULL) + KB_FREEALL((KBuffer *)arg1); + + /* + * Validation based on sscop state + */ + switch (uvp->uv_lstate) { + + case UVL_READY: + /* + * Incoming connection resynchronization request + */ + + /* + * Send resynch acknowledgement to sscop + */ + STACK_CALL(SSCOP_RESYNC_RSP, uvp->uv_lower, + uvp->uv_tokl, cvp, + 0, 0, err); + if (err) { + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + + if (uvp->uv_vers != UNI_VERS_3_0) { + + /* + * Notify the user that the connection + * has been resynced + */ + STACK_CALL(SSCF_UNI_ESTABLISH_IND, + uvp->uv_upper, uvp->uv_toku, cvp, + SSCOP_UU_NULL, 0, err); + if (err) { + sscf_uni_abort(uvp, + "sscf_uni: stack memory\n"); + return; + } + } + break; + + case UVL_TERM: + /* + * Ignoring everything + */ + break; + + case UVL_INST: + case UVL_IDLE: + case UVL_OUTCONN: + case UVL_INCONN: + case UVL_OUTDISC: + case UVL_OUTRESYN: + case UVL_INRESYN: + case UVL_RECOVERY: + default: + log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n", + cmd, uvp->uv_lstate); + sscf_uni_abort(uvp, "sscf_uni: sequence err\n"); + } + break; + + case SSCOP_RESYNC_CNF: + /* + * Not supported in version 3.0 + */ + if (uvp->uv_vers == UNI_VERS_3_0) { + sscf_uni_abort(uvp, + "sscf_uni: SSCOP_RESYNC_CNF in 3.0\n"); + return; + } + + /* + * Validation based on sscop state + */ + switch (uvp->uv_lstate) { + + case UVL_OUTRESYN: + /* + * Peer acknowledging connection resynchronization + */ + + /* + * Now notify the user that the connection + * has been resynced + */ + uvp->uv_ustate = UVU_ACTIVE; + uvp->uv_lstate = UVL_READY; + STACK_CALL(SSCF_UNI_ESTABLISH_CNF, uvp->uv_upper, + uvp->uv_toku, cvp, + SSCOP_UU_NULL, 0, err); + if (err) { + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + break; + + case UVL_TERM: + /* + * Ignoring everything + */ + break; + + case UVL_INST: + case UVL_IDLE: + case UVL_OUTCONN: + case UVL_INCONN: + case UVL_OUTDISC: + case UVL_INRESYN: + case UVL_RECOVERY: + case UVL_READY: + default: + log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n", + cmd, uvp->uv_lstate); + sscf_uni_abort(uvp, "sscf_uni: sequence err\n"); + } + break; + + case SSCOP_RECOVER_IND: + /* + * Not supported in version 3.0 + */ + if (uvp->uv_vers == UNI_VERS_3_0) { + sscf_uni_abort(uvp, + "sscf_uni: SSCOP_RECOVER_IND in 3.0\n"); + return; + } + + /* + * Validation based on sscop state + */ + switch (uvp->uv_lstate) { + + case UVL_READY: + /* + * Recover connection due to internal problems + */ + + /* + * Send recovery acknowledgement to sscop + */ + STACK_CALL(SSCOP_RECOVER_RSP, uvp->uv_lower, + uvp->uv_tokl, cvp, + 0, 0, err); + if (err) { + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + + /* + * Now notify the user that the connection + * has been recovered + */ + STACK_CALL(SSCF_UNI_ESTABLISH_IND, uvp->uv_upper, + uvp->uv_toku, cvp, + SSCOP_UU_NULL, 0, err); + if (err) { + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + break; + + case UVL_TERM: + /* + * Ignoring everything + */ + break; + + case UVL_INST: + case UVL_IDLE: + case UVL_OUTCONN: + case UVL_INCONN: + case UVL_OUTDISC: + case UVL_OUTRESYN: + case UVL_INRESYN: + case UVL_RECOVERY: + default: + log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n", + cmd, uvp->uv_lstate); + sscf_uni_abort(uvp, "sscf_uni: sequence err\n"); + } + break; + + case SSCOP_UNITDATA_IND: +#ifdef notdef + sscf_uni_pdu_print(uvp, (KBuffer *)arg1, "UNITDATA_IND"); +#endif + + /* + * Validation based on sscop state + */ + switch (uvp->uv_lstate) { + + case UVL_IDLE: + case UVL_OUTCONN: + case UVL_INCONN: + case UVL_OUTDISC: + case UVL_OUTRESYN: + case UVL_INRESYN: + case UVL_RECOVERY: + case UVL_READY: + /* + * Incoming unassured data from peer + */ + + /* + * Pass the data up to the user + */ + STACK_CALL(SSCF_UNI_UNITDATA_IND, uvp->uv_upper, + uvp->uv_toku, cvp, + arg1, 0, err); + if (err) { + KB_FREEALL((KBuffer *)arg1); + sscf_uni_abort(uvp, "sscf_uni: stack memory\n"); + return; + } + break; + + case UVL_TERM: + /* + * Ignoring everything + */ + KB_FREEALL((KBuffer *)arg1); + break; + + case UVL_INST: + default: + KB_FREEALL((KBuffer *)arg1); + log(LOG_ERR, "sscf_uni_upper: cmd=0x%x, lstate=%d\n", + cmd, uvp->uv_lstate); + sscf_uni_abort(uvp, "sscf_uni: sequence err\n"); + } + break; + + case SSCOP_RETRIEVE_IND: + case SSCOP_RETRIEVECMP_IND: + /* + * Not supported + */ + default: + log(LOG_ERR, "sscf_uni_upper: unknown cmd 0x%x, uvp=0x%x\n", + cmd, (int)uvp); + } + + return; +} + diff --git a/sys/netatm/uni/sscf_uni_var.h b/sys/netatm/uni/sscf_uni_var.h new file mode 100644 index 0000000..ffed7de --- /dev/null +++ b/sys/netatm/uni/sscf_uni_var.h @@ -0,0 +1,115 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscf_uni_var.h,v 1.5 1998/02/19 20:22:05 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * SSCF UNI protocol control blocks + * + */ + +#ifndef _UNI_SSCF_UNI_VAR_H +#define _UNI_SSCF_UNI_VAR_H + +/* + * Structure containing information for each SSCF UNI connection. + */ +struct univcc { + u_char uv_ustate; /* SSCF-User state (see below) */ + u_char uv_lstate; /* SSCF-SSCOP state (see below) */ + u_short uv_flags; /* Connection flags (see below) */ + enum uni_vers uv_vers; /* UNI version */ + + /* Stack variables */ + Atm_connvc *uv_connvc; /* Connection vcc for this stack */ + void *uv_toku; /* Stack upper layer's token */ + void *uv_tokl; /* Stack lower layer's token */ + void (*uv_upper) /* Stack upper layer's interface */ + __P((int, void *, int, int)); + void (*uv_lower) /* Stack lower layer's interface */ + __P((int, void *, int, int)); +}; + +/* + * SSCF to SAAL User (Q.2931) Interface States + */ +#define UVU_INST 0 /* Instantiated, waiting for INIT */ +#define UVU_RELEASED 1 /* Connection released */ +#define UVU_PACTIVE 2 /* Awaiting connection establishment */ +#define UVU_PRELEASE 3 /* Awaiting connection release */ +#define UVU_ACTIVE 4 /* Connection established */ +#define UVU_TERM 5 /* Waiting for TERM */ + +/* + * SSCF to SSCOP Interface States + */ +#define UVL_INST 0 /* Instantiated, waiting for INIT */ +#define UVL_IDLE 1 /* Idle */ +#define UVL_OUTCONN 2 /* Outgoing connection pending */ +#define UVL_INCONN 3 /* Incoming connection pending */ +#define UVL_OUTDISC 4 /* Outgoing disconnection pending */ +#define UVL_OUTRESYN 5 /* Outgoing resynchronization pending */ +#define UVL_INRESYN 6 /* Incoming resynchornization pending */ +#define UVL_RECOVERY 8 /* Recovery pending */ +#define UVL_READY 10 /* Data transfer ready */ +#define UVL_TERM 11 /* Waiting for TERM */ + +/* + * Connection Flags + */ +#define UVF_NOESTIND 0x0001 /* Don't process ESTABLISH_IND */ + + +#ifdef ATM_KERNEL +/* + * Global function declarations + */ + /* sscf_uni.c */ +int sscf_uni_start __P((void)); +int sscf_uni_stop __P((void)); +void sscf_uni_abort __P((struct univcc *, char *)); +void sscf_uni_pdu_print __P((struct univcc *, KBuffer *, + char *)); + + /* sscf_uni_lower.c */ +void sscf_uni_lower __P((int, void *, int, int)); + + /* sscf_uni_upper.c */ +void sscf_uni_upper __P((int, void *, int, int)); + + +/* + * External variables + */ +extern int sscf_uni_vccnt; + +#endif /* ATM_KERNEL */ + +#endif /* _UNI_SSCF_UNI_VAR_H */ diff --git a/sys/netatm/uni/sscop.c b/sys/netatm/uni/sscop.c new file mode 100644 index 0000000..d65118b --- /dev/null +++ b/sys/netatm/uni/sscop.c @@ -0,0 +1,409 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscop.c,v 1.6 1998/03/24 21:10:43 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * Service Specific Connection Oriented Protocol (SSCOP) + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: sscop.c,v 1.6 1998/03/24 21:10:43 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscop_misc.h> +#include <netatm/uni/sscop_pdu.h> +#include <netatm/uni/sscop_var.h> + + +/* + * Global variables + */ +int sscop_vccnt = 0; + +struct sscop *sscop_head = NULL; + +struct sscop_stat sscop_stat = {0}; + +struct atm_time sscop_timer = {0, 0}; + +struct sp_info sscop_pool = { + "sscop pool", /* si_name */ + sizeof(struct sscop), /* si_blksiz */ + 5, /* si_blkcnt */ + 100 /* si_maxallow */ +}; + + +/* + * Local functions + */ +static int sscop_inst __P((struct stack_defn **, Atm_connvc *)); + + +/* + * Local variables + */ +static struct stack_defn sscop_service = { + NULL, + SAP_SSCOP, + 0, + sscop_inst, + sscop_lower, + sscop_upper, + 0 +}; + +static struct t_atm_cause sscop_cause = { + T_ATM_ITU_CODING, + T_ATM_LOC_USER, + T_ATM_CAUSE_TEMPORARY_FAILURE, + {0, 0, 0, 0} +}; + +static u_char sscop_maa_log[MAA_ERROR_COUNT] = { + 1, /* A */ + 1, /* B */ + 1, /* C */ + 1, /* D */ + 1, /* E */ + 1, /* F */ + 1, /* G */ + 1, /* H */ + 1, /* I */ + 1, /* J */ + 1, /* K */ + 1, /* L */ + 1, /* M */ + 0, /* N */ + 0, /* O */ + 0, /* P */ + 1, /* Q */ + 1, /* R */ + 1, /* S */ + 1, /* T */ + 1, /* U */ + 0, /* V */ + 0, /* W */ + 0, /* X */ + 1 /* INVAL */ +}; + + +/* + * Initialize SSCOP processing + * + * This will be called during module loading. We will register our stack + * service and wait for someone to talk to us. + * + * Arguments: + * none + * + * Returns: + * 0 initialization was successful + * errno initialization failed - reason indicated + * + */ +int +sscop_start() +{ + int err = 0; + + /* + * Register stack service + */ + if (err = atm_stack_register(&sscop_service)) + goto done; + + /* + * Start up timer + */ + atm_timeout(&sscop_timer, ATM_HZ/SSCOP_HZ, sscop_timeout); + +done: + return (err); +} + + +/* + * Terminate SSCOP processing + * + * This will be called just prior to unloading the module from memory. All + * signalling instances should have been terminated by now, so we just free + * up all of our resources. + * + * Called at splnet. + * + * Arguments: + * none + * + * Returns: + * 0 termination was successful + * errno termination failed - reason indicated + * + */ +int +sscop_stop() +{ + int err = 0; + + /* + * Any connections still exist?? + */ + if (sscop_vccnt) { + + /* + * Yes, can't stop yet + */ + return (EBUSY); + } + + /* + * Stop our timer + */ + (void) atm_untimeout(&sscop_timer); + + /* + * Deregister the stack service + */ + (void) atm_stack_deregister(&sscop_service); + + /* + * Free our storage pools + */ + atm_release_pool(&sscop_pool); + +done: + return (err); +} + + +/* + * SSCOP Stack Instantiation + * + * Called at splnet. + * + * Arguments: + * ssp pointer to array of stack definition pointers for connection + * ssp[0] points to upper layer's stack service definition + * ssp[1] points to this layer's stack service definition + * ssp[2] points to lower layer's stack service definition + * cvp pointer to connection vcc for this stack + * + * Returns: + * 0 instantiation successful + * errno instantiation failed - reason indicated + * + */ +static int +sscop_inst(ssp, cvp) + struct stack_defn **ssp; + Atm_connvc *cvp; +{ + struct stack_defn *sdp_up = ssp[0], + *sdp_me = ssp[1], + *sdp_low = ssp[2]; + struct sscop *sop; + int err; + + ATM_DEBUG2("sscop_inst: ssp=0x%x, cvp=0x%x\n", ssp, cvp); + + /* + * Validate lower SAP + */ + if ((sdp_low->sd_sap & SAP_CLASS_MASK) != SAP_CPCS) + return (EINVAL); + + /* + * Allocate our control block + */ + sop = (struct sscop *)atm_allocate(&sscop_pool); + if (sop == NULL) + return (ENOMEM); + + sop->so_state = SOS_INST; + sop->so_connvc = cvp; + sop->so_toku = sdp_up->sd_toku; + sop->so_upper = sdp_up->sd_upper; + + /* + * Store my token into service definition + */ + sdp_me->sd_toku = sop; + + /* + * Update and save input buffer headroom + */ + HEADIN(cvp, sizeof(struct pdu_hdr), 0); + /* sop->so_headin = cvp->cvc_attr.headin; */ + + /* + * Pass instantiation down the stack + */ + err = sdp_low->sd_inst(ssp + 1, cvp); + if (err) { + /* + * Lower layer instantiation failed, free our resources + */ + atm_free((caddr_t)sop); + return (err); + } + + /* + * Link in connection block + */ + LINK2TAIL(sop, struct sscop, sscop_head, so_next); + sscop_vccnt++; + sscop_stat.sos_connects++; + + /* + * Save and update output buffer headroom + */ + sop->so_headout = cvp->cvc_attr.headout; + HEADOUT(cvp, sizeof(struct pdu_hdr), 0); + + /* + * Save lower layer's interface info + */ + sop->so_lower = sdp_low->sd_lower; + sop->so_tokl = sdp_low->sd_toku; + + /* + * Initialize version (until INIT received) + */ + sop->so_vers = SSCOP_VERS_Q2110; + + return (0); +} + + +/* + * Report Management Error + * + * Called to report an error to the layer management entity. + * + * Arguments: + * sop pointer to sscop control block + * code error code + * + * Returns: + * none + * + */ +void +sscop_maa_error(sop, code) + struct sscop *sop; + int code; +{ + int i; + + /* + * Validate error code + */ + if ((code < MAA_ERROR_MIN) || + (code > MAA_ERROR_MAX)) + code = MAA_ERROR_INVAL; + i = code - MAA_ERROR_MIN; + + /* + * Bump statistics counters + */ + sscop_stat.sos_maa_error[i]++; + + /* + * Log error message + */ + if (sscop_maa_log[i] != 0) { + struct vccb *vcp = sop->so_connvc->cvc_vcc; + struct atm_pif *pip = vcp->vc_pif; + + log(LOG_ERR, + "sscop_maa_error: intf=%s%d vpi=%d vci=%d code=%c state=%d\n", + pip->pif_name, pip->pif_unit, + vcp->vc_vpi, vcp->vc_vci, code, sop->so_state); + } +} + + +/* + * Abort an SSCOP connection + * + * Called when an unrecoverable or "should never happen" error occurs. + * We log a message, send an END PDU to our peer and request the signalling + * manager to abort the connection. + * + * Arguments: + * sop pointer to sscop control block + * msg pointer to error message + * + * Returns: + * none + * + */ +void +sscop_abort(sop, msg) + struct sscop *sop; + char *msg; +{ + Atm_connvc *cvp = sop->so_connvc; + + /* + * Log and count error + */ + log(LOG_ERR, msg); + sscop_stat.sos_aborts++; + + /* + * Send an END PDU as a courtesy to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + /* + * Set termination state + */ + sop->so_state = SOS_TERM; + + /* + * Flush all of our queues + */ + sscop_xmit_drain(sop); + sscop_rcvr_drain(sop); + + /* + * Tell Connection Manager to abort this connection + */ + (void) atm_cm_abort(cvp, &sscop_cause); +} + diff --git a/sys/netatm/uni/sscop.h b/sys/netatm/uni/sscop.h new file mode 100644 index 0000000..2f786b3 --- /dev/null +++ b/sys/netatm/uni/sscop.h @@ -0,0 +1,80 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscop.h,v 1.4 1998/08/26 23:29:19 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * SSCOP protocol definitions + * + */ + +#ifndef _UNI_SSCOP_H +#define _UNI_SSCOP_H + +/* + * SSCOP Version + */ +enum sscop_vers { + SSCOP_VERS_QSAAL, /* Version = Q.SAAL1 */ + SSCOP_VERS_Q2110 /* Version = Q.2110 */ +}; + + +/* + * SSCOP API definitions + */ +#define SSCOP_UU_NULL 0 /* User-to-User Info = null */ +#define SSCOP_RN_TOTAL -1 /* Retrieval Number = Total */ +#define SSCOP_RN_UNKNOWN -2 /* Retrieval Number = Unknown */ +#define SSCOP_BR_YES 1 /* Buffer Release = Yes */ +#define SSCOP_BR_NO 2 /* Buffer Release = No */ +#define SSCOP_SOURCE_SSCOP 1 /* Source = SSCOP */ +#define SSCOP_SOURCE_USER 2 /* Source = User */ +#define SSCOP_SOURCE_LAST 3 /* Source = from last END */ + + +/* + * Connection parameters for an SSCOP entity. + * Passed via an SSCOP_INIT stack call argument. + */ +struct sscop_parms { + u_short sp_maxinfo; /* k - max information field size */ + u_short sp_maxuu; /* j - max SSCOP-UU field size */ + short sp_maxcc; /* MaxCC - max value of VT(CC) */ + short sp_maxpd; /* MaxPD - max value of VT(PD) */ + u_short sp_timecc; /* Timer_CC value (ticks) */ + u_short sp_timekeep; /* Timer_KEEPALIVE value (ticks) */ + u_short sp_timeresp; /* Timer_NO-RESPONSE value (ticks) */ + u_short sp_timepoll; /* Timer_POLL value (ticks) */ + u_short sp_timeidle; /* Timer_IDLE value (ticks) */ + short sp_rcvwin; /* Receiver window size */ +}; + +#endif /* _UNI_SSCOP_H */ diff --git a/sys/netatm/uni/sscop_lower.c b/sys/netatm/uni/sscop_lower.c new file mode 100644 index 0000000..f76f702 --- /dev/null +++ b/sys/netatm/uni/sscop_lower.c @@ -0,0 +1,349 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscop_lower.c,v 1.6 1998/04/07 23:21:28 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * SSCOP - SSCOP SAP interface processing + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: sscop_lower.c,v 1.6 1998/04/07 23:21:28 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscop_misc.h> +#include <netatm/uni/sscop_pdu.h> +#include <netatm/uni/sscop_var.h> + + +/* + * Local variables + */ +/* + * Stack commands with arg1 containing an buffer pointer + */ +static u_char sscop_buf1[] = { + 0, + 0, /* SSCOP_INIT */ + 0, /* SSCOP_TERM */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, /* SSCOP_ESTABLISH_REQ */ + 0, + 1, /* SSCOP_ESTABLISH_RSP */ + 0, + 1, /* SSCOP_RELEASE_REQ */ + 0, + 0, + 1, /* SSCOP_DATA_REQ */ + 0, + 1, /* SSCOP_RESYNC_REQ */ + 0, + 0, /* SSCOP_RESYNC_RSP */ + 0, + 0, + 0, /* SSCOP_RECOVER_RSP */ + 1, /* SSCOP_UNITDATA_REQ */ + 0, + 0, /* SSCOP_RETRIEVE_REQ */ + 0, + 0 +}; + + +/* + * SSCOP Lower Stack Command Handler + * + * This function will receive all of the stack commands issued from the + * layer above SSCOP (ie. using the SSCOP SAP). The appropriate processing + * function will be determined based on the received stack command and the + * current sscop control block state. + * + * Arguments: + * cmd stack command code + * tok session token + * arg1 command specific argument + * arg2 command specific argument + * + * Returns: + * none + * + */ +void +sscop_lower(cmd, tok, arg1, arg2) + int cmd; + void *tok; + int arg1; + int arg2; +{ + struct sscop *sop = (struct sscop *)tok; + void (**stab) __P((struct sscop *, int, int)); + void (*func) __P((struct sscop *, int, int)); + int val; + + ATM_DEBUG5("sscop_lower: cmd=0x%x, sop=0x%x, state=%d, arg1=0x%x, arg2=0x%x\n", + cmd, (int)sop, sop->so_state, arg1, arg2); + + /* + * Validate stack command + */ + val = cmd & STKCMD_VAL_MASK; + if (((u_int)cmd < (u_int)SSCOP_CMD_MIN) || + ((u_int)cmd > (u_int)SSCOP_CMD_MAX) || + ((stab = (sop->so_vers == SSCOP_VERS_QSAAL ? + sscop_qsaal_aatab[val] : + sscop_q2110_aatab[val])) == NULL)) { + log(LOG_ERR, "sscop_lower: unknown cmd 0x%x, sop=0x%x\n", + cmd, (int)sop); + return; + } + + /* + * Validate sscop state + */ + if (sop->so_state > SOS_MAXSTATE) { + log(LOG_ERR, "sscop_lower: invalid state sop=0x%x, state=%d\n", + (int)sop, sop->so_state); + /* + * Release possible buffer + */ + if (sscop_buf1[val]) { + if (arg1) + KB_FREEALL((KBuffer *)arg1); + } + return; + } + + /* + * Validate command/state combination + */ + func = stab[sop->so_state]; + if (func == NULL) { + log(LOG_ERR, + "sscop_lower: invalid cmd/state: sop=0x%x, cmd=0x%x, state=%d\n", + (int)sop, cmd, sop->so_state); + /* + * Release possible buffer + */ + if (sscop_buf1[val]) { + if (arg1) + KB_FREEALL((KBuffer *)arg1); + } + return; + } + + /* + * Call event processing function + */ + (*func)(sop, arg1, arg2); + + return; +} + + +/* + * No-op Processor (no buffers) + * + * Arguments: + * sop pointer to sscop connection block + * arg1 command-specific argument + * arg2 command-specific argument + * + * Returns: + * none + * + */ +void +sscop_aa_noop_0(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + /* + * Nothing to do + */ + return; +} + + +/* + * No-op Processor (arg1 == buffer) + * + * Arguments: + * sop pointer to sscop connection block + * arg1 command-specific argument (buffer pointer) + * arg2 command-specific argument + * + * Returns: + * none + * + */ +void +sscop_aa_noop_1(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + + /* + * Just free buffer chain + */ + if (arg1) + KB_FREEALL((KBuffer *)arg1); + + return; +} + + +/* + * SSCOP_INIT / SOS_INST Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 command specific argument + * arg2 command specific argument + * + * Returns: + * none + * + */ +void +sscop_init_inst(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + int err; + + /* + * Make ourselves ready and pass on the INIT + */ + sop->so_state = SOS_IDLE; + + /* + * Validate SSCOP version to use + */ + switch ((enum sscop_vers)arg1) { + case SSCOP_VERS_QSAAL: + break; + + case SSCOP_VERS_Q2110: + break; + + default: + sscop_abort(sop, "sscop: bad version\n"); + return; + } + sop->so_vers = (enum sscop_vers)arg1; + + /* + * Copy SSCOP connection parameters to use + */ + sop->so_parm = *(struct sscop_parms *)arg2; + + /* + * Initialize lower layers + */ + STACK_CALL(CPCS_INIT, sop->so_lower, sop->so_tokl, sop->so_connvc, + 0, 0, err); + if (err) { + /* + * Should never happen + */ + sscop_abort(sop, "sscop: INIT failure\n"); + return; + } + return; +} + + +/* + * SSCOP_TERM / SOS_* Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 command specific argument + * arg2 command specific argument + * + * Returns: + * none + * + */ +void +sscop_term_all(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + int err; + + /* + * Set termination state + */ + sop->so_state = SOS_TERM; + + /* + * Pass the TERM down the stack + */ + STACK_CALL(CPCS_TERM, sop->so_lower, sop->so_tokl, sop->so_connvc, + 0, 0, err); + if (err) { + /* + * Should never happen + */ + sscop_abort(sop, "sscop: TERM failure\n"); + return; + } + + /* + * Unlink and free the connection block + */ + UNLINK(sop, struct sscop, sscop_head, so_next); + atm_free((caddr_t)sop); + sscop_vccnt--; + return; +} + diff --git a/sys/netatm/uni/sscop_misc.h b/sys/netatm/uni/sscop_misc.h new file mode 100644 index 0000000..4348cef --- /dev/null +++ b/sys/netatm/uni/sscop_misc.h @@ -0,0 +1,97 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscop_misc.h,v 1.4 1998/08/26 23:29:19 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * SSCOP miscellaneous definitions + * + */ + +#ifndef _UNI_SSCOP_MISC_H +#define _UNI_SSCOP_MISC_H + +/* + * SSCOP command definitions + */ +#define SSCOP_CMD_MIN SSCOP_INIT /* Minimum SSCOP CMD value */ +#define SSCOP_CMD_MAX SSCOP_RETRIEVECMP_IND /* Maximum SSCOP CMD value */ +#define SSCOP_CMD_SIZE 36 /* Size of command lookup table */ + + +/* + * Management Errors + */ +#define MAA_ERROR_MIN 'A' +#define MAA_ERROR_MAX 'X' +#define MAA_ERROR_INVAL (MAA_ERROR_MAX + 1) +#define MAA_ERROR_COUNT (MAA_ERROR_MAX - MAA_ERROR_MIN + 2) + + +/* + * SSCOP Sequence Numbers + * + * SSCOP sequence numbers are 24 bit integers using modulo arithmetic. + * The macros below must be used to modify and compare such numbers. + * Comparison of sequence numbers is always relative to some base number (b). + */ +typedef u_int sscop_seq; + +#define SEQ_MOD 0xffffff +#define SEQ_VAL(v) ((v) & SEQ_MOD) +#define SEQ_SET(s,v) ((s) = SEQ_VAL(v)) +#define SEQ_ADD(s,v) (SEQ_VAL((s) + (v))) +#define SEQ_SUB(s,v) (SEQ_VAL((s) - (v))) +#define SEQ_INCR(s,v) ((s) = SEQ_VAL((s) + (v))) +#define SEQ_DECR(s,v) ((s) = SEQ_VAL((s) - (v))) +#define SEQ_EQ(x,y) (SEQ_VAL(x) == SEQ_VAL(y)) +#define SEQ_NEQ(x,y) (SEQ_VAL(x) != SEQ_VAL(y)) +#define SEQ_LT(x,y,b) (SEQ_VAL((x) - (b)) < SEQ_VAL((y) - (b))) +#define SEQ_LEQ(x,y,b) (SEQ_VAL((x) - (b)) <= SEQ_VAL((y) - (b))) +#define SEQ_GT(x,y,b) (SEQ_VAL((x) - (b)) > SEQ_VAL((y) - (b))) +#define SEQ_GEQ(x,y,b) (SEQ_VAL((x) - (b)) >= SEQ_VAL((y) - (b))) + + +/* + * SSCOP Timers + * + * All of the SSCOP timer fields are maintained in terms of clock ticks. + * The timers tick 2 times per second. + */ +#define SSCOP_HZ 2 /* SSCOP ticks per second */ + +#define SSCOP_T_NUM 4 /* Number of timers per connection */ + +#define SSCOP_T_POLL 0 /* Timer_POLL / Timer_KEEP-ALIVE */ +#define SSCOP_T_NORESP 1 /* Timer_NO-RESPONSE */ +#define SSCOP_T_CC 2 /* Timer_CC */ +#define SSCOP_T_IDLE 3 /* Timer_IDLE */ + +#endif /* _UNI_SSCOP_MISC_H */ diff --git a/sys/netatm/uni/sscop_pdu.c b/sys/netatm/uni/sscop_pdu.c new file mode 100644 index 0000000..b9aec03 --- /dev/null +++ b/sys/netatm/uni/sscop_pdu.c @@ -0,0 +1,1237 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscop_pdu.c,v 1.6 1998/04/07 23:21:36 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * SSCOP - PDU subroutines + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: sscop_pdu.c,v 1.6 1998/04/07 23:21:36 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscop_misc.h> +#include <netatm/uni/sscop_pdu.h> +#include <netatm/uni/sscop_var.h> + +/* + * Local functions + */ +static KBuffer * sscop_stat_init __P((struct sscop *)); +static KBuffer * sscop_stat_add __P((sscop_seq, KBuffer *)); +static int sscop_stat_end __P((struct sscop *, sscop_seq, + KBuffer *, KBuffer *)); +static int sscop_recv_locate __P((struct sscop *, sscop_seq, + struct pdu_hdr **)); + + +/* + * Build and send BGN PDU + * + * A BGN PDU will be constructed and passed down the protocol stack. + * The SSCOP-UU/N(UU) field is not supported. + * + * Arguments: + * sop pointer to sscop connection control block + * source originator of BGN PDU (Q.SAAL1 only) + * + * Returns: + * 0 PDU successfully built and passed down the stack + * else unable to build or send pdu + * + */ +int +sscop_send_bgn(sop, source) + struct sscop *sop; + int source; +{ + KBuffer *m; + struct bgn_pdu *bp; + int err; + + + /* + * Get buffer for PDU + */ + KB_ALLOCPKT(m, sizeof(struct bgn_pdu), KB_F_NOWAIT, KB_T_HEADER); + if (m == NULL) + return (1); + + /* + * Setup buffer controls + */ + KB_HEADSET(m, MIN(sop->so_headout, + KB_BFRLEN(m) - sizeof(struct bgn_pdu))); + KB_LEN(m) = sizeof(struct bgn_pdu); + + /* + * Build PDU + */ + KB_DATASTART(m, bp, struct bgn_pdu *); + *(int *)&bp->bgn_rsvd[0] = 0; + if (sop->so_vers != SSCOP_VERS_QSAAL) + bp->bgn_nsq = sop->so_sendconn; + bp->bgn_nmr = + htonl((PT_BGN << PT_TYPE_SHIFT) | SEQ_VAL(sop->so_rcvmax)); + if ((sop->so_vers == SSCOP_VERS_QSAAL) && + (source == SSCOP_SOURCE_SSCOP)) + bp->bgn_type |= PT_SOURCE_SSCOP; + + /* + * Send PDU towards peer + */ + STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl, + sop->so_connvc, (int)m, 0, err); + + if (err) + KB_FREEALL(m); + + return (err); +} + + +/* + * Build and send BGAK PDU + * + * A BGAK PDU will be constructed and passed down the protocol stack. + * The SSCOP-UU/N(UU) field is not supported. + * + * Arguments: + * sop pointer to sscop connection control block + * + * Returns: + * 0 PDU successfully built and passed down the stack + * else unable to build or send pdu + * + */ +int +sscop_send_bgak(sop) + struct sscop *sop; +{ + KBuffer *m; + struct bgak_pdu *bp; + int err; + + + /* + * Get buffer for PDU + */ + KB_ALLOCPKT(m, sizeof(struct bgak_pdu), KB_F_NOWAIT, KB_T_HEADER); + if (m == NULL) + return (1); + + /* + * Setup buffer controls + */ + KB_HEADSET(m, MIN(sop->so_headout, + KB_BFRLEN(m) - sizeof(struct bgak_pdu))); + KB_LEN(m) = sizeof(struct bgak_pdu); + + /* + * Build PDU + */ + KB_DATASTART(m, bp, struct bgak_pdu *); + bp->bgak_rsvd = 0; + bp->bgak_nmr = + htonl((PT_BGAK << PT_TYPE_SHIFT) | SEQ_VAL(sop->so_rcvmax)); + + /* + * Send PDU towards peer + */ + STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl, + sop->so_connvc, (int)m, 0, err); + + if (err) + KB_FREEALL(m); + + return (err); +} + + +/* + * Build and send BGREJ PDU + * + * A BGREJ PDU will be constructed and passed down the protocol stack. + * The SSCOP-UU/N(UU) field is not supported. + * + * Arguments: + * sop pointer to sscop connection control block + * + * Returns: + * 0 PDU successfully built and passed down the stack + * else unable to build or send pdu + * + */ +int +sscop_send_bgrej(sop) + struct sscop *sop; +{ + KBuffer *m; + struct bgrej_pdu *bp; + int err; + + + /* + * Get buffer for PDU + */ + KB_ALLOCPKT(m, sizeof(struct bgrej_pdu), KB_F_NOWAIT, KB_T_HEADER); + if (m == NULL) + return (1); + + /* + * Setup buffer controls + */ + KB_HEADSET(m, MIN(sop->so_headout, + KB_BFRLEN(m) - sizeof(struct bgrej_pdu))); + KB_LEN(m) = sizeof(struct bgrej_pdu); + + /* + * Build PDU + */ + KB_DATASTART(m, bp, struct bgrej_pdu *); + bp->bgrej_rsvd2 = 0; + *(u_int *)&bp->bgrej_type = htonl((PT_BGREJ << PT_TYPE_SHIFT) | 0); + + /* + * Send PDU towards peer + */ + STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl, + sop->so_connvc, (int)m, 0, err); + + if (err) + KB_FREEALL(m); + + return (err); +} + + +/* + * Build and send END PDU + * + * An END PDU will be constructed and passed down the protocol stack. + * The SSCOP-UU/N(UU) field is not supported. + * + * Arguments: + * sop pointer to sscop connection control block + * source originator of END PDU + * + * Returns: + * 0 PDU successfully built and passed down the stack + * else unable to build or send pdu + * + */ +int +sscop_send_end(sop, source) + struct sscop *sop; + int source; +{ + KBuffer *m; + struct end_pdu *ep; + int err; + + + /* + * Get buffer for PDU + */ + KB_ALLOCPKT(m, sizeof(struct end_pdu), KB_F_NOWAIT, KB_T_HEADER); + if (m == NULL) + return (1); + + /* + * Setup buffer controls + */ + KB_HEADSET(m, MIN(sop->so_headout, + KB_BFRLEN(m) - sizeof(struct end_pdu))); + KB_LEN(m) = sizeof(struct end_pdu); + + /* + * Build PDU + */ + KB_DATASTART(m, ep, struct end_pdu *); + ep->end_rsvd2 = 0; + *(u_int *)&ep->end_type = htonl((PT_END << PT_TYPE_SHIFT) | 0); + if (source == SSCOP_SOURCE_SSCOP) { + ep->end_type |= PT_SOURCE_SSCOP; + sop->so_flags |= SOF_ENDSSCOP; + } else if (source == SSCOP_SOURCE_USER) + sop->so_flags &= ~SOF_ENDSSCOP; + else if ((source == SSCOP_SOURCE_LAST) && + (sop->so_flags & SOF_ENDSSCOP)) + ep->end_type |= PT_SOURCE_SSCOP; + + /* + * Send PDU towards peer + */ + STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl, + sop->so_connvc, (int)m, 0, err); + + if (err) + KB_FREEALL(m); + + return (err); +} + + +/* + * Build and send ENDAK PDU + * + * An ENDAK PDU will be constructed and passed down the protocol stack. + * + * Arguments: + * sop pointer to sscop connection control block + * + * Returns: + * 0 PDU successfully built and passed down the stack + * else unable to build or send pdu + * + */ +int +sscop_send_endak(sop) + struct sscop *sop; +{ + KBuffer *m; + struct endak_q2110_pdu *e2p; + struct endak_qsaal_pdu *esp; + int err, size; + + + /* + * Get size of PDU + */ + if (sop->so_vers == SSCOP_VERS_QSAAL) + size = sizeof(struct endak_qsaal_pdu); + else + size = sizeof(struct endak_q2110_pdu); + + /* + * Get buffer for PDU + */ + KB_ALLOCPKT(m, size, KB_F_NOWAIT, KB_T_HEADER); + if (m == NULL) + return (1); + + /* + * Setup buffer controls + */ + KB_HEADSET(m, MIN(sop->so_headout, KB_BFRLEN(m) - size)); + KB_LEN(m) = size; + + /* + * Build PDU + */ + if (sop->so_vers == SSCOP_VERS_QSAAL) { + KB_DATASTART(m, esp, struct endak_qsaal_pdu *); + *(u_int *)&esp->endak_type = + htonl((PT_ENDAK << PT_TYPE_SHIFT) | 0); + } else { + KB_DATASTART(m, e2p, struct endak_q2110_pdu *); + e2p->endak_rsvd2 = 0; + *(u_int *)&e2p->endak_type = + htonl((PT_ENDAK << PT_TYPE_SHIFT) | 0); + } + + /* + * Send PDU towards peer + */ + STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl, + sop->so_connvc, (int)m, 0, err); + + if (err) + KB_FREEALL(m); + + return (err); +} + + +/* + * Build and send RS PDU + * + * A RS PDU will be constructed and passed down the protocol stack. + * The SSCOP-UU/N(UU) field is not supported. + * + * Arguments: + * sop pointer to sscop connection control block + * + * Returns: + * 0 PDU successfully built and passed down the stack + * else unable to build or send pdu + * + */ +int +sscop_send_rs(sop) + struct sscop *sop; +{ + KBuffer *m; + struct rs_pdu *rp; + int err; + + + /* + * Get buffer for PDU + */ + KB_ALLOCPKT(m, sizeof(struct rs_pdu), KB_F_NOWAIT, KB_T_HEADER); + if (m == NULL) + return (1); + + /* + * Setup buffer controls + */ + KB_HEADSET(m, MIN(sop->so_headout, + KB_BFRLEN(m) - sizeof(struct rs_pdu))); + KB_LEN(m) = sizeof(struct rs_pdu); + + /* + * Build PDU + */ + KB_DATASTART(m, rp, struct rs_pdu *); + *(int *)&rp->rs_rsvd[0] = 0; + if (sop->so_vers != SSCOP_VERS_QSAAL) { + rp->rs_nsq = sop->so_sendconn; + rp->rs_nmr = htonl((PT_RS << PT_TYPE_SHIFT) | + SEQ_VAL(sop->so_rcvmax)); + } else { + rp->rs_nmr = htonl((PT_RS << PT_TYPE_SHIFT) | 0); + } + + /* + * Send PDU towards peer + */ + STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl, + sop->so_connvc, (int)m, 0, err); + + if (err) + KB_FREEALL(m); + + return (err); +} + + +/* + * Build and send RSAK PDU + * + * An RSAK PDU will be constructed and passed down the protocol stack. + * + * Arguments: + * sop pointer to sscop connection control block + * + * Returns: + * 0 PDU successfully built and passed down the stack + * else unable to build or send pdu + * + */ +int +sscop_send_rsak(sop) + struct sscop *sop; +{ + KBuffer *m; + struct rsak_q2110_pdu *r2p; + struct rsak_qsaal_pdu *rsp; + int err, size; + + + /* + * Get size of PDU + */ + if (sop->so_vers == SSCOP_VERS_QSAAL) + size = sizeof(struct rsak_qsaal_pdu); + else + size = sizeof(struct rsak_q2110_pdu); + + /* + * Get buffer for PDU + */ + KB_ALLOCPKT(m, size, KB_F_NOWAIT, KB_T_HEADER); + if (m == NULL) + return (1); + + /* + * Setup buffer controls + */ + KB_HEADSET(m, MIN(sop->so_headout, KB_BFRLEN(m) - size)); + KB_LEN(m) = size; + + /* + * Build PDU + */ + if (sop->so_vers == SSCOP_VERS_QSAAL) { + KB_DATASTART(m, rsp, struct rsak_qsaal_pdu *); + *(u_int *)&rsp->rsaks_type = + htonl((PT_RSAK << PT_TYPE_SHIFT) | 0); + } else { + KB_DATASTART(m, r2p, struct rsak_q2110_pdu *); + r2p->rsak_rsvd = 0; + r2p->rsak_nmr = htonl((PT_RSAK << PT_TYPE_SHIFT) | + SEQ_VAL(sop->so_rcvmax)); + } + + /* + * Send PDU towards peer + */ + STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl, + sop->so_connvc, (int)m, 0, err); + + if (err) + KB_FREEALL(m); + + return (err); +} + + +/* + * Build and send ER PDU + * + * An ER PDU will be constructed and passed down the protocol stack. + * + * Arguments: + * sop pointer to sscop connection control block + * + * Returns: + * 0 PDU successfully built and passed down the stack + * else unable to build or send pdu + * + */ +int +sscop_send_er(sop) + struct sscop *sop; +{ + KBuffer *m; + struct er_pdu *ep; + int err; + + + /* + * Get buffer for PDU + */ + KB_ALLOCPKT(m, sizeof(struct er_pdu), KB_F_NOWAIT, KB_T_HEADER); + if (m == NULL) + return (1); + + /* + * Setup buffer controls + */ + KB_HEADSET(m, MIN(sop->so_headout, + KB_BFRLEN(m) - sizeof(struct er_pdu))); + KB_LEN(m) = sizeof(struct er_pdu); + + /* + * Build PDU + */ + KB_DATASTART(m, ep, struct er_pdu *); + *(int *)&ep->er_rsvd[0] = 0; + ep->er_nsq = sop->so_sendconn; + ep->er_nmr = htonl((PT_ER << PT_TYPE_SHIFT) | SEQ_VAL(sop->so_rcvmax)); + + /* + * Send PDU towards peer + */ + STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl, + sop->so_connvc, (int)m, 0, err); + + if (err) + KB_FREEALL(m); + + return (err); +} + + +/* + * Build and send ERAK PDU + * + * An ERAK PDU will be constructed and passed down the protocol stack. + * + * Arguments: + * sop pointer to sscop connection control block + * + * Returns: + * 0 PDU successfully built and passed down the stack + * else unable to build or send pdu + * + */ +int +sscop_send_erak(sop) + struct sscop *sop; +{ + KBuffer *m; + struct erak_pdu *ep; + int err; + + + /* + * Get buffer for PDU + */ + KB_ALLOCPKT(m, sizeof(struct erak_pdu), KB_F_NOWAIT, KB_T_HEADER); + if (m == NULL) + return (1); + + /* + * Setup buffer controls + */ + KB_HEADSET(m, MIN(sop->so_headout, + KB_BFRLEN(m) - sizeof(struct erak_pdu))); + KB_LEN(m) = sizeof(struct erak_pdu); + + /* + * Build PDU + */ + KB_DATASTART(m, ep, struct erak_pdu *); + ep->erak_rsvd = 0; + ep->erak_nmr = htonl((PT_ERAK << PT_TYPE_SHIFT) | + SEQ_VAL(sop->so_rcvmax)); + + /* + * Send PDU towards peer + */ + STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl, + sop->so_connvc, (int)m, 0, err); + + if (err) + KB_FREEALL(m); + + return (err); +} + + +/* + * Build and send POLL PDU + * + * A POLL PDU will be constructed and passed down the protocol stack. + * + * Arguments: + * sop pointer to sscop connection control block + * + * Returns: + * 0 PDU successfully built and passed down the stack + * else unable to build or send pdu + * + */ +int +sscop_send_poll(sop) + struct sscop *sop; +{ + KBuffer *m; + struct poll_pdu *pp; + int err; + + + /* + * Get buffer for PDU + */ + KB_ALLOCPKT(m, sizeof(struct poll_pdu), KB_F_NOWAIT, KB_T_HEADER); + if (m == NULL) + return (1); + + /* + * Setup buffer controls + */ + KB_HEADSET(m, MIN(sop->so_headout, + KB_BFRLEN(m) - sizeof(struct poll_pdu))); + KB_LEN(m) = sizeof(struct poll_pdu); + + /* + * Build PDU + */ + KB_DATASTART(m, pp, struct poll_pdu *); + pp->poll_nps = htonl(SEQ_VAL(sop->so_pollsend)); + pp->poll_ns = htonl((PT_POLL << PT_TYPE_SHIFT) | SEQ_VAL(sop->so_send)); + + /* + * Send PDU towards peer + */ + STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl, + sop->so_connvc, (int)m, 0, err); + + if (err) + KB_FREEALL(m); + + return (err); +} + + +/* + * STAT PDU Construction - Initialize for new PDU + * + * Arguments: + * sop pointer to sscop connection control block + * + * Returns: + * addr pointer to initialized buffer + * 0 unable to allocate buffer + * + */ +static KBuffer * +sscop_stat_init(sop) + struct sscop *sop; +{ + KBuffer *m; + +#define STAT_INIT_SIZE (sizeof(struct stat_pdu) + 2 * sizeof(sscop_seq)) + + /* + * Get buffer for PDU + */ + KB_ALLOCPKT(m, STAT_INIT_SIZE, KB_F_NOWAIT, KB_T_HEADER); + if (m == NULL) + return (0); + + /* + * Setup buffer controls + */ + KB_HEADSET(m, sop->so_headout < (KB_BFRLEN(m) - STAT_INIT_SIZE) ? + sop->so_headout : 0); + KB_LEN(m) = 0; + + return (m); +#undef STAT_INIT_SIZE +} + + +/* + * STAT PDU Construction - Add List Element + * + * Arguments: + * elem sequence number to add to list + * m pointer to current buffer + * + * Returns: + * addr pointer to current buffer (updated) + * 0 buffer allocation failure + * + */ +static KBuffer * +sscop_stat_add(elem, m) + sscop_seq elem; + KBuffer *m; +{ + KBuffer *n; + sscop_seq *sp; + int space; + + /* + * See if new element will fit in current buffer + */ + KB_TAILROOM(m, space); + if (space < sizeof(elem)) { + + /* + * Nope, so get another buffer + */ + KB_ALLOC(n, sizeof(elem), KB_F_NOWAIT, KB_T_DATA); + if (n == NULL) + return (0); + + /* + * Link in new buffer + */ + KB_LINK(n, m); + KB_LEN(n) = 0; + m = n; + } + + /* + * Add new element + */ + KB_DATAEND(m, sp, sscop_seq *); + *sp = htonl(elem); + KB_LEN(m) += sizeof (elem); + return (m); +} + + +/* + * STAT PDU Construction - Add Trailer and Send + * + * Arguments: + * sop pointer to sscop connection control block + * nps received poll sequence number (POLL.N(PS)) + * head pointer to head of buffer chain + * m pointer to current (last) buffer + * + * Returns: + * 0 STAT successfully sent + * else unable to send STAT or truncated STAT was sent - buffer freed + * + */ +static int +sscop_stat_end(sop, nps, head, m) + struct sscop *sop; + sscop_seq nps; + KBuffer *head; + KBuffer *m; +{ + struct stat_pdu *sp; + KBuffer *n; + int err, space, trunc = 0; + + /* + * See if PDU trailer will fit in current buffer + */ + KB_TAILROOM(m, space); + if (space < sizeof(struct stat_pdu)) { + + /* + * Doesn't fit, so get another buffer + */ + KB_ALLOC(n, sizeof(struct stat_pdu), KB_F_NOWAIT, KB_T_DATA); + if (n == NULL) { + /* + * Out of buffers - truncate elements and send + * what we can, but tell caller that we can't + * send any more segments. + */ + trunc = 1; + do { + KB_LEN(m) -= sizeof(sscop_seq); + space += sizeof(sscop_seq); + } while (space < sizeof(struct stat_pdu)); + } else { + /* + * Link in new buffer + */ + KB_LINK(n, m); + KB_LEN(n) = 0; + m = n; + } + } + + /* + * Build PDU trailer + */ + KB_DATAEND(m, sp, struct stat_pdu *); + sp->stat_nps = htonl(nps); + sp->stat_nmr = htonl(sop->so_rcvmax); + sp->stat_nr = htonl(sop->so_rcvnext); + sp->stat_type = PT_STAT; + KB_LEN(m) += sizeof(struct stat_pdu); + + /* + * Finally, send the STAT + */ + STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl, + sop->so_connvc, (int)head, 0, err); + + if (err) { + /* + * We lie about the STACK_CALL failing... + */ + KB_FREEALL(head); + } + + if (trunc) + return (1); + else + return (0); +} + + +/* + * Check for PDU in Receive Queue + * + * A receive queue will be searched for an SD PDU matching the requested + * sequence number. The caller must supply a pointer to the address of the + * PDU in the particular receive queue at which to begin the search. This + * function will update that pointer as it traverses the queue. + * + * Arguments: + * sop pointer to sscop connection control block + * seq sequence number of PDU to locate + * currp address of pointer to PDU in receive queue to start search + * + * Returns: + * 0 reqeusted PDU not in receive queue + * 1 requested PDU located in receive queue + * + */ +static int +sscop_recv_locate(sop, seq, currp) + struct sscop *sop; + sscop_seq seq; + struct pdu_hdr **currp; +{ + sscop_seq cs; + + /* + * Search queue until we know the answer + */ + while (1) { + /* + * If we're at the end of the queue, the PDU isn't there + */ + if (*currp == NULL) + return (0); + + /* + * Get the current PDU sequence number + */ + cs = (*currp)->ph_ns; + + /* + * See if we're at the requested PDU + */ + if (seq == cs) + return (1); + + /* + * If we're past the requested seq number, + * the PDU isn't there + */ + if (SEQ_LT(seq, cs, sop->so_rcvnext)) + return (0); + + /* + * Go to next PDU and keep looking + */ + *currp = (*currp)->ph_recv_lk; + } +} + + +/* + * Build and send STAT PDU + * + * A STAT PDU will be constructed and passed down the protocol stack. + * + * Arguments: + * sop pointer to sscop connection control block + * nps received poll sequence number (POLL.N(PS)) + * + * Returns: + * 0 PDU successfully built and passed down the stack + * else unable to build or send complete pdu + * + */ +int +sscop_send_stat(sop, nps) + struct sscop *sop; + sscop_seq nps; +{ + KBuffer *head, *curr, *n; + struct pdu_hdr *rq = sop->so_recv_hd; + sscop_seq i; + sscop_seq vrh = sop->so_rcvhigh; + sscop_seq vrr = sop->so_rcvnext; + int len = 0; + + /* + * Initialize for start of STAT PDU + */ + head = sscop_stat_init(sop); + if (head == NULL) + return (1); + curr = head; + + /* + * Start with first PDU not yet received + */ + i = vrr; + + /* + * Keep looping until we get to last sent PDU + */ + while (i != vrh) { + + /* + * Find next missing PDU + */ + while (SEQ_LT(i, vrh, vrr) && sscop_recv_locate(sop, i, &rq)) { + SEQ_INCR(i, 1); + } + + /* + * Add odd (start of missing gap) STAT element + */ + n = sscop_stat_add(i, curr); + if (n == NULL) { + goto nobufs; + } + curr = n; + len++; + + /* + * Have we reached the last sent PDU sequence number?? + */ + if (i == vrh) { + /* + * Yes, then we're done, send STAT + */ + break; + } + + /* + * Have we reached the max STAT size yet?? + */ + if (len >= PDU_MAX_ELEM) { + /* + * Yes, send this STAT segment + */ + if (sscop_stat_end(sop, nps, head, curr)) { + return (1); + } + + /* + * Start a new segment + */ + head = sscop_stat_init(sop); + if (head == NULL) + return (1); + curr = head; + + /* + * Restart missing gap + */ + curr = sscop_stat_add(i, curr); + if (curr == NULL) { + KB_FREEALL(head); + return (1); + } + len = 1; + } + + /* + * Now find the end of the missing gap + */ + do { + SEQ_INCR(i, 1); + } while (SEQ_LT(i, vrh, vrr) && + (sscop_recv_locate(sop, i, &rq) == 0)); + + /* + * Add even (start of received gap) STAT element + */ + n = sscop_stat_add(i, curr); + if (n == NULL) { + goto nobufs; + } + curr = n; + len++; + } + + /* + * Finally, send the STAT PDU (or last STAT segment) + */ + if (sscop_stat_end(sop, nps, head, curr)) { + return (1); + } + + return (0); + +nobufs: + /* + * Send a truncated STAT PDU + */ + sscop_stat_end(sop, nps, head, curr); + + return (1); +} + + +/* + * Build and send USTAT PDU + * + * A USTAT PDU will be constructed and passed down the protocol stack. + * + * Arguments: + * sop pointer to sscop connection control block + * ns sequence number for second list element + * + * Returns: + * 0 PDU successfully built and passed down the stack + * else unable to build or send pdu + * + */ +int +sscop_send_ustat(sop, ns) + struct sscop *sop; + sscop_seq ns; +{ + KBuffer *m; + struct ustat_pdu *up; + int err; + + + /* + * Get buffer for PDU + */ + KB_ALLOCPKT(m, sizeof(struct ustat_pdu), KB_F_NOWAIT, KB_T_HEADER); + if (m == NULL) + return (1); + + /* + * Setup buffer controls + */ + KB_HEADSET(m, MIN(sop->so_headout, + KB_BFRLEN(m) - sizeof(struct ustat_pdu))); + KB_LEN(m) = sizeof(struct ustat_pdu); + + /* + * Build PDU + */ + KB_DATASTART(m, up, struct ustat_pdu *); + up->ustat_le1 = htonl(SEQ_VAL(sop->so_rcvhigh)); + up->ustat_le2 = htonl(SEQ_VAL(ns)); + up->ustat_nmr = htonl(SEQ_VAL(sop->so_rcvmax)); + up->ustat_nr = + htonl((PT_USTAT << PT_TYPE_SHIFT) | SEQ_VAL(sop->so_rcvnext)); + + /* + * Send PDU towards peer + */ + STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl, + sop->so_connvc, (int)m, 0, err); + + if (err) + KB_FREEALL(m); + + return (err); +} + + +/* + * Build and send UD PDU + * + * A UD PDU will be constructed and passed down the protocol stack. + * + * Arguments: + * sop pointer to sscop connection control block + * m pointer to user data buffer chain + * + * Returns: + * 0 PDU successfully built and passed down the stack + * else unable to build or send pdu (buffer released) + * + */ +int +sscop_send_ud(sop, m) + struct sscop *sop; + KBuffer *m; +{ + KBuffer *ml, *n; + int len = 0, err; + int pad, trlen, space; + u_char *cp; + + /* + * Count data and get to last buffer in chain + */ + for (ml = m; ; ml = KB_NEXT(ml)) { + len += KB_LEN(ml); + if (KB_NEXT(ml) == NULL) + break; + } + + /* + * Verify data length + */ + if (len > sop->so_parm.sp_maxinfo) { + KB_FREEALL(m); + sscop_abort(sop, "sscop: maximum unitdata size exceeded\n"); + return (1); + } + + /* + * Figure out how much padding we'll need + */ + pad = ((len + (PDU_PAD_ALIGN - 1)) & ~(PDU_PAD_ALIGN - 1)) - len; + trlen = pad + sizeof(struct ud_pdu); + + /* + * Get space for PDU trailer and padding + */ + KB_TAILROOM(ml, space); + if (space < trlen) { + /* + * Allocate & link buffer for pad and trailer + */ + KB_ALLOC(n, trlen, KB_F_NOWAIT, KB_T_HEADER); + if (n == NULL) + return (1); + + KB_LEN(n) = 0; + KB_LINK(n, ml); + ml = n; + } + + /* + * Build the PDU trailer + * + * Since we can't be sure of alignment in the buffers, we + * have to move this a byte at a time. + */ + KB_DATAEND(ml, cp, u_char *); + cp += pad; + *cp++ = (pad << PT_PAD_SHIFT) | PT_UD; + KM_ZERO(cp, 3); + KB_LEN(ml) += trlen; + + /* + * Now pass PDU down the stack + */ + STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl, + sop->so_connvc, (int)m, 0, err); + if (err) { + KB_FREEALL(m); + return (1); + } + + return (0); +} + + +/* + * Print an SSCOP PDU + * + * Arguments: + * sop pointer to sscop connection control block + * m pointer to pdu buffer chain + * msg pointer to message string + * + * Returns: + * none + * + */ +void +sscop_pdu_print(sop, m, msg) + struct sscop *sop; + KBuffer *m; + char *msg; +{ + char buf[128]; + struct vccb *vcp; + + vcp = sop->so_connvc->cvc_vcc; + sprintf(buf, "sscop %s: vcc=(%d,%d)\n", msg, vcp->vc_vpi, vcp->vc_vci); + atm_pdu_print(m, buf); +} + diff --git a/sys/netatm/uni/sscop_pdu.h b/sys/netatm/uni/sscop_pdu.h new file mode 100644 index 0000000..387a602 --- /dev/null +++ b/sys/netatm/uni/sscop_pdu.h @@ -0,0 +1,317 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscop_pdu.h,v 1.3 1997/05/06 22:20:15 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * SSCOP Protocol Data Unit (PDU) definitions + * + */ + +#ifndef _UNI_SSCOP_PDU_H +#define _UNI_SSCOP_PDU_H + +/* + * SSCOP PDU Constants + */ +#define PDU_MIN_LEN 4 /* Minimum PDU length */ +#define PDU_LEN_MASK 3 /* PDU length must be 32-bit aligned */ +#define PDU_ADDR_MASK 3 /* PDUs must be 32-bit aligned */ +#define PDU_SEQ_MASK 0x00ffffff /* Mask for 24-bit sequence values */ +#define PDU_MAX_INFO 65528 /* Maximum length of PDU info field */ +#define PDU_MAX_UU 65524 /* Maximum length of SSCOP-UU field */ +#define PDU_MAX_STAT 65520 /* Maximum length of STAT list */ +#define PDU_MAX_ELEM 67 /* Maximum elements sent in STAT */ +#define PDU_PAD_ALIGN 4 /* I-field padding alignment */ + + +/* + * PDU Queueing Header + * + * There will be a queueing header tacked on to the front of each + * buffer chain that is placed on any of the sscop SD PDU queues (not + * including the SD transmission queue). Note that this header will + * not be included in the buffer data length/offset fields. + */ +struct pdu_hdr { + union { + struct pdu_hdr *phu_pack_lk; /* Pending ack queue link */ + struct pdu_hdr *phu_recv_lk; /* Receive queue link */ + } ph_u; + struct pdu_hdr *ph_rexmit_lk; /* Retranmit queue link */ + sscop_seq ph_ns; /* SD.N(S) - SD's sequence number */ + sscop_seq ph_nps; /* SD.N(PS) - SD's poll sequence */ + KBuffer *ph_buf; /* Pointer to containing buffer */ +}; +#define ph_pack_lk ph_u.phu_pack_lk +#define ph_recv_lk ph_u.phu_recv_lk + + +/* + * SSCOP PDU formats + * + * N.B. - all SSCOP PDUs are trailer oriented (don't ask me...) + */ + +/* + * PDU Type Fields + */ +#define PT_PAD_MASK 0xc0 /* Pad length mask */ +#define PT_PAD_SHIFT 6 /* Pad byte shift count */ +#define PT_SOURCE_SSCOP 0x10 /* Source = SSCOP */ +#define PT_TYPE_MASK 0x0f /* Type mask */ +#define PT_TYPE_MAX 0x0f /* Maximum pdu type */ +#define PT_TYPE_SHIFT 24 /* Type word shift count */ + +#define PT_BGN 0x01 /* Begin */ +#define PT_BGAK 0x02 /* Begin Acknowledge */ +#define PT_BGREJ 0x07 /* Begin Reject */ +#define PT_END 0x03 /* End */ +#define PT_ENDAK 0x04 /* End Acknowledge */ +#define PT_RS 0x05 /* Resynchronization */ +#define PT_RSAK 0x06 /* Resynchronization Acknowledge */ +#define PT_ER 0x09 /* Error Recovery */ +#define PT_ERAK 0x0f /* Error Recovery Acknowledge */ +#define PT_SD 0x08 /* Sequenced Data */ +#define PT_SDP 0x09 /* Sequenced Data with Poll */ +#define PT_POLL 0x0a /* Status Request */ +#define PT_STAT 0x0b /* Solicited Status Response */ +#define PT_USTAT 0x0c /* Unsolicited Status Response */ +#define PT_UD 0x0d /* Unnumbered Data */ +#define PT_MD 0x0e /* Management Data */ + +/* + * Begin PDU + */ +struct bgn_pdu { + u_char bgn_rsvd[3]; /* Reserved */ + u_char bgn_nsq; /* N(SQ) */ + union { + u_char bgnu_type; /* PDU type, etc */ + sscop_seq bgnu_nmr; /* N(MR) */ + } bgn_u; +}; +#define bgn_type bgn_u.bgnu_type +#define bgn_nmr bgn_u.bgnu_nmr + +/* + * Begin Acknowledge PDU + */ +struct bgak_pdu { + int bgak_rsvd; /* Reserved */ + union { + u_char bgaku_type; /* PDU type, etc */ + sscop_seq bgaku_nmr; /* N(MR) */ + } bgak_u; +}; +#define bgak_type bgak_u.bgaku_type +#define bgak_nmr bgak_u.bgaku_nmr + +/* + * Begin Reject PDU + */ +struct bgrej_pdu { + int bgrej_rsvd2; /* Reserved */ + u_char bgrej_type; /* PDU type, etc */ + u_char bgrej_rsvd1[3]; /* Reserved */ +}; + +/* + * End PDU + */ +struct end_pdu { + int end_rsvd2; /* Reserved */ + u_char end_type; /* PDU type, etc */ + u_char end_rsvd1[3]; /* Reserved */ +}; + +/* + * End Acknowledge PDU (Q.2110) + */ +struct endak_q2110_pdu { + int endak_rsvd2; /* Reserved */ + u_char endak_type; /* PDU type, etc */ + u_char endak_rsvd1[3]; /* Reserved */ +}; + +/* + * End Acknowledge PDU (Q.SAAL) + */ +struct endak_qsaal_pdu { + u_char endak_type; /* PDU type, etc */ + u_char endak_rsvd[3]; /* Reserved */ +}; + +/* + * Resynchronization PDU + */ +struct rs_pdu { + char rs_rsvd[3]; /* Reserved */ + u_char rs_nsq; /* N(SQ) */ + union { + u_char rsu_type; /* PDU type, etc */ + sscop_seq rsu_nmr; /* N(MR) */ + } rs_u; +}; +#define rs_type rs_u.rsu_type +#define rs_nmr rs_u.rsu_nmr + +/* + * Resynchronization Acknowledge PDU (Q.2110) + */ +struct rsak_q2110_pdu { + int rsak_rsvd; /* Reserved */ + union { + u_char rsaku_type; /* PDU type, etc */ + sscop_seq rsaku_nmr; /* N(MR) */ + } rsak_u; +}; +#define rsak2_type rsak_u.rsaku_type +#define rsak_nmr rsak_u.rsaku_nmr + +/* + * Resynchronization Acknowledge PDU (Q.SAAL) + */ +struct rsak_qsaal_pdu { + u_char rsaks_type; /* PDU type, etc */ + u_char rsak_rsvd[3]; /* Reserved */ +}; + +/* + * Error Recovery PDU + */ +struct er_pdu { + char er_rsvd[3]; /* Reserved */ + u_char er_nsq; /* N(SQ) */ + union { + u_char eru_type; /* PDU type, etc */ + sscop_seq eru_nmr; /* N(MR) */ + } er_u; +}; +#define er_type er_u.eru_type +#define er_nmr er_u.eru_nmr + +/* + * Error Recovery Acknowledge PDU + */ +struct erak_pdu { + int erak_rsvd; /* Reserved */ + union { + u_char eraku_type; /* PDU type, etc */ + sscop_seq eraku_nmr; /* N(MR) */ + } erak_u; +}; +#define erak_type erak_u.eraku_type +#define erak_nmr erak_u.eraku_nmr + +/* + * Sequenced Data PDU + */ +struct sd_pdu { + union { + u_char sdu_type; /* PDU type, etc */ + sscop_seq sdu_ns; /* N(S) */ + } sd_u; +}; +#define sd_type sd_u.sdu_type +#define sd_ns sd_u.sdu_ns + +/* + * Sequenced Data with Poll PDU + */ +struct sdp_pdu { + sscop_seq sdp_nps; /* N(PS) */ + union { + u_char sdpu_type; /* PDU type, etc */ + sscop_seq sdpu_ns; /* N(S) */ + } sdp_u; +}; +#define sdp_type sdp_u.sdpu_type +#define sdp_ns sdp_u.sdpu_ns + +/* + * Poll PDU + */ +struct poll_pdu { + sscop_seq poll_nps; /* N(PS) */ + union { + u_char pollu_type; /* PDU type, etc */ + sscop_seq pollu_ns; /* N(S) */ + } poll_u; +}; +#define poll_type poll_u.pollu_type +#define poll_ns poll_u.pollu_ns + +/* + * Solicited Status PDU + */ +struct stat_pdu { + sscop_seq stat_nps; /* N(PS) */ + sscop_seq stat_nmr; /* N(MR) */ + union { + u_char statu_type; /* PDU type, etc */ + sscop_seq statu_nr; /* N(R) */ + } stat_u; +}; +#define stat_type stat_u.statu_type +#define stat_nr stat_u.statu_nr + +/* + * Unsolicited Status PDU + */ +struct ustat_pdu { + sscop_seq ustat_le1; /* List element 1 */ + sscop_seq ustat_le2; /* List element 2 */ + sscop_seq ustat_nmr; /* N(MR) */ + union { + u_char ustatu_type; /* PDU type, etc */ + sscop_seq ustatu_nr; /* N(R) */ + } ustat_u; +}; +#define ustat_type ustat_u.ustatu_type +#define ustat_nr ustat_u.ustatu_nr + +/* + * Unit Data PDU + */ +struct ud_pdu { + u_char ud_type; /* PDU type, etc */ + u_char ud_rsvd[3]; /* Reserved */ +}; + +/* + * Management Data PDU + */ +struct md_pdu { + u_char md_type; /* PDU type, etc */ + u_char md_rsvd[3]; /* Reserved */ +}; + +#endif /* _UNI_SSCOP_PDU_H */ diff --git a/sys/netatm/uni/sscop_sigaa.c b/sys/netatm/uni/sscop_sigaa.c new file mode 100644 index 0000000..8f347ce --- /dev/null +++ b/sys/netatm/uni/sscop_sigaa.c @@ -0,0 +1,449 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscop_sigaa.c,v 1.1 1998/04/07 23:15:11 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * SSCOP Common - Process AA-signals (SAP_SSCOP) + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: sscop_sigaa.c,v 1.1 1998/04/07 23:15:11 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscop_misc.h> +#include <netatm/uni/sscop_pdu.h> +#include <netatm/uni/sscop_var.h> + + +/* + * SSCOP_ESTABLISH_REQ / SOS_IDLE Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 pointer to buffer containing SSCOP-UU data + * arg2 buffer release parameter + * + * Returns: + * none + * + */ +void +sscop_estreq_idle(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + + /* + * We don't support SSCOP-UU data + */ + if (arg1 != SSCOP_UU_NULL) + KB_FREEALL((KBuffer *)arg1); + + /* + * We currently only support BR=YES + */ + if (arg2 != SSCOP_BR_YES) { + sscop_abort(sop, "sscop: BR != YES\n"); + return; + } + + /* + * Initialize receiver window + */ + SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin); + + /* + * Send first BGN PDU + */ + sop->so_connctl = 1; + SEQ_INCR(sop->so_sendconn, 1); + (void) sscop_send_bgn(sop, SSCOP_SOURCE_USER); + + /* + * Reset transmitter state + */ + if (sop->so_vers == SSCOP_VERS_Q2110) + q2110_clear_xmit(sop); + else + qsaal1_reset_xmit(sop); + + /* + * Set retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = sop->so_parm.sp_timecc; + + /* + * Wait for BGAK + */ + sop->so_state = SOS_OUTCONN; + + return; +} + + +/* + * SSCOP_ESTABLISH_RSP / SOS_INCONN Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 pointer to buffer containing SSCOP-UU data + * arg2 buffer release parameter + * + * Returns: + * none + * + */ +void +sscop_estrsp_inconn(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + + /* + * We don't support SSCOP-UU data + */ + if (arg1 != SSCOP_UU_NULL) + KB_FREEALL((KBuffer *)arg1); + + /* + * We currently only support BR=YES + */ + if (arg2 != SSCOP_BR_YES) { + sscop_abort(sop, "sscop: BR != YES\n"); + return; + } + + if (sop->so_vers == SSCOP_VERS_Q2110) { + /* + * Clear transmitter buffers + */ + q2110_clear_xmit(sop); + + /* + * Initialize state variables + */ + SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin); + q2110_init_state(sop); + } else { + /* + * Reset transmitter state + */ + qsaal1_reset_xmit(sop); + } + + /* + * Send BGAK PDU + */ + (void) sscop_send_bgak(sop); + + /* + * Start polling timer + */ + sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll; + + /* + * Start lost poll/stat timer + */ + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + + /* + * OK, we're ready for data + */ + sop->so_state = SOS_READY; + + /* + * See if transmit queues need servicing + */ + if (sop->so_flags & SOF_XMITSRVC) + sscop_service_xmit(sop); + + return; +} + + +/* + * SSCOP_RELEASE_REQ / SOS_OUTCONN Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 pointer to buffer containing SSCOP-UU data + * arg2 unused + * + * Returns: + * none + * + */ +void +sscop_relreq_outconn(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + + /* + * We don't support SSCOP-UU data + */ + if (arg1 != SSCOP_UU_NULL) + KB_FREEALL((KBuffer *)arg1); + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Clear reestablishment flag + */ + sop->so_flags &= ~SOF_REESTAB; + + /* + * Send first END PDU + */ + sop->so_connctl = 1; + (void) sscop_send_end(sop, SSCOP_SOURCE_USER); + + if (sop->so_vers == SSCOP_VERS_QSAAL) + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + + /* + * Set retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = sop->so_parm.sp_timecc; + + /* + * Wait for ENDAK + */ + sop->so_state = SOS_OUTDISC; + + return; +} + + +/* + * SSCOP_RELEASE_REQ / SOS_INCONN Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 pointer to buffer containing SSCOP-UU data + * arg2 unused + * + * Returns: + * none + * + */ +void +sscop_relreq_inconn(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + + /* + * We don't support SSCOP-UU data + */ + if (arg1 != SSCOP_UU_NULL) + KB_FREEALL((KBuffer *)arg1); + + /* + * Return a BGREJ PDU + */ + (void) sscop_send_bgrej(sop); + + /* + * Back to IDLE state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * SSCOP_RELEASE_REQ / SOS_READY Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 pointer to buffer containing SSCOP-UU data + * arg2 unused + * + * Returns: + * none + * + */ +void +sscop_relreq_ready(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + + /* + * We don't support SSCOP-UU data + */ + if (arg1 != SSCOP_UU_NULL) + KB_FREEALL((KBuffer *)arg1); + + /* + * Stop data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_timer[SSCOP_T_NORESP] = 0; + sop->so_timer[SSCOP_T_IDLE] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Send first END PDU + */ + sop->so_connctl = 1; + (void) sscop_send_end(sop, SSCOP_SOURCE_USER); + + if (sop->so_vers == SSCOP_VERS_Q2110) { + /* + * Clear out appropriate queues + */ + if (sop->so_state == SOS_READY) + q2110_prep_retrieve(sop); + else + sscop_rcvr_drain(sop); + } else { + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + } + + /* + * Set retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = sop->so_parm.sp_timecc; + + /* + * Wait for ENDAK + */ + sop->so_state = SOS_OUTDISC; + + return; +} + + +/* + * SSCOP_DATA_REQ / SOS_READY Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 pointer to buffer containing assured user data + * arg2 unused + * + * Returns: + * none + * + */ +void +sscop_datreq_ready(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + KBuffer *m = (KBuffer *)arg1; + + /* + * We must have a buffer (even if it contains no data) + */ + if (m == NULL) { + sscop_abort(sop, "sscop_datreq_ready: no buffer\n"); + return; + } + + /* + * Place data at end of transmission queue + */ + KB_QNEXT(m) = NULL; + if (sop->so_xmit_hd == NULL) + sop->so_xmit_hd = m; + else + KB_QNEXT(sop->so_xmit_tl) = m; + sop->so_xmit_tl = m; + + /* + * Service the transmit queues + */ + sscop_service_xmit(sop); + + return; +} + + +/* + * SSCOP_UNITDATA_REQ / SOS_* Command Processor + * + * Arguments: + * sop pointer to sscop connection block + * arg1 pointer to buffer containing unassured user data + * arg2 unused + * + * Returns: + * none + * + */ +void +sscop_udtreq_all(sop, arg1, arg2) + struct sscop *sop; + int arg1; + int arg2; +{ + KBuffer *m = (KBuffer *)arg1; + + /* + * We must have a buffer (even if it contains no data) + */ + if (m == NULL) { + sscop_abort(sop, "sscop_udtreq_all: no buffer\n"); + return; + } + + /* + * Send the data in a UD PDU + */ + (void) sscop_send_ud(sop, m); + + return; +} + diff --git a/sys/netatm/uni/sscop_sigcpcs.c b/sys/netatm/uni/sscop_sigcpcs.c new file mode 100644 index 0000000..a9bf504 --- /dev/null +++ b/sys/netatm/uni/sscop_sigcpcs.c @@ -0,0 +1,2311 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscop_sigcpcs.c,v 1.2 1998/07/24 20:18:09 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * SSCOP Common - Process CPCS-signals (SSCOP PDUs) + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: sscop_sigcpcs.c,v 1.2 1998/07/24 20:18:09 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscop_misc.h> +#include <netatm/uni/sscop_pdu.h> +#include <netatm/uni/sscop_var.h> + + +/* + * No-op Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_noop(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + /* + * Just free PDU + */ + KB_FREEALL(m); + + return; +} + + +/* + * BGN PDU / SOS_IDLE Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_bgn_idle(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct bgn_pdu *bp = (struct bgn_pdu *)trlr; + int err, source; + + if (sop->so_vers == SSCOP_VERS_Q2110) { + /* + * "Power-up Robustness" option + * + * Accept BGN regardless of BGN.N(SQ) + */ + sop->so_rcvconn = bp->bgn_nsq; + + } else { + /* + * If retransmitted BGN, reject it + */ + if (sscop_is_rexmit(sop, bp->bgn_nsq)) { + KB_FREEALL(m); + (void) sscop_send_bgrej(sop); + return; + } + } + + if (sop->so_vers == SSCOP_VERS_QSAAL) { + /* + * Get Source value + */ + if (bp->bgn_type & PT_SOURCE_SSCOP) + source = SSCOP_SOURCE_SSCOP; + else + source = SSCOP_SOURCE_USER; + + /* + * Reset receiver state variables + */ + qsaal1_reset_rcvr(sop); + } else + source = 0; + + /* + * Set initial transmit window + */ + SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr)); + + /* + * Pass connection request up to user + */ + STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, source, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Wait for user's response + */ + sop->so_state = SOS_INCONN; + + return; +} + + +/* + * BGN PDU / SOS_OUTDISC Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_bgn_outdisc(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct bgn_pdu *bp = (struct bgn_pdu *)trlr; + int err, source; + + /* + * If retransmitted BGN, ACK it and send new END + */ + if (sscop_is_rexmit(sop, bp->bgn_nsq)) { + KB_FREEALL(m); + (void) sscop_send_bgak(sop); + (void) sscop_send_end(sop, SSCOP_SOURCE_LAST); + return; + } + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Initialize transmit window + */ + SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr)); + + /* + * Notify user of connection termination + */ + STACK_CALL(SSCOP_RELEASE_CNF, sop->so_upper, sop->so_toku, + sop->so_connvc, 0, 0, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + if (sop->so_vers == SSCOP_VERS_QSAAL) { + /* + * Get Source value + */ + if (bp->bgn_type & PT_SOURCE_SSCOP) + source = SSCOP_SOURCE_SSCOP; + else + source = SSCOP_SOURCE_USER; + + /* + * Reset receiver variables + */ + qsaal1_reset_rcvr(sop); + + } else + source = 0; + + /* + * Tell user about incoming connection + */ + STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, source, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Wait for user's response + */ + sop->so_state = SOS_INCONN; + + return; +} + + +/* + * BGN PDU / SOS_OUTRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_bgn_outresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct bgn_pdu *bp = (struct bgn_pdu *)trlr; + int err, source; + + /* + * If retransmitted BGN, ACK it and send new RS + */ + if (sscop_is_rexmit(sop, bp->bgn_nsq)) { + KB_FREEALL(m); + (void) sscop_send_bgak(sop); + (void) sscop_send_rs(sop); + return; + } + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Initialize transmit window + */ + SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr)); + + if (sop->so_vers == SSCOP_VERS_QSAAL) { + /* + * Get (possible) Source value + */ + if (bp->bgn_type & PT_SOURCE_SSCOP) + source = SSCOP_SOURCE_SSCOP; + else + source = SSCOP_SOURCE_USER; + + /* + * Reset receiver variables + */ + qsaal1_reset_rcvr(sop); + + } else + source = SSCOP_SOURCE_USER; + + /* + * Notify user of connection termination + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, source, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Now tell user of a "new" incoming connection + */ + STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, source, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Wait for user's response + */ + sop->so_state = SOS_INCONN; + + return; +} + + +/* + * BGN PDU / SOS_INRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_bgn_inresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct bgn_pdu *bp = (struct bgn_pdu *)trlr; + int err, source; + + /* + * If retransmitted BGN, oops + */ + if (sscop_is_rexmit(sop, bp->bgn_nsq)) { + KB_FREEALL(m); + sscop_maa_error(sop, 'B'); + return; + } + + /* + * Stop data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_timer[SSCOP_T_NORESP] = 0; + sop->so_timer[SSCOP_T_IDLE] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Initialize transmit window + */ + SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr)); + + if (sop->so_vers == SSCOP_VERS_QSAAL) { + /* + * Get (possible) Source value + */ + if (bp->bgn_type & PT_SOURCE_SSCOP) + source = SSCOP_SOURCE_SSCOP; + else + source = SSCOP_SOURCE_USER; + + /* + * Reset receiver variables + */ + qsaal1_reset_rcvr(sop); + + } else { + /* + * Stop possible retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Drain receiver queues + */ + sscop_rcvr_drain(sop); + + /* + * Tell user current connection has been released + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_USER, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + source = 0; + } + + /* + * Tell user of incoming connection + */ + STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, source, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Wait for user's response + */ + sop->so_state = SOS_INCONN; + + return; +} + + +/* + * BGAK PDU / Protocol Error + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_bgak_error(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Record error condition + */ + sscop_maa_error(sop, 'C'); + KB_FREEALL(m); + + return; +} + + +/* + * BGAK PDU / SOS_IDLE Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_bgak_idle(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Record error condition + */ + sscop_bgak_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + return; +} + + +/* + * BGAK PDU / SOS_OUTCONN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_bgak_outconn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct bgak_pdu *bp = (struct bgak_pdu *)trlr; + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Initialize transmit window + */ + SEQ_SET(sop->so_sendmax, ntohl(bp->bgak_nmr)); + + /* + * Notify user of connection establishment + */ + if (sop->so_flags & SOF_REESTAB) { + KB_FREEALL(m); + STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + sop->so_flags &= ~SOF_REESTAB; + } else { + STACK_CALL(SSCOP_ESTABLISH_CNF, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, 0, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + } + + if (sop->so_vers == SSCOP_VERS_QSAAL) { + /* + * Reset receiver variables + */ + qsaal1_reset_rcvr(sop); + + /* + * Start polling timer + */ + sscop_set_poll(sop); + + /* + * Start lost poll/stat timer + */ + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + + } else { + /* + * Initialize state variables + */ + q2110_init_state(sop); + + /* + * Start data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll; + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + } + + /* + * OK, we're ready for data + */ + sop->so_state = SOS_READY; + + /* + * See if transmit queues need servicing + */ + if (sop->so_flags & SOF_XMITSRVC) + sscop_service_xmit(sop); + + return; +} + + +/* + * BGREJ PDU / Protocol Error + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_bgrej_error(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Record error condition + */ + sscop_maa_error(sop, 'D'); + KB_FREEALL(m); + return; +} + + +/* + * BGREJ PDU / SOS_OUTCONN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_bgrej_outconn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int source, uu, err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + if (sop->so_vers == SSCOP_VERS_QSAAL) { + /* + * Clear reestablishment flag + */ + sop->so_flags &= ~SOF_REESTAB; + + KB_FREEALL(m); + m = NULL; + uu = SSCOP_UU_NULL; + source = SSCOP_SOURCE_SSCOP; + } else { + uu = (int)m; + source = SSCOP_SOURCE_USER; + } + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, uu, source, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * BGREJ PDU / SOS_INCONN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_bgrej_inconn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Report protocol error + */ + sscop_bgrej_error(sop, m, trlr); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * BGREJ PDU / SOS_OUTRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_bgrej_outresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Report protocol error + */ + sscop_bgrej_error(sop, m, trlr); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + if (sop->so_vers == SSCOP_VERS_QSAAL) { + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + } + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * BGREJ PDU / SOS_READY Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_bgrej_ready(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_timer[SSCOP_T_NORESP] = 0; + sop->so_timer[SSCOP_T_IDLE] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Report protocol error + */ + sscop_bgrej_error(sop, m, trlr); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + if (sop->so_vers == SSCOP_VERS_QSAAL) { + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + } else { + /* + * Clear out appropriate queues + */ + q2110_prep_retrieve(sop); + } + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * END PDU / SOS_IDLE Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_end_idle(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Free buffers + */ + KB_FREEALL(m); + + /* + * Return an ENDAK to peer + */ + (void) sscop_send_endak(sop); + + return; +} + + +/* + * END PDU / SOS_INCONN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_end_inconn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct end_pdu *ep = (struct end_pdu *)trlr; + int err, source; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Acknowledge END + */ + (void) sscop_send_endak(sop); + + /* + * Get Source value + */ + if (ep->end_type & PT_SOURCE_SSCOP) + source = SSCOP_SOURCE_SSCOP; + else + source = SSCOP_SOURCE_USER; + + /* + * Notify user of connection termination + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, source, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * END PDU / SOS_OUTDISC Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_end_outdisc(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Release buffers + */ + KB_FREEALL(m); + + /* + * Acknowledge END + */ + (void) sscop_send_endak(sop); + + /* + * Notify user of connection termination + */ + STACK_CALL(SSCOP_RELEASE_CNF, sop->so_upper, sop->so_toku, + sop->so_connvc, 0, 0, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * ENDAK PDU / Protocol Error + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_endak_error(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Record error condition + */ + sscop_maa_error(sop, 'F'); + KB_FREEALL(m); + + return; +} + + +/* + * ENDAK PDU / SOS_INCONN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_endak_inconn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Report protocol error + */ + sscop_endak_error(sop, m, trlr); + + /* + * Notify user of connection termination + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * ENDAK PDU / SOS_OUTDISC Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_endak_outdisc(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Release buffers + */ + KB_FREEALL(m); + + /* + * Notify user of connection termination + */ + STACK_CALL(SSCOP_RELEASE_CNF, sop->so_upper, sop->so_toku, + sop->so_connvc, 0, 0, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * ENDAK PDU / SOS_READY Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_endak_ready(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Stop data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_timer[SSCOP_T_NORESP] = 0; + sop->so_timer[SSCOP_T_IDLE] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Report protocol error + */ + sscop_endak_error(sop, m, trlr); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + if (sop->so_vers == SSCOP_VERS_QSAAL) { + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + } else { + /* + * Clear out appropriate queues + */ + q2110_prep_retrieve(sop); + } + + /* + * Back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * RS PDU / Protocol Error + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_rs_error(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Record error condition + */ + sscop_maa_error(sop, 'J'); + KB_FREEALL(m); + + return; +} + + +/* + * RS PDU / SOS_IDLE Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_rs_idle(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Report error condition + */ + sscop_rs_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + return; +} + + +/* + * RSAK PDU / Protocol Error + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_rsak_error(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Record error condition + */ + sscop_maa_error(sop, 'K'); + KB_FREEALL(m); + + return; +} + + +/* + * RSAK PDU / SOS_IDLE Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_rsak_idle(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Report error condition + */ + sscop_rsak_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + return; +} + + +/* + * RSAK PDU / SOS_OUTRESYN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_rsak_outresyn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct rsak_q2110_pdu *rp = (struct rsak_q2110_pdu *)trlr; + int err; + + /* + * Stop retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = 0; + + /* + * Notify user of resynchronization completion + */ + STACK_CALL(SSCOP_RESYNC_CNF, sop->so_upper, sop->so_toku, + sop->so_connvc, 0, 0, err); + if (err) { + KB_FREEALL(m); + sscop_abort(sop, "stack memory\n"); + return; + } + + if (sop->so_vers == SSCOP_VERS_QSAAL) { + /* + * Start the polling timer + */ + sscop_set_poll(sop); + + /* + * Start lost poll/stat timer + */ + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + } else { + /* + * Initialize state variables + */ + SEQ_SET(sop->so_sendmax, ntohl(rp->rsak_nmr)); + q2110_init_state(sop); + + /* + * Start data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll; + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + } + + /* + * Free buffers + */ + KB_FREEALL(m); + + /* + * Now go back to data transfer state + */ + sop->so_state = SOS_READY; + + /* + * See if transmit queues need servicing + */ + if (sop->so_flags & SOF_XMITSRVC) + sscop_service_xmit(sop); + + return; +} + + +/* + * SD PDU / Protocol Error + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_sd_error(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Record error condition + */ + sscop_maa_error(sop, 'A'); + KB_FREEALL(m); + + return; +} + + +/* + * SD PDU / SOS_IDLE Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_sd_idle(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Record error condition + */ + sscop_sd_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + return; +} + + +/* + * SD PDU / SOS_INCONN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_sd_inconn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Record error condition + */ + sscop_sd_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Go back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * POLL PDU / Protocol Error + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_poll_error(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Record error condition + */ + sscop_maa_error(sop, 'G'); + KB_FREEALL(m); + + return; +} + + +/* + * POLL PDU / SOS_IDLE Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_poll_idle(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Report error condition + */ + sscop_poll_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + return; +} + + +/* + * POLL PDU / SOS_INCONN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_poll_inconn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Record error condition + */ + sscop_poll_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Go back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * STAT PDU / Protocol Error + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_stat_error(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Record error condition + */ + sscop_maa_error(sop, 'H'); + KB_FREEALL(m); + + return; +} + + +/* + * STAT PDU / SOS_IDLE Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_stat_idle(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Report error condition + */ + sscop_stat_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + return; +} + + +/* + * STAT PDU / SOS_INCONN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_stat_inconn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Record error condition + */ + sscop_stat_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Go back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * STAT PDU / SOS_READY Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_stat_ready(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct stat_pdu *sp = (struct stat_pdu *)trlr; + struct pdu_hdr *php; + KBuffer *m0 = m; + sscop_seq seq1, seq2, opa; + int cnt = 0; + + NTOHL(sp->stat_nps); + NTOHL(sp->stat_nmr); + NTOHL(sp->stat_nr); + + /* + * Validate peer's received poll sequence number + */ + if (SEQ_GT(sop->so_pollack, sp->stat_nps, sop->so_pollack) || + SEQ_GT(sp->stat_nps, sop->so_pollsend, sop->so_pollack)) { + /* + * Bad poll sequence number + */ + sscop_maa_error(sop, 'R'); + goto goterr; + } + + /* + * Validate peer's current receive data sequence number + */ + if (SEQ_GT(sop->so_ack, sp->stat_nr, sop->so_ack) || + SEQ_GT(sp->stat_nr, sop->so_send, sop->so_ack)) { + /* + * Bad data sequence number + */ + sscop_maa_error(sop, 'S'); + goto goterr; + } + + /* + * Free acknowledged PDUs + */ + for (seq1 = sop->so_ack, SEQ_SET(seq2, sp->stat_nr); + SEQ_LT(seq1, seq2, sop->so_ack); + SEQ_INCR(seq1, 1)) { + sscop_pack_free(sop, seq1); + } + + /* + * Update transmit state variables + */ + opa = sop->so_pollack; + sop->so_ack = seq2; + SEQ_SET(sop->so_pollack, sp->stat_nps); + SEQ_SET(sop->so_sendmax, sp->stat_nmr); + + /* + * Get first element in STAT list + */ + while (m && (KB_LEN(m) == 0)) + m = KB_NEXT(m); + if (m == NULL) + goto done; + m = sscop_stat_getelem(m, &seq1); + + /* + * Make sure there's a second element too + */ + if (m == NULL) + goto done; + + /* + * Validate first element (start of missing pdus) + */ + if (SEQ_GT(sop->so_ack, seq1, sop->so_ack) || + SEQ_GEQ(seq1, sop->so_send, sop->so_ack)) { + /* + * Bad element sequence number + */ + sscop_maa_error(sop, 'S'); + goto goterr; + } + + /* + * Loop thru all STAT elements in list + */ + while (m) { + /* + * Get next even element (start of received pdus) + */ + m = sscop_stat_getelem(m, &seq2); + + /* + * Validate seqence number + */ + if (SEQ_GEQ(seq1, seq2, sop->so_ack) || + SEQ_GT(seq2, sop->so_send, sop->so_ack)) { + /* + * Bad element sequence number + */ + sscop_maa_error(sop, 'S'); + goto goterr; + } + + /* + * Process each missing sequence number in this gap + */ + while (SEQ_LT(seq1, seq2, sop->so_ack)) { + /* + * Find corresponding SD PDU on pending ack queue + */ + php = sscop_pack_locate(sop, seq1); + if (php == NULL) { + sscop_maa_error(sop, 'S'); + goto goterr; + } + + /* + * Retransmit this SD PDU only if it was last sent + * during an earlier poll sequence and it's not + * already scheduled for retranmission. + */ + if (SEQ_LT(php->ph_nps, sp->stat_nps, opa) && + (php->ph_rexmit_lk == NULL) && + (sop->so_rexmit_tl != php)) { + /* + * Put PDU on retransmit queue and schedule + * transmit servicing + */ + sscop_rexmit_insert(sop, php); + sop->so_flags |= SOF_XMITSRVC; + cnt++; + } + + /* + * Bump to next sequence number + */ + SEQ_INCR(seq1, 1); + } + + /* + * Now process series of acknowledged PDUs + * + * Get next odd element (start of missing pdus), + * but make sure there is one and that it's valid + */ + if (m == NULL) + goto done; + m = sscop_stat_getelem(m, &seq2); + if (SEQ_GEQ(seq1, seq2, sop->so_ack) || + SEQ_GT(seq2, sop->so_send, sop->so_ack)) { + /* + * Bad element sequence number + */ + sscop_maa_error(sop, 'S'); + goto goterr; + } + + /* + * Process each acked sequence number + */ + while (SEQ_LT(seq1, seq2, sop->so_ack)) { + /* + * Can we clear transmit buffers ?? + */ + if ((sop->so_flags & SOF_NOCLRBUF) == 0) { + /* + * Yes, free acked buffers + */ + sscop_pack_free(sop, seq1); + } + + /* + * Bump to next sequence number + */ + SEQ_INCR(seq1, 1); + } + } + +done: + /* + * Free PDU buffer chain + */ + KB_FREEALL(m0); + + /* + * Report retransmitted PDUs + */ + if (cnt) + sscop_maa_error(sop, 'V'); + + /* + * Record transmit window closed transitions + */ + if (SEQ_LT(sop->so_send, sop->so_sendmax, sop->so_ack)) { + if (sop->so_flags & SOF_NOCREDIT) { + sop->so_flags &= ~SOF_NOCREDIT; + sscop_maa_error(sop, 'X'); + } + } else { + if ((sop->so_flags & SOF_NOCREDIT) == 0) { + sop->so_flags |= SOF_NOCREDIT; + sscop_maa_error(sop, 'W'); + } + } + + if (sop->so_vers == SSCOP_VERS_QSAAL) + /* + * Restart lost poll/stat timer + */ + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + else { + /* + * Determine new polling phase + */ + if ((sop->so_timer[SSCOP_T_POLL] != 0) && + ((sop->so_flags & SOF_KEEPALIVE) == 0)) { + /* + * Remain in active phase - reset NO-RESPONSE timer + */ + sop->so_timer[SSCOP_T_NORESP] = + sop->so_parm.sp_timeresp; + + } else if (sop->so_timer[SSCOP_T_IDLE] == 0) { + /* + * Go from transient to idle phase + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + sop->so_timer[SSCOP_T_NORESP] = 0; + sop->so_timer[SSCOP_T_IDLE] = sop->so_parm.sp_timeidle; + } + } + + /* + * See if transmit queues need servicing + */ + if (sop->so_flags & SOF_XMITSRVC) + sscop_service_xmit(sop); + + return; + +goterr: + /* + * Protocol/parameter error encountered + */ + + /* + * Free PDU buffer chain + */ + KB_FREEALL(m0); + + if (sop->so_vers == SSCOP_VERS_QSAAL) + /* + * Reestablish a new connection + */ + qsaal1_reestablish(sop); + else + /* + * Initiate error recovery + */ + q2110_error_recovery(sop); + + return; +} + + +/* + * USTAT PDU / Protocol Error + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_ustat_error(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Record error condition + */ + sscop_maa_error(sop, 'I'); + KB_FREEALL(m); + + return; +} + + +/* + * USTAT PDU / SOS_IDLE Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_ustat_idle(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * Report error condition + */ + sscop_ustat_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + return; +} + + +/* + * USTAT PDU / SOS_INCONN Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_ustat_inconn(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Record error condition + */ + sscop_ustat_error(sop, m, trlr); + + /* + * Return an END to peer + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + /* + * Notify user of connection failure + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + sscop_abort(sop, "stack memory\n"); + return; + } + + /* + * Go back to idle state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * USTAT PDU / SOS_READY Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_ustat_ready(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + struct ustat_pdu *up = (struct ustat_pdu *)trlr; + struct pdu_hdr *php; + sscop_seq seq1, seq2; + + NTOHL(up->ustat_nmr); + NTOHL(up->ustat_nr); + + /* + * Validate peer's current receive data sequence number + */ + if (SEQ_GT(sop->so_ack, up->ustat_nr, sop->so_ack) || + SEQ_GEQ(up->ustat_nr, sop->so_send, sop->so_ack)) { + /* + * Bad data sequence number + */ + goto goterr; + } + + /* + * Free acknowledged PDUs + */ + for (seq1 = sop->so_ack, SEQ_SET(seq2, up->ustat_nr); + SEQ_LT(seq1, seq2, sop->so_ack); + SEQ_INCR(seq1, 1)) { + sscop_pack_free(sop, seq1); + } + + /* + * Update transmit state variables + */ + sop->so_ack = seq2; + SEQ_SET(sop->so_sendmax, up->ustat_nmr); + + /* + * Get USTAT list elements + */ + SEQ_SET(seq1, ntohl(up->ustat_le1)); + SEQ_SET(seq2, ntohl(up->ustat_le2)); + + /* + * Validate elements + */ + if (SEQ_GT(sop->so_ack, seq1, sop->so_ack) || + SEQ_GEQ(seq1, seq2, sop->so_ack) || + SEQ_GEQ(seq2, sop->so_send, sop->so_ack)) { + /* + * Bad element sequence number + */ + goto goterr; + } + + /* + * Process each missing sequence number in this gap + */ + while (SEQ_LT(seq1, seq2, sop->so_ack)) { + /* + * Find corresponding SD PDU on pending ack queue + */ + php = sscop_pack_locate(sop, seq1); + if (php == NULL) { + goto goterr; + } + + /* + * Retransmit this SD PDU if it's not + * already scheduled for retranmission. + */ + if ((php->ph_rexmit_lk == NULL) && + (sop->so_rexmit_tl != php)) { + /* + * Put PDU on retransmit queue and schedule + * transmit servicing + */ + sscop_rexmit_insert(sop, php); + sop->so_flags |= SOF_XMITSRVC; + } + + /* + * Bump to next sequence number + */ + SEQ_INCR(seq1, 1); + } + + /* + * Report retransmitted PDUs + */ + sscop_maa_error(sop, 'V'); + + /* + * Free PDU buffer chain + */ + KB_FREEALL(m); + + /* + * See if transmit queues need servicing + */ + if (sop->so_flags & SOF_XMITSRVC) + sscop_service_xmit(sop); + + return; + +goterr: + /* + * Protocol/parameter error encountered + */ + sscop_maa_error(sop, 'T'); + + /* + * Free PDU buffer chain + */ + KB_FREEALL(m); + + if (sop->so_vers == SSCOP_VERS_QSAAL) + /* + * Reestablish a new connection + */ + qsaal1_reestablish(sop); + else + /* + * Initiate error recovery + */ + q2110_error_recovery(sop); + + return; +} + + +/* + * UD PDU / SOS_* Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_ud_all(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + int err; + + /* + * Pass data up to user + */ + STACK_CALL(SSCOP_UNITDATA_IND, sop->so_upper, sop->so_toku, + sop->so_connvc, (int)m, 0, err); + if (err) + KB_FREEALL(m); + return; +} + + +/* + * MD PDU / SOS_* Processor + * + * Arguments: + * sop pointer to sscop connection block + * m pointer to PDU buffer (without trailer) + * trlr pointer to PDU trailer + * + * Returns: + * none + * + */ +void +sscop_md_all(sop, m, trlr) + struct sscop *sop; + KBuffer *m; + caddr_t trlr; +{ + + /* + * We don't support MD PDUs + */ + KB_FREEALL(m); + return; +} + diff --git a/sys/netatm/uni/sscop_subr.c b/sys/netatm/uni/sscop_subr.c new file mode 100644 index 0000000..2d01229 --- /dev/null +++ b/sys/netatm/uni/sscop_subr.c @@ -0,0 +1,972 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscop_subr.c,v 1.7 1998/08/26 23:29:19 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * SSCOP - Subroutines + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: sscop_subr.c,v 1.7 1998/08/26 23:29:19 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscop_misc.h> +#include <netatm/uni/sscop_pdu.h> +#include <netatm/uni/sscop_var.h> + + +/* + * Local functions + */ +static int sscop_proc_xmit __P((struct sscop *)); + + +/* + * Get Next Element from STAT PDU + * + * Arguments: + * m pointer to current buffer in STAT PDU + * pelem pointer to location to store element value + * + * Returns: + * addr pointer to updated current buffer in STAT PDU + * + */ +KBuffer * +sscop_stat_getelem(m, pelem) + KBuffer *m; + sscop_seq *pelem; +{ + caddr_t cp; + + /* + * Get to start of element + * + * Note that we always ensure that the current buffer has + * at least one byte of the next element. + */ + KB_DATASTART(m, cp, caddr_t); + + /* + * See how much of element is in this buffer + */ + if (KB_LEN(m) >= sizeof(sscop_seq)) { + /* + * Get element from this buffer + */ + if ((int)cp & (sizeof(sscop_seq) - 1)) + KM_COPY(cp, (caddr_t)pelem, sizeof(sscop_seq)); + else + *pelem = *(sscop_seq *)cp; + + /* + * Update buffer controls + */ + KB_HEADADJ(m, -sizeof(sscop_seq)); + } else { + /* + * Get element split between two buffers + */ + int i, j; + + /* + * Copy what's in this buffer + */ + i = KB_LEN(m); + KM_COPY(cp, (caddr_t)pelem, i); + KB_LEN(m) = 0; + + /* + * Now get to next buffer + */ + while (m && (KB_LEN(m) == 0)) + m = KB_NEXT(m); + + /* + * And copy remainder of element + */ + j = sizeof(sscop_seq) - i; + KB_DATASTART(m, cp, caddr_t); + KM_COPY(cp, (caddr_t)pelem + i, j); + + /* + * Update buffer controls + */ + KB_HEADADJ(m, -j); + } + + /* + * Put element (sequence number) into host order + */ + NTOHL(*pelem); + + /* + * Get pointers set for next call + */ + while (m && (KB_LEN(m) == 0)) + m = KB_NEXT(m); + + return (m); +} + + +/* + * Locate SD PDU on Pending Ack Queue + * + * Arguments: + * sop pointer to sscop connection block + * seq sequence number of PDU to locate + * + * Returns: + * addr pointer to located PDU header + * 0 SD PDU sequence number not found + * + */ +struct pdu_hdr * +sscop_pack_locate(sop, seq) + struct sscop *sop; + sscop_seq seq; +{ + struct pdu_hdr *php; + + /* + * Loop thru queue until we either find the PDU or the queue's + * sequence numbers are greater than the PDU's sequence number, + * indicating that the PDU is not on the queue. + */ + for (php = sop->so_pack_hd; php; php = php->ph_pack_lk) { + if (php->ph_ns == seq) + break; + + if (SEQ_GT(php->ph_ns, seq, sop->so_ack)) { + php = NULL; + break; + } + } + + return (php); +} + + +/* + * Free Acknowledged SD PDU + * + * Arguments: + * sop pointer to sscop connection block + * seq sequence number of PDU to free + * + * Returns: + * none + * + */ +void +sscop_pack_free(sop, seq) + struct sscop *sop; + sscop_seq seq; +{ + struct pdu_hdr *php, *prev; + + /* + * Unlink PDU from pending ack queue + * + * First, check for an empty queue + */ + php = sop->so_pack_hd; + if (php == NULL) + return; + + /* + * Now check for PDU at head of queue + */ + if (php->ph_ns == seq) { + if ((sop->so_pack_hd = php->ph_pack_lk) == NULL) + sop->so_pack_tl = NULL; + goto found; + } + + /* + * Otherwise, loop thru queue until we either find the PDU or + * the queue's sequence numbers are greater than the PDU's + * sequence number, indicating that the PDU is not on the queue. + */ + prev = php; + php = php->ph_pack_lk; + while (php) { + if (php->ph_ns == seq) { + if ((prev->ph_pack_lk = php->ph_pack_lk) == NULL) + sop->so_pack_tl = prev; + goto found; + } + + if (SEQ_GT(php->ph_ns, seq, sop->so_ack)) + return; + + prev = php; + php = php->ph_pack_lk; + } + + return; + +found: + /* + * We've got the ack'ed PDU - unlink it from retransmit queue + */ + sscop_rexmit_unlink(sop, php); + + /* + * Free PDU buffers + */ + KB_FREEALL(php->ph_buf); + + return; +} + + +/* + * Insert SD PDU into Retransmit Queue + * + * Arguments: + * sop pointer to sscop connection block + * php pointer to SD PDU header + * + * Returns: + * none + * + */ +void +sscop_rexmit_insert(sop, php) + struct sscop *sop; + struct pdu_hdr *php; +{ + struct pdu_hdr *curr, *next; + sscop_seq seq = php->ph_ns; + + /* + * Check for an empty queue + */ + if ((curr = sop->so_rexmit_hd) == NULL) { + php->ph_rexmit_lk = NULL; + sop->so_rexmit_hd = php; + sop->so_rexmit_tl = php; + return; + } + + /* + * Now see if PDU belongs at head of queue + */ + if (SEQ_LT(seq, curr->ph_ns, sop->so_ack)) { + php->ph_rexmit_lk = curr; + sop->so_rexmit_hd = php; + return; + } + + /* + * Otherwise, loop thru the queue until we find the + * proper insertion point for the PDU + */ + while (next = curr->ph_rexmit_lk) { + if (SEQ_LT(seq, next->ph_ns, sop->so_ack)) { + php->ph_rexmit_lk = next; + curr->ph_rexmit_lk = php; + return; + } + curr = next; + } + + /* + * Insert PDU at end of queue + */ + php->ph_rexmit_lk = NULL; + curr->ph_rexmit_lk = php; + sop->so_rexmit_tl = php; + + return; +} + + +/* + * Unlink SD PDU from Retransmit Queue + * + * Arguments: + * sop pointer to sscop connection block + * php pointer to PDU header to unlink + * + * Returns: + * none + * + */ +void +sscop_rexmit_unlink(sop, php) + struct sscop *sop; + struct pdu_hdr *php; +{ + struct pdu_hdr *curr; + + /* + * See if PDU is on retransmit queue + */ + if ((php->ph_rexmit_lk == NULL) && (sop->so_rexmit_tl != php)) + return; + + /* + * It's here somewhere, so first check for the PDU at the + * head of the queue + */ + if (php == sop->so_rexmit_hd) { + if ((sop->so_rexmit_hd = php->ph_rexmit_lk) == NULL) + sop->so_rexmit_tl = NULL; + php->ph_rexmit_lk = NULL; + return; + } + + /* + * Otherwise, loop thru the queue until we find the PDU + */ + for (curr = sop->so_rexmit_hd; curr; curr = curr->ph_rexmit_lk) { + if (curr->ph_rexmit_lk == php) + break; + } + if (curr) { + if ((curr->ph_rexmit_lk = php->ph_rexmit_lk) == NULL) + sop->so_rexmit_tl = curr; + } else { + log(LOG_ERR, + "sscop_rexmit_unlink: Not found - sop=0x%x, php=0x%x\n", + (int)sop, (int)php); +#ifdef DIAGNOSTIC + panic("sscop_rexmit_unlink: Not found"); +#endif + } + php->ph_rexmit_lk = NULL; + + return; +} + + +/* + * Drain Transmission Queues + * + * Arguments: + * sop pointer to sscop connection block + * + * Returns: + * none + * + */ +void +sscop_xmit_drain(sop) + struct sscop *sop; +{ + KBuffer *m; + struct pdu_hdr *php; + + /* + * Free transmission queue buffers + */ + while (m = sop->so_xmit_hd) { + sop->so_xmit_hd = KB_QNEXT(m); + KB_FREEALL(m); + } + sop->so_xmit_tl = NULL; + + /* + * Free retransmission queue + * + * All retranmission buffers are also on the pending ack + * queue (but not the converse), so we just clear the queue + * pointers here and do all the real work below. + */ + sop->so_rexmit_hd = NULL; + sop->so_rexmit_tl = NULL; + + /* + * Free pending ack queue buffers + */ + while (php = sop->so_pack_hd) { + sop->so_pack_hd = php->ph_pack_lk; + KB_FREEALL(php->ph_buf); + } + sop->so_pack_tl = NULL; + + /* + * Clear service required flag + */ + sop->so_flags &= ~SOF_XMITSRVC; + + return; +} + + +/* + * Insert SD PDU into Receive Queue + * + * Arguments: + * sop pointer to sscop connection block + * php pointer to SD PDU header + * + * Returns: + * 0 PDU successfully inserted into queue + * 1 duplicate sequence number PDU on queue, PDU not inserted + * + */ +int +sscop_recv_insert(sop, php) + struct sscop *sop; + struct pdu_hdr *php; +{ + struct pdu_hdr *curr, *next; + sscop_seq seq = php->ph_ns; + + /* + * Check for an empty queue + */ + if ((curr = sop->so_recv_hd) == NULL) { + php->ph_recv_lk = NULL; + sop->so_recv_hd = php; + sop->so_recv_tl = php; + return (0); + } + + /* + * Now see if PDU belongs at head of queue + */ + if (SEQ_LT(seq, curr->ph_ns, sop->so_rcvnext)) { + php->ph_recv_lk = curr; + sop->so_recv_hd = php; + return (0); + } + + /* + * Otherwise, loop thru the queue until we find the + * proper insertion point for the PDU. We also check + * to make sure there isn't a PDU already on the queue + * with a matching sequence number. + */ + while (next = curr->ph_recv_lk) { + if (SEQ_LT(seq, next->ph_ns, sop->so_rcvnext)) { + if (seq == curr->ph_ns) + return (1); + php->ph_recv_lk = next; + curr->ph_recv_lk = php; + return (0); + } + curr = next; + } + + /* + * Insert PDU at end of queue + */ + if (seq == curr->ph_ns) + return (1); + php->ph_recv_lk = NULL; + curr->ph_recv_lk = php; + sop->so_recv_tl = php; + + return (0); +} + + +/* + * Drain Receiver Queues + * + * Arguments: + * sop pointer to sscop connection block + * + * Returns: + * none + * + */ +void +sscop_rcvr_drain(sop) + struct sscop *sop; +{ + struct pdu_hdr *php; + + /* + * Free receive queue buffers + */ + while (php = sop->so_recv_hd) { + sop->so_recv_hd = php->ph_recv_lk; + KB_FREEALL(php->ph_buf); + } + sop->so_recv_tl = NULL; + + return; +} + + +/* + * Service connection's transmit queues + * + * Arguments: + * sop pointer to sscop connection block + * + * Returns: + * none + * + */ +void +sscop_service_xmit(sop) + struct sscop *sop; +{ + KBuffer *m, *n; + struct pdu_hdr *php; + int err = 0, pollsent = 0; + + /* + * Initially assume we need service + */ + sop->so_flags |= SOF_XMITSRVC; + + /* + * Loop until done with queues + * + * (Congestion control will be added later) + */ + while (1) { + if (php = sop->so_rexmit_hd) { + + /* + * Send SD PDU from retransmit queue + * + * First, get a copy of the PDU to send + */ + m = php->ph_buf; + if (KB_LEN(m) == 0) + m = KB_NEXT(m); + KB_COPY(m, 0, KB_COPYALL, n, KB_F_NOWAIT); + if (n == NULL) { + err = 1; + break; + } + + /* + * Now pass it down the stack + */ + STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, + sop->so_tokl, sop->so_connvc, (int)n, 0, err); + if (err) { + KB_FREEALL(n); + break; + } + + /* + * PDU is on its way, so remove it from + * the retransmit queue + */ + if (sop->so_rexmit_tl == php) { + sop->so_rexmit_hd = NULL; + sop->so_rexmit_tl = NULL; + } else { + sop->so_rexmit_hd = php->ph_rexmit_lk; + } + php->ph_rexmit_lk = NULL; + + /* + * Update PDU's poll sequence + */ + php->ph_nps = sop->so_pollsend; + + } else if (sop->so_xmit_hd) { + + /* + * Newly arrived data waiting to be sent. + * See if transmit window allows us to send it. + */ + if (SEQ_LT(sop->so_send, sop->so_sendmax, sop->so_ack)){ + /* + * OK, send SD PDU from transmission queue + */ + err = sscop_proc_xmit(sop); + if (err) + break; + } else { + /* + * Can't send now, so leave idle phase. + */ + if (sop->so_timer[SSCOP_T_IDLE] != 0) { + sop->so_timer[SSCOP_T_IDLE] = 0; + sop->so_timer[SSCOP_T_NORESP] = + sop->so_parm.sp_timeresp; + err = 1; + } + break; + } + + } else { + + /* + * We're finished, so clear service required flag + */ + sop->so_flags &= ~SOF_XMITSRVC; + break; + } + + /* + * We've sent another SD PDU + */ + sop->so_polldata++; + + /* + * Transition into active (polling) phase + */ + if (sop->so_timer[SSCOP_T_POLL] != 0) { + if (sop->so_flags & SOF_KEEPALIVE) { + /* + * Leaving transient phase + */ + sop->so_flags &= ~SOF_KEEPALIVE; + sop->so_timer[SSCOP_T_POLL] = + sop->so_parm.sp_timepoll; + } + } else { + /* + * Leaving idle phase + */ + sop->so_timer[SSCOP_T_IDLE] = 0; + sop->so_timer[SSCOP_T_NORESP] = + sop->so_parm.sp_timeresp; + sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll; + } + + /* + * Let's see if we need to send a POLL yet + */ + if (sop->so_polldata < sop->so_parm.sp_maxpd) + continue; + + /* + * Yup, send another poll out + */ + SEQ_INCR(sop->so_pollsend, 1); + (void) sscop_send_poll(sop); + pollsent++; + + /* + * Reset data counter for this poll cycle + */ + sop->so_polldata = 0; + + /* + * Restart polling timer in active phase + */ + sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll; + } + + /* + * If we need/want to send a poll, but haven't sent any yet + * on this servicing, send one now + */ + if (err && (pollsent == 0)) { + /* + * Send poll + */ + SEQ_INCR(sop->so_pollsend, 1); + (void) sscop_send_poll(sop); + + /* + * Reset data counter for this poll cycle + */ + sop->so_polldata = 0; + + /* + * Restart polling timer in active phase + */ + sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll; + sop->so_flags &= ~SOF_KEEPALIVE; + } + + return; +} + + +/* + * Process Transmission Queue PDU + * + * For the first entry on the transmission queue: add a PDU header and + * trailer, send a copy of the PDU down the stack and move the PDU from + * the transmission queue to the pending ack queue. + * + * Arguments: + * sop pointer to sscop connection block + * + * Returns: + * 0 head of transmission queue successfully processed + * else processing error, tranmission queue unchanged + * + */ +static int +sscop_proc_xmit(sop) + struct sscop *sop; +{ + KBuffer *m, *ml, *n; + struct pdu_hdr *php; + sscop_seq seq; + int len = 0, err; + int pad, trlen, space; + u_char *cp; + + /* + * Get first buffer chain on queue + */ + if ((m = sop->so_xmit_hd) == NULL) + return (0); + + /* + * Count data and get to last buffer in chain + */ + for (ml = m; ; ml = KB_NEXT(ml)) { + len += KB_LEN(ml); + if (KB_NEXT(ml) == NULL) + break; + } + + /* + * Verify data length + */ + if (len > sop->so_parm.sp_maxinfo) { + sscop_abort(sop, "sscop: maximum data size exceeded\n"); + return (1); + } + + /* + * Get space for PDU header + */ + KB_HEADROOM(m, space); + if (space < sizeof(struct pdu_hdr)) { + /* + * Allocate & link buffer for header + */ + KB_ALLOC(n, sizeof(struct pdu_hdr), KB_F_NOWAIT, KB_T_HEADER); + if (n == NULL) + return (1); + + KB_LEN(n) = 0; + KB_HEADSET(n, sizeof(struct pdu_hdr)); + KB_LINKHEAD(n, m); + KB_QNEXT(n) = KB_QNEXT(m); + KB_QNEXT(m) = NULL; + sop->so_xmit_hd = n; + if (sop->so_xmit_tl == m) + sop->so_xmit_tl = n; + m = n; + } + + /* + * Figure out how much padding we'll need + */ + pad = ((len + (PDU_PAD_ALIGN - 1)) & ~(PDU_PAD_ALIGN - 1)) - len; + trlen = pad + sizeof(struct sd_pdu); + + /* + * Now get space for PDU trailer and padding + */ + KB_TAILROOM(ml, space); + if (space < trlen) { + /* + * Allocate & link buffer for pad and trailer + */ + KB_ALLOC(n, trlen, KB_F_NOWAIT, KB_T_HEADER); + if (n == NULL) + return (1); + + KB_LEN(n) = 0; + KB_LINK(n, ml); + ml = n; + } + + /* + * Build the PDU trailer + * + * Since we can't be sure of alignment in the buffers, we + * have to move this a byte at a time and we have to be + * careful with host byte order issues. + */ + KB_DATASTART(ml, cp, u_char *); + cp += KB_LEN(ml) + pad; + *cp++ = (pad << PT_PAD_SHIFT) | PT_SD; + seq = sop->so_send; + *(cp + 2) = (u_char)(seq & 0xff); + seq >>= 8; + *(cp + 1) = (u_char)(seq & 0xff); + seq >>= 8; + *(cp) = (u_char)(seq & 0xff); + KB_LEN(ml) += trlen; + + /* + * Get a copy of the SD PDU to send + */ + if (KB_LEN(m) == 0) + n = KB_NEXT(m); + else + n = m; + KB_COPY(n, 0, KB_COPYALL, n, KB_F_NOWAIT); + if (n == NULL) { + KB_LEN(ml) -= trlen; + return (1); + } + + /* + * Now pass copy down the stack + */ + STACK_CALL(CPCS_UNITDATA_INV, sop->so_lower, sop->so_tokl, + sop->so_connvc, (int)n, 0, err); + if (err) { + KB_FREEALL(n); + KB_LEN(ml) -= trlen; + return (1); + } + + /* + * PDU is on its way, so remove buffer from + * the transmission queue + */ + if (sop->so_xmit_tl == m) { + sop->so_xmit_hd = NULL; + sop->so_xmit_tl = NULL; + } else { + sop->so_xmit_hd = KB_QNEXT(m); + } + KB_QNEXT(m) = NULL; + + /* + * Build PDU header + * + * We can at least assume/require that the start of + * the user data is aligned. Also note that we don't + * include this header in the buffer len/offset fields. + */ + KB_DATASTART(m, php, struct pdu_hdr *); + php--; + php->ph_ns = sop->so_send; + php->ph_nps = sop->so_pollsend; + php->ph_buf = m; + php->ph_rexmit_lk = NULL; + php->ph_pack_lk = NULL; + + /* + * Put PDU onto the pending ack queue + */ + if (sop->so_pack_hd == NULL) + sop->so_pack_hd = php; + else + sop->so_pack_tl->ph_pack_lk = php; + sop->so_pack_tl = php; + + /* + * Finally, bump send sequence number + */ + SEQ_INCR(sop->so_send, 1); + + return (0); +} + + +/* + * Detect Retransmitted PDUs + * + * Arguments: + * sop pointer to sscop connection block + * nsq connection sequence value (N(SQ)) from received PDU + * + * Returns: + * 0 received PDU was NOT retransmitted + * 1 received PDU was retransmitted + * + */ +int +sscop_is_rexmit(sop, nsq) + struct sscop *sop; + u_char nsq; +{ + + /* + * For Q.SAAL1, N(SQ) doesn't exist + */ + if (sop->so_vers == SSCOP_VERS_QSAAL) + return (0); + + /* + * If we've already received the N(SQ) value, + * then this PDU has been retransmitted + */ + if (nsq == sop->so_rcvconn) + return (1); + + /* + * New PDU, save its N(SQ) + */ + sop->so_rcvconn = nsq; + + return (0); +} + + +/* + * Start connection poll timer + * + * Arguments: + * sop pointer to sscop connection block + * + * Returns: + * none + * + */ +void +sscop_set_poll(sop) + struct sscop *sop; +{ + + /* + * Decide which polling timer value to set + */ + if ((sop->so_xmit_hd != NULL) || SEQ_NEQ(sop->so_send, sop->so_ack)) { + /* + * Data outstanding, poll frequently + */ + sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll; + sop->so_flags &= ~SOF_KEEPALIVE; + } else { + /* + * No data outstanding, just poll occassionally + */ + sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timekeep; + sop->so_flags |= SOF_KEEPALIVE; + } + + return; +} + diff --git a/sys/netatm/uni/sscop_timer.c b/sys/netatm/uni/sscop_timer.c new file mode 100644 index 0000000..8c23344b --- /dev/null +++ b/sys/netatm/uni/sscop_timer.c @@ -0,0 +1,576 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscop_timer.c,v 1.6 1998/04/07 23:21:48 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * SSCOP - Timer processing + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: sscop_timer.c,v 1.6 1998/04/07 23:21:48 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscop_misc.h> +#include <netatm/uni/sscop_pdu.h> +#include <netatm/uni/sscop_var.h> + + +/* + * Local functions + */ +static void sscop_poll_expire __P((struct sscop *)); +static void sscop_noresponse_expire __P((struct sscop *)); +static void sscop_cc_expire __P((struct sscop *)); +static void sscop_idle_expire __P((struct sscop *)); + +/* + * Local variables + */ +static void (*sscop_expired[SSCOP_T_NUM]) __P((struct sscop *)) = { + sscop_poll_expire, + sscop_noresponse_expire, + sscop_cc_expire, + sscop_idle_expire +}; + + +/* + * Process an SSCOP timer tick + * + * This function is called SSCOP_HZ times a second in order to update + * all of the sscop connection timers. The sscop expiration function + * will be called to process all timer expirations. + * + * Called at splnet. + * + * Arguments: + * tip pointer to sscop timer control block + * + * Returns: + * none + * + */ +void +sscop_timeout(tip) + struct atm_time *tip; +{ + struct sscop *sop, **sprev; + int i; + + + /* + * Schedule next timeout + */ + atm_timeout(&sscop_timer, ATM_HZ/SSCOP_HZ, sscop_timeout); + + /* + * Run through all connections, updating each active timer. + * If an expired timer is found, notify that entry. + */ + sprev = &sscop_head; + while (sop = *sprev) { + + /* + * Check out each timer + */ + for (i =0; i < SSCOP_T_NUM; i++) { + + /* + * Decrement timer if it's active + */ + if (sop->so_timer[i] && (--sop->so_timer[i] == 0)) { + +#ifdef DIAGNOSTIC + { + static char *tn[] = { + "POLL", + "NORESPONSE", + "CC", + "IDLE" + }; + ATM_DEBUG3("sscop_timer: %s expired, sop=0x%x, state=%d\n", + tn[i], (int)sop, sop->so_state); + } +#endif + + /* + * Expired timer - process it + */ + (*sscop_expired[i])(sop); + + /* + * Make sure connection still exists + */ + if (*sprev != sop) + break; + } + } + + /* + * Update previous pointer if current control + * block wasn't deleted + */ + if (*sprev == sop) + sprev = &sop->so_next; + } +} + + +/* + * Process an SSCOP Timer_POLL expiration + * + * Arguments: + * sop pointer to sscop connection control block + * + * Returns: + * none + * + */ +static void +sscop_poll_expire(sop) + struct sscop *sop; +{ + + /* + * Validate current state + */ + if ((sop->so_state != SOS_READY) && + ((sop->so_state != SOS_INRESYN) || + (sop->so_vers != SSCOP_VERS_QSAAL))) { + log(LOG_ERR, "sscop: invalid %s state: sop=0x%x, state=%d\n", + "Timer_POLL", (int)sop, sop->so_state); + return; + } + + /* + * Send next poll along its way + */ + SEQ_INCR(sop->so_pollsend, 1); + (void) sscop_send_poll(sop); + + /* + * Reset data counter for this poll cycle + */ + sop->so_polldata = 0; + + /* + * Reset polling timer + */ + sscop_set_poll(sop); + + return; +} + + +/* + * Process an SSCOP Timer_IDLE expiration + * + * Arguments: + * sop pointer to sscop connection control block + * + * Returns: + * none + * + */ +static void +sscop_idle_expire(sop) + struct sscop *sop; +{ + + /* + * Timer_IDLE only valid in READY state + */ + if (sop->so_state != SOS_READY) { + log(LOG_ERR, "sscop: invalid %s state: sop=0x%x, state=%d\n", + "Timer_IDLE", (int)sop, sop->so_state); + return; + } + + /* + * Send next poll along its way + */ + SEQ_INCR(sop->so_pollsend, 1); + (void) sscop_send_poll(sop); + + /* + * Reset data counter for this poll cycle + */ + sop->so_polldata = 0; + + /* + * Start NO-RESPONSE timer + */ + sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp; + + /* + * Reset polling timer + */ + sscop_set_poll(sop); + + return; +} + + +/* + * Process an SSCOP Timer_NORESPONSE expiration + * + * Arguments: + * sop pointer to sscop connection control block + * + * Returns: + * none + * + */ +static void +sscop_noresponse_expire(sop) + struct sscop *sop; +{ + int err; + + /* + * Validate current state + */ + if ((sop->so_state != SOS_READY) && + ((sop->so_state != SOS_INRESYN) || + (sop->so_vers != SSCOP_VERS_QSAAL))) { + log(LOG_ERR, "sscop: invalid %s state: sop=0x%x, state=%d\n", + "Timer_NORESPONSE", (int)sop, sop->so_state); + return; + } + + /* + * Peer seems to be dead, so terminate session + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, + sop->so_toku, sop->so_connvc, + SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + /* + * Error, force retry + */ + sop->so_timer[SSCOP_T_NORESP] = 1; + return; + } + + /* + * Stop data transfer timers + */ + sop->so_timer[SSCOP_T_POLL] = 0; + sop->so_timer[SSCOP_T_IDLE] = 0; + sop->so_flags &= ~SOF_KEEPALIVE; + + /* + * Notify peer of termination + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + /* + * Report peer's failure + */ + sscop_maa_error(sop, 'P'); + + if (sop->so_vers == SSCOP_VERS_QSAAL) + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + else + /* + * Clear out appropriate queues + */ + q2110_prep_retrieve(sop); + + /* + * Return to IDLE state + */ + sop->so_state = SOS_IDLE; + + return; +} + + +/* + * Process an SSCOP Timer_CC expiration + * + * Arguments: + * sop pointer to sscop connection control block + * + * Returns: + * none + * + */ +static void +sscop_cc_expire(sop) + struct sscop *sop; +{ + int err; + + /* + * Process timeout based on protocol state + */ + switch (sop->so_state) { + + case SOS_OUTCONN: + /* + * No response to our BGN yet + */ + if (sop->so_connctl < sop->so_parm.sp_maxcc) { + + /* + * Send another BGN PDU + */ + sop->so_connctl++; + (void) sscop_send_bgn(sop, SSCOP_SOURCE_USER); + + /* + * Restart retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = sop->so_parm.sp_timecc; + + } else { + + /* + * Retransmit limit exceeded, terminate session + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, + sop->so_toku, sop->so_connvc, + SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + /* + * Error, force retry + */ + sop->so_timer[SSCOP_T_CC] = 1; + break; + } + + /* + * Notify peer of termination + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + /* + * Report establishment failure + */ + sscop_maa_error(sop, 'O'); + + /* + * Clear reestablishment flag + */ + sop->so_flags &= ~SOF_REESTAB; + + /* + * Return to IDLE state + */ + sop->so_state = SOS_IDLE; + } + break; + + case SOS_OUTDISC: + /* + * No response to our END yet + */ + if (sop->so_connctl < sop->so_parm.sp_maxcc) { + + /* + * Send another END PDU + */ + sop->so_connctl++; + (void) sscop_send_end(sop, SSCOP_SOURCE_LAST); + + /* + * Restart retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = sop->so_parm.sp_timecc; + + } else { + + /* + * Retransmit limit exceeded, force session termination + */ + STACK_CALL(SSCOP_RELEASE_CNF, sop->so_upper, + sop->so_toku, sop->so_connvc, 0, 0, err); + if (err) { + /* + * Error, force retry + */ + sop->so_timer[SSCOP_T_CC] = 1; + break; + } + + /* + * Report establishment failure + */ + sscop_maa_error(sop, 'O'); + + /* + * Return to IDLE state + */ + sop->so_state = SOS_IDLE; + } + break; + + case SOS_OUTRESYN: +rexmitrs: + /* + * No response to our RS yet + */ + if (sop->so_connctl < sop->so_parm.sp_maxcc) { + + /* + * Send another RS PDU + */ + sop->so_connctl++; + (void) sscop_send_rs(sop); + + /* + * Restart retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = sop->so_parm.sp_timecc; + + } else { + + /* + * Retransmit limit exceeded, terminate session + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, + sop->so_toku, sop->so_connvc, + SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + /* + * Error, force retry + */ + sop->so_timer[SSCOP_T_CC] = 1; + break; + } + + /* + * Notify peer of termination + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + /* + * Report establishment failure + */ + sscop_maa_error(sop, 'O'); + + if (sop->so_vers == SSCOP_VERS_QSAAL) + /* + * Clear connection data + */ + qsaal1_clear_connection(sop); + + /* + * Return to IDLE state + */ + sop->so_state = SOS_IDLE; + } + break; + + case SOS_CONRESYN: /* Q.SAAL1 */ +#if (SOS_OUTRECOV != SOS_CONRESYN) + case SOS_OUTRECOV: /* Q.2110 */ +#endif + if (sop->so_vers == SSCOP_VERS_QSAAL) { + /* + * Handle timeout for SOS_CONRESYN + */ + goto rexmitrs; + } + + /* + * Handle timeout for SOS_OUTRECOV + */ + + /* + * No response to our ER yet + */ + if (sop->so_connctl < sop->so_parm.sp_maxcc) { + + /* + * Send another ER PDU + */ + sop->so_connctl++; + (void) sscop_send_er(sop); + + /* + * Restart retransmit timer + */ + sop->so_timer[SSCOP_T_CC] = sop->so_parm.sp_timecc; + + } else { + + /* + * Retransmit limit exceeded, terminate session + */ + STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, + sop->so_toku, sop->so_connvc, + SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err); + if (err) { + /* + * Error, force retry + */ + sop->so_timer[SSCOP_T_CC] = 1; + break; + } + + /* + * Notify peer of termination + */ + (void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP); + + /* + * Report establishment failure + */ + sscop_maa_error(sop, 'O'); + + /* + * Clear receiver buffer + */ + sscop_rcvr_drain(sop); + + /* + * Return to IDLE state + */ + sop->so_state = SOS_IDLE; + } + break; + + default: + log(LOG_ERR, "sscop: invalid %s state: sop=0x%x, state=%d\n", + "Timer_CC", (int)sop, sop->so_state); + } +} + diff --git a/sys/netatm/uni/sscop_upper.c b/sys/netatm/uni/sscop_upper.c new file mode 100644 index 0000000..be9556d --- /dev/null +++ b/sys/netatm/uni/sscop_upper.c @@ -0,0 +1,412 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscop_upper.c,v 1.6 1998/08/26 23:29:20 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * SSCOP - CPCS SAP interface processing + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: sscop_upper.c,v 1.6 1998/08/26 23:29:20 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/sscop.h> +#include <netatm/uni/sscop_misc.h> +#include <netatm/uni/sscop_pdu.h> +#include <netatm/uni/sscop_var.h> + + +/* + * Local functions + */ +static caddr_t sscop_pdu_receive __P((KBuffer *, struct sscop *, int *)); + + +/* + * Local variables + */ +static union { + struct bgn_pdu t_bgn; + struct bgak_pdu t_bgak; + struct end_pdu t_end; + struct endak_q2110_pdu t_endak_q2110; + struct endak_qsaal_pdu t_endak_qsaal; + struct rs_pdu t_rs; + struct rsak_q2110_pdu t_rsak_q2110; + struct rsak_qsaal_pdu t_rsak_qsaal; + struct bgrej_pdu t_bgrej; + struct sd_pdu t_sd; + struct sdp_pdu t_sdp; + struct er_pdu t_er; + struct poll_pdu t_poll; + struct stat_pdu t_stat; + struct ustat_pdu t_ustat; + struct ud_pdu t_ud; + struct md_pdu t_md; + struct erak_pdu t_erak; +} sscop_trailer; + + +/* + * PDU length validation table + */ +struct pdulen { + int min; + int max; +}; + +static struct pdulen qsaal_pdulen[] = { + {0, 0}, + {sizeof(struct bgn_pdu), sizeof(struct bgn_pdu)}, + {sizeof(struct bgak_pdu), sizeof(struct bgak_pdu)}, + {sizeof(struct end_pdu), sizeof(struct end_pdu)}, + {sizeof(struct endak_qsaal_pdu),sizeof(struct endak_qsaal_pdu)}, + {sizeof(struct rs_pdu), sizeof(struct rs_pdu)}, + {sizeof(struct rsak_qsaal_pdu), sizeof(struct rsak_qsaal_pdu)}, + {sizeof(struct bgrej_pdu), sizeof(struct bgrej_pdu)}, + {sizeof(struct sd_pdu), sizeof(struct sd_pdu) + PDU_MAX_INFO}, + {sizeof(struct sdp_pdu), sizeof(struct sdp_pdu) + PDU_MAX_INFO}, + {sizeof(struct poll_pdu), sizeof(struct poll_pdu)}, + {sizeof(struct stat_pdu), sizeof(struct stat_pdu) + PDU_MAX_STAT}, + {sizeof(struct ustat_pdu), sizeof(struct ustat_pdu)}, + {sizeof(struct ud_pdu), sizeof(struct ud_pdu) + PDU_MAX_INFO}, + {sizeof(struct md_pdu), sizeof(struct md_pdu) + PDU_MAX_INFO}, + {0, 0} +}; + +static struct pdulen q2110_pdulen[] = { + {0, 0}, + {sizeof(struct bgn_pdu), sizeof(struct bgn_pdu) + PDU_MAX_UU}, + {sizeof(struct bgak_pdu), sizeof(struct bgak_pdu) + PDU_MAX_UU}, + {sizeof(struct end_pdu), sizeof(struct end_pdu) + PDU_MAX_UU}, + {sizeof(struct endak_q2110_pdu),sizeof(struct endak_q2110_pdu)}, + {sizeof(struct rs_pdu), sizeof(struct rs_pdu) + PDU_MAX_UU}, + {sizeof(struct rsak_q2110_pdu), sizeof(struct rsak_q2110_pdu)}, + {sizeof(struct bgrej_pdu), sizeof(struct bgrej_pdu) + PDU_MAX_UU}, + {sizeof(struct sd_pdu), sizeof(struct sd_pdu) + PDU_MAX_INFO}, + {sizeof(struct er_pdu), sizeof(struct er_pdu)}, + {sizeof(struct poll_pdu), sizeof(struct poll_pdu)}, + {sizeof(struct stat_pdu), sizeof(struct stat_pdu) + PDU_MAX_STAT}, + {sizeof(struct ustat_pdu), sizeof(struct ustat_pdu)}, + {sizeof(struct ud_pdu), sizeof(struct ud_pdu) + PDU_MAX_INFO}, + {sizeof(struct md_pdu), sizeof(struct md_pdu) + PDU_MAX_INFO}, + {sizeof(struct erak_pdu), sizeof(struct erak_pdu)} +}; + + +/* + * PDUs with Pad Length Fields + */ +static u_char qsaal_padlen[] = { + 0, /* --- */ + 0, /* BGN */ + 0, /* BGAK */ + 0, /* END */ + 0, /* ENDAK */ + 0, /* RS */ + 0, /* RSAK */ + 0, /* BGREJ */ + 1, /* SD */ + 1, /* SDP */ + 0, /* POLL */ + 0, /* STAT */ + 0, /* USTAT */ + 1, /* UD */ + 1, /* MD */ + 0 /* --- */ +}; + +static u_char q2110_padlen[] = { + 0, /* --- */ + 1, /* BGN */ + 1, /* BGAK */ + 1, /* END */ + 0, /* ENDAK */ + 1, /* RS */ + 0, /* RSAK */ + 1, /* BGREJ */ + 1, /* SD */ + 0, /* ER */ + 0, /* POLL */ + 0, /* STAT */ + 0, /* USTAT */ + 1, /* UD */ + 1, /* MD */ + 0 /* ERAK */ +}; + + +/* + * SSCOP Upper Stack Command Handler + * + * This function will receive all of the stack commands issued from the + * layer below SSCOP (ie. CPCS). Currently, only incoming PDUs will be + * received here. The appropriate processing function will be determined + * based on the received PDU type and the current sscop control block state. + * + * Arguments: + * cmd stack command code + * tok session token + * arg1 command specific argument + * arg2 command specific argument + * + * Returns: + * none + * + */ +void +sscop_upper(cmd, tok, arg1, arg2) + int cmd; + void *tok; + int arg1; + int arg2; +{ + struct sscop *sop = (struct sscop *)tok; + void (**ptab) __P((struct sscop *, KBuffer *, caddr_t)); + void (*func) __P((struct sscop *, KBuffer *, caddr_t)); + caddr_t trlr; + int type; + + ATM_DEBUG5("sscop_upper: cmd=0x%x, sop=0x%x, state=%d, arg1=0x%x, arg2=0x%x\n", + cmd, (int)sop, sop->so_state, arg1, arg2); + + switch (cmd) { + + case CPCS_UNITDATA_SIG: + /* + * Decode/validate received PDU + */ + trlr = sscop_pdu_receive((KBuffer *)arg1, sop, &type); + if (trlr == NULL) { + return; + } + + /* + * Validate sscop state + */ + if (sop->so_state > SOS_MAXSTATE) { + log(LOG_ERR, + "sscop_upper: invalid state sop=0x%x, state=%d\n", + (int)sop, sop->so_state); + KB_FREEALL((KBuffer *)arg1); + return; + } + + /* + * Call event processing function + */ + ptab = sop->so_vers == SSCOP_VERS_QSAAL ? + sscop_qsaal_pdutab[type]: + sscop_q2110_pdutab[type]; + func = ptab[sop->so_state]; + if (func == NULL) { + log(LOG_ERR, + "sscop_upper: unsupported pdu=%d, state=%d\n", + type, sop->so_state); + break; + } + (*func)(sop, (KBuffer *)arg1, trlr); + break; + + default: + log(LOG_ERR, "sscop_upper: unknown cmd 0x%x, sop=0x%x\n", + cmd, (int)sop); + } + + return; +} + + +/* + * Decode and Validate Received PDU + * + * This function will process all received SSCOP PDUs. The PDU type will be + * determined and PDU format validation will be performed. If the PDU is + * successfully decoded and validated, the buffer chain will have the PDU + * trailer removed, but any resultant zero-length buffers will NOT be freed. + * If the PDU fails validation, then the buffer chain will be freed. + * + * Arguments: + * m pointer to PDU buffer chain + * sop pointer to sscop connection block + * typep address to store PDU type + * + * Returns: + * addr pointer to (contiguous) PDU trailer + * 0 invalid PDU, buffer chain freed + * + */ +static caddr_t +sscop_pdu_receive(m, sop, typep) + KBuffer *m; + struct sscop *sop; + int *typep; +{ + KBuffer *m0, *ml, *mn; + caddr_t cp, tp; + int len, tlen, type, plen; + + /* + * Calculate PDU length and find the last two buffers in the chain + */ + len = 0; + for (m0 = m, ml = mn = NULL; m0; m0 = KB_NEXT(m0)) { + len += KB_LEN(m0); + mn = ml; + ml = m0; + } + + /* + * Make sure we've got a minimum sized PDU + */ + if (len < PDU_MIN_LEN) + goto badpdu; + + /* + * Get PDU type field + */ + if (KB_LEN(ml) >= PDU_MIN_LEN) { + KB_DATAEND(ml, tp, caddr_t); + tp -= PDU_MIN_LEN; + } else { + KB_DATAEND(mn, tp, caddr_t); + tp -= (PDU_MIN_LEN - KB_LEN(ml)); + } + *typep = type = *tp & PT_TYPE_MASK; + + /* + * Check up on PDU length + */ + if (sop->so_vers == SSCOP_VERS_QSAAL) { + if ((len < (tlen = qsaal_pdulen[type].min)) || + (len > qsaal_pdulen[type].max) || + (len & PDU_LEN_MASK)) + goto badpdu; + } else { + if ((len < (tlen = q2110_pdulen[type].min)) || + (len > q2110_pdulen[type].max) || + (len & PDU_LEN_MASK)) + goto badpdu; + } + + /* + * Get a contiguous, aligned PDU trailer and adjust buffer + * controls to remove trailer + */ + if (KB_LEN(ml) >= tlen) { + /* + * Trailer is contained in last buffer + */ + KB_TAILADJ(ml, -tlen); + KB_DATAEND(ml, cp, caddr_t); + if ((int)cp & PDU_ADDR_MASK) { + /* + * Trailer not aligned in buffer, use local memory + */ + KM_COPY(cp, (caddr_t)&sscop_trailer, tlen); + cp = (caddr_t)&sscop_trailer; + } + } else { + /* + * Trailer is split across buffers, use local memory + */ + caddr_t cp1; + int off = tlen - KB_LEN(ml); + + cp = (caddr_t)&sscop_trailer; + + /* + * Ensure trailer is within last two buffers + */ + if ((mn == NULL) || (KB_LEN(mn) < off)) + goto badpdu; + + KB_DATASTART(ml, cp1, caddr_t); + KM_COPY(cp1, cp + off, KB_LEN(ml)); + KB_LEN(ml) = 0; + KB_TAILADJ(mn, -off); + KB_DATAEND(mn, cp1, caddr_t); + KM_COPY(cp1, cp, off); + } + + /* + * Get possible PDU Pad Length + */ + if (sop->so_vers == SSCOP_VERS_QSAAL) { + if (qsaal_padlen[type]) + plen = (*tp & PT_PAD_MASK) >> PT_PAD_SHIFT; + else + plen = 0; + } else { + if (q2110_padlen[type]) + plen = (*tp & PT_PAD_MASK) >> PT_PAD_SHIFT; + else + plen = 0; + } + + /* + * Perform Pad Length adjustments + */ + if (plen) { + if (KB_LEN(ml) >= plen) { + /* + * All pad bytes in last buffer + */ + KB_TAILADJ(ml, -plen); + } else { + /* + * Pad bytes split between buffers + */ + plen -= KB_LEN(ml); + if ((mn == NULL) || (KB_LEN(mn) < plen)) + goto badpdu; + KB_LEN(ml) = 0; + KB_TAILADJ(mn, -plen); + } + } + + return (cp); + +badpdu: + /* + * This MAA Error is only supposed to be for a PDU length violation, + * but we use it for any PDU format error. + */ + sscop_maa_error(sop, 'U'); + sscop_pdu_print(sop, m, "badpdu received"); + KB_FREEALL(m); + return (NULL); +} + diff --git a/sys/netatm/uni/sscop_var.h b/sys/netatm/uni/sscop_var.h new file mode 100644 index 0000000..9a739d3 --- /dev/null +++ b/sys/netatm/uni/sscop_var.h @@ -0,0 +1,283 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: sscop_var.h,v 1.6 1998/04/07 23:21:57 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * SSCOP protocol control blocks + * + */ + +#ifndef _UNI_SSCOP_VAR_H +#define _UNI_SSCOP_VAR_H + +/* + * Structure containing information for each SSCOP connection. + */ +struct sscop { + struct sscop *so_next; /* Next connection in chain */ + u_char so_state; /* Connection state (see below) */ + u_short so_flags; /* Connection flags (see below) */ + enum sscop_vers so_vers; /* SSCOP version */ + + /* Transmitter variables */ + sscop_seq so_send; /* VT(S) - next SD to send */ + sscop_seq so_sendmax; /* VT(MS) - max SD to send + 1 */ + sscop_seq so_ack; /* VT(A) - next expected ack */ + sscop_seq so_pollsend; /* VT(PS) - last POLL sent */ + sscop_seq so_pollack; /* VT(PA) - next expected STAT */ + short so_polldata; /* VT(PD) - SD's sent between POLLs */ + short so_connctl; /* VT(CC) - un-ack'd BGN,END,ER,RS */ + u_char so_sendconn; /* VT(SQ) - last BGN,ER,RS sent */ + + /* Receiver variables */ + sscop_seq so_rcvnext; /* VR(R) - next SD to receive */ + sscop_seq so_rcvhigh; /* VR(H) - next highest SD to receive */ + sscop_seq so_rcvmax; /* VR(MR) - max SD to receive + 1 */ + u_char so_rcvconn; /* VR(SQ) - last BGN,ER,RS received */ + + /* PDU queues */ + KBuffer *so_xmit_hd; /* SD transmission queue head */ + KBuffer *so_xmit_tl; /* SD transmission queue tail */ + struct pdu_hdr *so_rexmit_hd; /* SD retransmission queue head */ + struct pdu_hdr *so_rexmit_tl; /* SD retransmission queue head */ + struct pdu_hdr *so_pack_hd; /* SD pending ack queue head */ + struct pdu_hdr *so_pack_tl; /* SD pending ack queue tail */ + struct pdu_hdr *so_recv_hd; /* SD receive queue head */ + struct pdu_hdr *so_recv_tl; /* SD receive queue tail */ + + /* Connection parameters */ + struct sscop_parms so_parm; /* Connection parameters */ + + /* Timers */ + u_short so_timer[SSCOP_T_NUM]; /* Connection timers */ + + /* Stack variables */ + Atm_connvc *so_connvc; /* Connection vcc for this stack */ + void *so_toku; /* Stack upper layer's token */ + void *so_tokl; /* Stack lower layer's token */ + void (*so_upper) /* Stack upper layer's interface */ + __P((int, void *, int, int)); + void (*so_lower) /* Stack lower layer's interface */ + __P((int, void *, int, int)); + u_short so_headout; /* Output buffer headroom */ +}; + +/* + * Connection States + * + * Notes: + * # - state valid only for Q.SAAL1 + * ## - state valid only for Q.2110 + */ +#define SOS_INST 0 /* Instantiated, waiting for INIT */ +#define SOS_IDLE 1 /* Idle connection */ +#define SOS_OUTCONN 2 /* Outgoing connection pending */ +#define SOS_INCONN 3 /* Incoming connection pending */ +#define SOS_OUTDISC 4 /* Outgoing disconnection pending */ +#define SOS_OUTRESYN 5 /* Outgoing resynchronization pending */ +#define SOS_INRESYN 6 /* Incoming resynchronization pending */ +#define SOS_CONRESYN 7 /* Concurrent resynch pending (#) */ +#define SOS_OUTRECOV 7 /* Outgoing recovery pending (##) */ +#define SOS_RECOVRSP 8 /* Recovery response pending (##) */ +#define SOS_INRECOV 9 /* Incoming recovery pending (##) */ +#define SOS_READY 10 /* Data transfer ready */ +#define SOS_TERM 11 /* Waiting for TERM */ + +#define SOS_MAXSTATE 11 /* Maximum state value */ +#define SOS_NUMSTATES (SOS_MAXSTATE+1)/* Number of states */ + +/* + * Connection Flags + */ +#define SOF_NOCLRBUF 0x0001 /* Clear buffers = no */ +#define SOF_REESTAB 0x0002 /* SSCOP initiated reestablishment */ +#define SOF_XMITSRVC 0x0004 /* Transmit queues need servicing */ +#define SOF_KEEPALIVE 0x0008 /* Polling in transient phase */ +#define SOF_ENDSSCOP 0x0010 /* Last END PDU, SOURCE=SSCOP */ +#define SOF_NOCREDIT 0x0020 /* Transmit window closed */ + + +/* + * SSCOP statistics + */ +struct sscop_stat { + u_long sos_connects; /* Connection instances */ + u_long sos_aborts; /* Connection aborts */ + u_long sos_maa_error[MAA_ERROR_COUNT]; /* Management errors */ +}; + +#ifdef ATM_KERNEL +/* + * Global function declarations + */ + /* sscop.c */ +int sscop_start __P((void)); +int sscop_stop __P((void)); +void sscop_maa_error __P((struct sscop *, int)); +void sscop_abort __P((struct sscop *, char *)); + + /* sscop_lower.c */ +void sscop_lower __P((int, void *, int, int)); +void sscop_aa_noop_0 __P((struct sscop *, int, int)); +void sscop_aa_noop_1 __P((struct sscop *, int, int)); +void sscop_init_inst __P((struct sscop *, int, int)); +void sscop_term_all __P((struct sscop *, int, int)); + + /* sscop_pdu.c */ +int sscop_send_bgn __P((struct sscop *, int)); +int sscop_send_bgak __P((struct sscop *)); +int sscop_send_bgrej __P((struct sscop *)); +int sscop_send_end __P((struct sscop *, int)); +int sscop_send_endak __P((struct sscop *)); +int sscop_send_rs __P((struct sscop *)); +int sscop_send_rsak __P((struct sscop *)); +int sscop_send_er __P((struct sscop *)); +int sscop_send_erak __P((struct sscop *)); +int sscop_send_poll __P((struct sscop *)); +int sscop_send_stat __P((struct sscop *, sscop_seq)); +int sscop_send_ustat __P((struct sscop *, sscop_seq)); +int sscop_send_ud __P((struct sscop *, KBuffer *)); +void sscop_pdu_print __P((struct sscop *, KBuffer *, char *)); + + /* sscop_sigaa.c */ +void sscop_estreq_idle __P((struct sscop *, int, int)); +void sscop_estrsp_inconn __P((struct sscop *, int, int)); +void sscop_relreq_outconn __P((struct sscop *, int, int)); +void sscop_relreq_inconn __P((struct sscop *, int, int)); +void sscop_relreq_ready __P((struct sscop *, int, int)); +void sscop_datreq_ready __P((struct sscop *, int, int)); +void sscop_udtreq_all __P((struct sscop *, int, int)); + + /* sscop_sigcpcs.c */ +void sscop_noop __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_bgn_idle __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_bgn_outdisc __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_bgn_outresyn __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_bgn_inresyn __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_bgak_error __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_bgak_idle __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_bgak_outconn __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_bgrej_error __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_bgrej_outconn __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_bgrej_inconn __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_bgrej_outresyn __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_bgrej_ready __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_end_idle __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_end_inconn __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_end_outdisc __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_endak_error __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_endak_inconn __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_endak_outdisc __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_endak_ready __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_rs_error __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_rs_idle __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_rsak_error __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_rsak_idle __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_rsak_outresyn __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_sd_error __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_sd_idle __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_sd_inconn __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_poll_error __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_poll_idle __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_poll_inconn __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_stat_error __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_stat_idle __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_stat_inconn __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_stat_ready __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_ustat_error __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_ustat_idle __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_ustat_inconn __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_ustat_ready __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_ud_all __P((struct sscop *, KBuffer *, caddr_t)); +void sscop_md_all __P((struct sscop *, KBuffer *, caddr_t)); + + /* sscop_subr.c */ +KBuffer * sscop_stat_getelem __P((KBuffer *, sscop_seq *)); +struct pdu_hdr *sscop_pack_locate __P((struct sscop *, sscop_seq)); +void sscop_pack_free __P((struct sscop *, sscop_seq)); +void sscop_rexmit_insert __P((struct sscop *, struct pdu_hdr *)); +void sscop_rexmit_unlink __P((struct sscop *, struct pdu_hdr *)); +void sscop_xmit_drain __P((struct sscop *)); +int sscop_recv_insert __P((struct sscop *, struct pdu_hdr *)); +void sscop_rcvr_drain __P((struct sscop *)); +void sscop_service_xmit __P((struct sscop *)); +int sscop_is_rexmit __P((struct sscop *, u_char)); +void sscop_set_poll __P((struct sscop *)); + + /* sscop_timer.c */ +void sscop_timeout __P((struct atm_time *)); + + /* sscop_upper.c */ +void sscop_upper __P((int, void *, int, int)); + + /* q2110_sigaa.c */ + + /* q2110_sigcpcs.c */ + + /* q2110_subr.c */ +void q2110_clear_xmit __P((struct sscop *)); +void q2110_init_state __P((struct sscop *)); +void q2110_prep_retrieve __P((struct sscop *)); +void q2110_prep_recovery __P((struct sscop *)); +void q2110_deliver_data __P((struct sscop *)); +void q2110_error_recovery __P((struct sscop *)); + + /* qsaal1_sigaa.c */ + + /* qsaal1_sigcpcs.c */ + + /* qsaal1_subr.c */ +void qsaal1_reestablish __P((struct sscop *)); +void qsaal1_reset_xmit __P((struct sscop *)); +void qsaal1_reset_rcvr __P((struct sscop *)); +void qsaal1_clear_connection __P((struct sscop *)); + + +/* + * External variables + */ +extern struct sp_info sscop_pool; +extern int sscop_vccnt; +extern struct sscop *sscop_head; +extern struct sscop_stat sscop_stat; +extern struct atm_time sscop_timer; +extern void (*(*sscop_qsaal_aatab[])) + __P((struct sscop *, int, int)); +extern void (*(*sscop_q2110_aatab[])) + __P((struct sscop *, int, int)); +extern void (*(*sscop_qsaal_pdutab[])) + __P((struct sscop *, KBuffer *, caddr_t)); +extern void (*(*sscop_q2110_pdutab[])) + __P((struct sscop *, KBuffer *, caddr_t)); + +#endif /* ATM_KERNEL */ + +#endif /* _UNI_SSCOP_VAR_H */ diff --git a/sys/netatm/uni/uni.h b/sys/netatm/uni/uni.h new file mode 100644 index 0000000..700e859 --- /dev/null +++ b/sys/netatm/uni/uni.h @@ -0,0 +1,50 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: uni.h,v 1.2 1997/05/06 22:20:39 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * Protocol definitions + * + */ + +#ifndef _UNI_UNI_H +#define _UNI_UNI_H + +/* + * UNI Version + */ +enum uni_vers { + UNI_VERS_3_0, + UNI_VERS_3_1, + UNI_VERS_4_0 +}; + +#endif /* _UNI_UNI_H */ diff --git a/sys/netatm/uni/uni_load.c b/sys/netatm/uni/uni_load.c new file mode 100644 index 0000000..23e7ff5 --- /dev/null +++ b/sys/netatm/uni/uni_load.c @@ -0,0 +1,450 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: uni_load.c,v 1.6 1997/05/06 22:20:43 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * Loadable kernel module support + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: uni_load.c,v 1.6 1997/05/06 22:20:43 mks Exp $"; +#endif + +#ifndef ATM_UNI_MODULE +#include "opt_atm.h" +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> + +/* + * External functions + */ +int sscop_start __P((void)); +int sscop_stop __P((void)); +int sscf_uni_start __P((void)); +int sscf_uni_stop __P((void)); +int uniip_start __P((void)); +int uniip_stop __P((void)); +int unisig_start __P((void)); +int unisig_stop __P((void)); + +/* + * Local functions + */ +static int uni_start __P((void)); +static int uni_stop __P((void)); + + +/* + * Initialize uni processing + * + * This will be called during module loading. We just notify all of our + * sub-services to initialize. + * + * Arguments: + * none + * + * Returns: + * 0 startup was successful + * errno startup failed - reason indicated + * + */ +static int +uni_start() +{ + int err; + + /* + * Verify software version + */ + if (atm_version != ATM_VERSION) { + log(LOG_ERR, "version mismatch: uni=%d.%d kernel=%d.%d\n", + ATM_VERS_MAJ(ATM_VERSION), ATM_VERS_MIN(ATM_VERSION), + ATM_VERS_MAJ(atm_version), ATM_VERS_MIN(atm_version)); + return (EINVAL); + } + + /* + * Initialize uni sub-services + */ + err = sscop_start(); + if (err) + goto done; + + err = sscf_uni_start(); + if (err) + goto done; + + err = unisig_start(); + if (err) + goto done; + + err = uniip_start(); + if (err) + goto done; + +done: + return (err); +} + + +/* + * Halt uni processing + * + * This will be called just prior to unloading the module from + * memory. All sub-services will be notified of the termination. + * + * Arguments: + * none + * + * Returns: + * 0 shutdown was successful + * errno shutdown failed - reason indicated + * + */ +static int +uni_stop() +{ + int err, s = splnet(); + + /* + * Terminate uni sub-services + */ + err = uniip_stop(); + if (err) + goto done; + + err = unisig_stop(); + if (err) + goto done; + + err = sscf_uni_stop(); + if (err) + goto done; + + err = sscop_stop(); + if (err) + goto done; + +done: + (void) splx(s); + return (err); +} + + +#ifdef ATM_UNI_MODULE +/* + ******************************************************************* + * + * Loadable Module Support + * + ******************************************************************* + */ +static int uni_doload __P((void)); +static int uni_dounload __P((void)); + +/* + * Generic module load processing + * + * This function is called by an OS-specific function when this + * module is being loaded. + * + * Arguments: + * none + * + * Returns: + * 0 load was successful + * errno load failed - reason indicated + * + */ +static int +uni_doload() +{ + int err = 0; + + /* + * Start us up + */ + err = uni_start(); + if (err) + /* Problems, clean up */ + (void)uni_stop(); + + return (err); +} + + +/* + * Generic module unload processing + * + * This function is called by an OS-specific function when this + * module is being unloaded. + * + * Arguments: + * none + * + * Returns: + * 0 unload was successful + * errno unload failed - reason indicated + * + */ +static int +uni_dounload() +{ + int err = 0; + + /* + * OK, try to clean up our mess + */ + err = uni_stop(); + + return (err); +} + + +#ifdef sun +/* + * Loadable driver description + */ +struct vdldrv uni_drv = { + VDMAGIC_PSEUDO, /* Pseudo Driver */ + "uni_mod", /* name */ + NULL, /* dev_ops */ + NULL, /* bdevsw */ + NULL, /* cdevsw */ + 0, /* blockmajor */ + 0 /* charmajor */ +}; + + +/* + * Loadable module support entry point + * + * This is the routine called by the vd driver for all loadable module + * functions for this pseudo driver. This routine name must be specified + * on the modload(1) command. This routine will be called whenever the + * modload(1), modunload(1) or modstat(1) commands are issued for this + * module. + * + * Arguments: + * cmd vd command code + * vdp pointer to vd driver's structure + * vdi pointer to command-specific vdioctl_* structure + * vds pointer to status structure (VDSTAT only) + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +int +uni_mod(cmd, vdp, vdi, vds) + int cmd; + struct vddrv *vdp; + caddr_t vdi; + struct vdstat *vds; +{ + int err = 0; + + switch (cmd) { + + case VDLOAD: + /* + * Module Load + * + * We dont support any user configuration + */ + err = uni_doload(); + if (err == 0) + /* Let vd driver know about us */ + vdp->vdd_vdtab = (struct vdlinkage *)&uni_drv; + break; + + case VDUNLOAD: + /* + * Module Unload + */ + err = uni_dounload(); + break; + + case VDSTAT: + /* + * Module Status + */ + + /* Not much to say at the moment */ + + break; + + default: + log(LOG_ERR, "uni_mod: Unknown vd command 0x%x\n", cmd); + err = EINVAL; + } + + return (err); +} +#endif /* sun */ + +#ifdef __FreeBSD__ + +#include <sys/exec.h> +#include <sys/sysent.h> +#include <sys/lkm.h> + +/* + * Loadable miscellaneous module description + */ +MOD_MISC(uni); + + +/* + * Loadable module support "load" entry point + * + * This is the routine called by the lkm driver whenever the + * modload(1) command is issued for this module. + * + * Arguments: + * lkmtp pointer to lkm drivers's structure + * cmd lkm command code + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +static int +uni_load(lkmtp, cmd) + struct lkm_table *lkmtp; + int cmd; +{ + return(uni_doload()); +} + + +/* + * Loadable module support "unload" entry point + * + * This is the routine called by the lkm driver whenever the + * modunload(1) command is issued for this module. + * + * Arguments: + * lkmtp pointer to lkm drivers's structure + * cmd lkm command code + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +static int +uni_unload(lkmtp, cmd) + struct lkm_table *lkmtp; + int cmd; +{ + return(uni_dounload()); +} + + +/* + * Loadable module support entry point + * + * This is the routine called by the lkm driver for all loadable module + * functions for this driver. This routine name must be specified + * on the modload(1) command. This routine will be called whenever the + * modload(1), modunload(1) or modstat(1) commands are issued for this + * module. + * + * Arguments: + * lkmtp pointer to lkm drivers's structure + * cmd lkm command code + * ver lkm version + * + * Returns: + * 0 command was successful + * errno command failed - reason indicated + * + */ +int +uni_mod(lkmtp, cmd, ver) + struct lkm_table *lkmtp; + int cmd; + int ver; +{ + MOD_DISPATCH(uni, lkmtp, cmd, ver, + uni_load, uni_unload, lkm_nullcmd); +} +#endif /* __FreeBSD__ */ + +#else /* !ATM_UNI_MODULE */ + +/* + ******************************************************************* + * + * Kernel Compiled Module Support + * + ******************************************************************* + */ +static void uni_doload __P((void *)); + +SYSINIT(atmuni, SI_SUB_PROTO_END, SI_ORDER_ANY, uni_doload, NULL) + +/* + * Kernel initialization + * + * Arguments: + * arg Not used + * + * Returns: + * none + * + */ +static void +uni_doload(void *arg) +{ + int err = 0; + + /* + * Start us up + */ + err = uni_start(); + if (err) { + /* Problems, clean up */ + (void)uni_stop(); + + log(LOG_ERR, "ATM UNI unable to initialize (%d)!!\n", err); + } + return; +} +#endif /* ATM_UNI_MODULE */ + diff --git a/sys/netatm/uni/uniarp.c b/sys/netatm/uni/uniarp.c new file mode 100644 index 0000000..f316a73 --- /dev/null +++ b/sys/netatm/uni/uniarp.c @@ -0,0 +1,1231 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: uniarp.c,v 1.10 1998/07/20 18:58:45 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * UNI ATMARP support (RFC1577) + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: uniarp.c,v 1.10 1998/07/20 18:58:45 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/uniip_var.h> + + +/* + * Global variables + */ +struct uniarp *uniarp_arptab[UNIARP_HASHSIZ] = {NULL}; +struct uniarp *uniarp_nomaptab = NULL; +struct uniarp *uniarp_pvctab = NULL; +struct atm_time uniarp_timer = {0, 0}; /* Aging timer */ +struct uniarp_stat uniarp_stat = {0}; +int uniarp_print = 0; + +Atm_endpoint uniarp_endpt = { + NULL, + ENDPT_ATMARP, + uniarp_ioctl, + uniarp_getname, + uniarp_connected, + uniarp_cleared, + NULL, + NULL, + NULL, + NULL, + uniarp_cpcs_data, + NULL, + NULL, + NULL, + NULL +}; + +struct sp_info uniarp_pool = { + "uni arp pool", /* si_name */ + sizeof(struct uniarp), /* si_blksiz */ + 10, /* si_blkcnt */ + 200 /* si_maxallow */ +}; + + +/* + * Local variables + */ +static void uniarp_server_mode __P((struct uniip *)); +static void uniarp_client_mode __P((struct uniip *, Atm_addr *)); + + +/* + * Process module loading notification + * + * Called whenever the uni module is initializing. + * + * Arguments: + * none + * + * Returns: + * 0 initialization successful + * errno initialization failed - reason indicated + * + */ +int +uniarp_start() +{ + int err; + + /* + * Register our endpoint + */ + err = atm_endpoint_register(&uniarp_endpt); + + return (err); +} + + +/* + * Process module unloading notification + * + * Called whenever the uni module is about to be unloaded. All signalling + * instances will have been previously detached. All uniarp resources + * must be freed now. + * + * Arguments: + * none + * + * Returns: + * none + * + */ +void +uniarp_stop() +{ + int i; + + /* + * Make sure the arp table is empty + */ + for (i = 0; i < UNIARP_HASHSIZ; i++) { + if (uniarp_arptab[i] != NULL) + panic("uniarp_stop: arp table not empty"); + } + + /* + * Cancel timers + */ + (void) atm_untimeout(&uniarp_timer); + + /* + * De-register ourselves + */ + (void) atm_endpoint_deregister(&uniarp_endpt); + + /* + * Free our storage pools + */ + atm_release_pool(&uniarp_pool); +} + + +/* + * Process IP Network Interface Activation + * + * Called whenever an IP network interface becomes active. + * + * Called at splnet. + * + * Arguments: + * uip pointer to UNI IP interface + * + * Returns: + * none + * + */ +void +uniarp_ipact(uip) + struct uniip *uip; +{ + struct unisig *usp; + + ATM_DEBUG1("uniarp_ipact: uip=0x%x\n", (int)uip); + + /* + * Set initial state + */ + uip->uip_arpstate = UIAS_NOTCONF; + uip->uip_arpsvratm.address_format = T_ATM_ABSENT; + uip->uip_arpsvratm.address_length = 0; + uip->uip_arpsvrsub.address_format = T_ATM_ABSENT; + uip->uip_arpsvrsub.address_length = 0; + + usp = (struct unisig *)uip->uip_ipnif->inf_nif->nif_pif->pif_siginst; + if (usp->us_addr.address_format != T_ATM_ABSENT) + uip->uip_flags |= UIF_IFADDR; + + /* + * Make sure aging timer is running + */ + if ((uniarp_timer.ti_flag & TIF_QUEUED) == 0) + atm_timeout(&uniarp_timer, UNIARP_AGING, uniarp_aging); + + return; +} + + +/* + * Process IP Network Interface Deactivation + * + * Called whenever an IP network interface becomes inactive. All VCCs + * for this interface should already have been closed. + * + * Called at splnet. + * + * Arguments: + * uip pointer to UNI IP interface + * + * Returns: + * none + * + */ +void +uniarp_ipdact(uip) + struct uniip *uip; +{ + struct ip_nif *inp = uip->uip_ipnif; + struct uniarp *uap, *unext; + int i; + + ATM_DEBUG1("uniarp_ipdact: uip=0x%x\n", (int)uip); + + /* + * Delete all interface entries + */ + for (i = 0; i < UNIARP_HASHSIZ; i++) { + for (uap = uniarp_arptab[i]; uap; uap = unext) { + unext = uap->ua_next; + + if (uap->ua_intf != uip) + continue; + + /* + * All VCCs should (better) be gone by now + */ + if (uap->ua_ivp) + panic("uniarp_ipdact: entry not empty"); + + /* + * Clean up any loose ends + */ + UNIARP_CANCEL(uap); + + /* + * Delete entry from arp table and free entry + */ + UNIARP_DELETE(uap); + atm_free((caddr_t)uap); + } + } + + /* + * Clean up 'nomap' table + */ + for (uap = uniarp_nomaptab; uap; uap = unext) { + unext = uap->ua_next; + + if (uap->ua_intf != uip) + continue; + + /* + * All VCCs should (better) be gone by now + */ + if (uap->ua_ivp) + panic("uniarp_ipdact: entry not empty"); + + /* + * Clean up any loose ends + */ + UNIARP_CANCEL(uap); + + /* + * Delete entry from 'no map' table and free entry + */ + UNLINK(uap, struct uniarp, uniarp_nomaptab, ua_next); + atm_free((caddr_t)uap); + } + + /* + * Also clean up pvc table + */ + for (uap = uniarp_pvctab; uap; uap = unext) { + unext = uap->ua_next; + + if (uap->ua_intf != uip) + continue; + + /* + * All PVCs should (better) be gone by now + */ + panic("uniarp_ipdact: pvc table not empty"); + } + + /* + * Cancel arp interface timer + */ + UNIIP_ARP_CANCEL(uip); + + /* + * Stop aging timer if this is the last active interface + */ + if (uniip_head == uip && uip->uip_next == NULL) + (void) atm_untimeout(&uniarp_timer); +} + + +/* + * Process Interface ATM Address Change + * + * This function is called whenever the ATM address for a physical + * interface is set/changed. + * + * Called at splnet. + * + * Arguments: + * sip pointer to interface's UNI signalling instance + * + * Returns: + * none + * + */ +void +uniarp_ifaddr(sip) + struct siginst *sip; +{ + struct atm_nif *nip; + struct uniip *uip; + + ATM_DEBUG1("uniarp_ifaddr: sip=0x%x\n", (int)sip); + + /* + * We've got to handle this for every network interface + */ + for (nip = sip->si_pif->pif_nif; nip; nip = nip->nif_pnext) { + + /* + * Find our control blocks + */ + for (uip = uniip_head; uip; uip = uip->uip_next) { + if (uip->uip_ipnif->inf_nif == nip) + break; + } + if (uip == NULL) + continue; + + /* + * We don't support changing prefix (yet) + */ + if (uip->uip_flags & UIF_IFADDR) { + log(LOG_ERR, "uniarp_ifaddr: change not supported\n"); + continue; + } + + /* + * Note that address has been set and figure out what + * to do next + */ + uip->uip_flags |= UIF_IFADDR; + + if (uip->uip_arpstate == UIAS_CLIENT_PADDR) { + /* + * This is what we're waiting for + */ + uniarp_client_mode(uip, NULL); + } + } + + return; +} + + +/* + * Set ATMARP Server Mode + * + * This function is called to configure the local node to become the + * ATMARP server for the specified LIS. + * + * Called at splnet. + * + * Arguments: + * uip pointer to UNI IP interface + * + * Returns: + * none + * + */ +static void +uniarp_server_mode(uip) + struct uniip *uip; +{ + struct ip_nif *inp; + struct atm_nif *nip; + struct siginst *sgp; + struct ipvcc *ivp, *inext; + struct uniarp *uap, *unext; + int i; + + ATM_DEBUG1("uniarp_server_mode: uip=0x%x\n", (int)uip); + + /* + * Handle client/server mode changes first + */ + switch (uip->uip_arpstate) { + + case UIAS_NOTCONF: + case UIAS_SERVER_ACTIVE: + case UIAS_CLIENT_PADDR: + /* + * Nothing to undo + */ + break; + + case UIAS_CLIENT_POPEN: + /* + * We're becoming the server, so kill the pending connection + */ + UNIIP_ARP_CANCEL(uip); + if (ivp = uip->uip_arpsvrvcc) { + ivp->iv_flags &= ~IVF_NOIDLE; + uip->uip_arpsvrvcc = NULL; + (*ivp->iv_ipnif->inf_arpnotify)(ivp, MAP_FAILED); + } + break; + + case UIAS_CLIENT_REGISTER: + case UIAS_CLIENT_ACTIVE: + /* + * We're becoming the server, but leave existing VCC as a + * "normal" IP VCC + */ + UNIIP_ARP_CANCEL(uip); + ivp = uip->uip_arpsvrvcc; + ivp->iv_flags &= ~IVF_NOIDLE; + uip->uip_arpsvrvcc = NULL; + break; + } + + /* + * Revalidate status for all arp entries on this interface + */ + for (i = 0; i < UNIARP_HASHSIZ; i++) { + for (uap = uniarp_arptab[i]; uap; uap = unext) { + unext = uap->ua_next; + + if (uap->ua_intf != uip) + continue; + + if (uap->ua_origin >= UAO_PERM) + continue; + + if (uap->ua_origin >= UAO_SCSP) { + if (uniarp_validate_ip(uip, &uap->ua_dstip, + uap->ua_origin) == 0) + continue; + } + + if (uap->ua_ivp == NULL) { + UNIARP_CANCEL(uap); + UNIARP_DELETE(uap); + atm_free((caddr_t)uap); + continue; + } + + if (uap->ua_flags & UAF_VALID) { + uap->ua_flags |= UAF_LOCKED; + for (ivp = uap->ua_ivp; ivp; ivp = inext) { + inext = ivp->iv_arpnext; + (*ivp->iv_ipnif->inf_arpnotify) + (ivp, MAP_INVALID); + } + uap->ua_flags &= ~(UAF_LOCKED | UAF_VALID); + } + uap->ua_aging = 1; + uap->ua_origin = 0; + } + } + + /* + * OK, now let's make ourselves the server + */ + inp = uip->uip_ipnif; + nip = inp->inf_nif; + sgp = nip->nif_pif->pif_siginst; + ATM_ADDR_SEL_COPY(&sgp->si_addr, nip->nif_sel, &uip->uip_arpsvratm); + uip->uip_arpsvrip = IA_SIN(inp->inf_addr)->sin_addr; + uip->uip_arpstate = UIAS_SERVER_ACTIVE; + return; +} + + +/* + * Set ATMARP Client Mode + * + * This function is called to configure the local node to be an ATMARP + * client on the specified LIS using the specified ATMARP server. + * + * Called at splnet. + * + * Arguments: + * uip pointer to UNI IP interface + * aap pointer to the ATMARP server's ATM address + * + * Returns: + * none + * + */ +static void +uniarp_client_mode(uip, aap) + struct uniip *uip; + Atm_addr *aap; +{ + struct ip_nif *inp = uip->uip_ipnif; + struct uniarp *uap, *unext; + struct ipvcc *ivp, *inext; + int i; + + ATM_DEBUG2("uniarp_client_mode: uip=0x%x, atm=(%s,-)\n", + (int)uip, aap ? unisig_addr_print(aap): "-"); + + /* + * Handle client/server mode changes first + */ + switch (uip->uip_arpstate) { + + case UIAS_NOTCONF: + case UIAS_CLIENT_PADDR: + /* + * Nothing to undo + */ + break; + + case UIAS_CLIENT_POPEN: + /* + * If this is this a timeout retry, just go do it + */ + if (aap == NULL) + break; + + /* + * If this isn't really a different arpserver, we're done + */ + if (ATM_ADDR_EQUAL(aap, &uip->uip_arpsvratm)) + return; + + /* + * We're changing servers, so kill the pending connection + */ + UNIIP_ARP_CANCEL(uip); + if (ivp = uip->uip_arpsvrvcc) { + ivp->iv_flags &= ~IVF_NOIDLE; + uip->uip_arpsvrvcc = NULL; + (*ivp->iv_ipnif->inf_arpnotify)(ivp, MAP_FAILED); + } + break; + + case UIAS_CLIENT_REGISTER: + case UIAS_CLIENT_ACTIVE: + /* + * If this isn't really a different arpserver, we're done + */ + if (ATM_ADDR_EQUAL(aap, &uip->uip_arpsvratm)) + return; + + /* + * We're changing servers, but leave existing VCC as a + * "normal" IP VCC + */ + UNIIP_ARP_CANCEL(uip); + ivp = uip->uip_arpsvrvcc; + ivp->iv_flags &= ~IVF_NOIDLE; + uip->uip_arpsvrvcc = NULL; + break; + + case UIAS_SERVER_ACTIVE: + /* + * We're changing from server mode, so... + * + * Reset valid/authoritative status for all arp entries + * on this interface + */ + for (i = 0; i < UNIARP_HASHSIZ; i++) { + for (uap = uniarp_arptab[i]; uap; uap = unext) { + unext = uap->ua_next; + + if (uap->ua_intf != uip) + continue; + + if (uap->ua_origin >= UAO_PERM) + continue; + + if (uap->ua_ivp == NULL) { + UNIARP_CANCEL(uap); + UNIARP_DELETE(uap); + atm_free((caddr_t)uap); + continue; + } + + if (uap->ua_flags & UAF_VALID) { + uap->ua_flags |= UAF_LOCKED; + for (ivp = uap->ua_ivp; ivp; + ivp = inext) { + inext = ivp->iv_arpnext; + (*ivp->iv_ipnif->inf_arpnotify) + (ivp, MAP_INVALID); + } + uap->ua_flags &= + ~(UAF_LOCKED | UAF_VALID); + } + uap->ua_aging = 1; + uap->ua_origin = 0; + } + } + uip->uip_arpsvratm.address_format = T_ATM_ABSENT; + uip->uip_arpsvratm.address_length = 0; + uip->uip_arpsvrsub.address_format = T_ATM_ABSENT; + uip->uip_arpsvrsub.address_length = 0; + uip->uip_arpsvrip.s_addr = 0; + break; + } + + /* + * Save the arp server address, if supplied now + */ + if (aap) + ATM_ADDR_COPY(aap, &uip->uip_arpsvratm); + + /* + * If the interface's ATM address isn't set yet, then we + * can't do much until it is + */ + if ((uip->uip_flags & UIF_IFADDR) == 0) { + uip->uip_arpstate = UIAS_CLIENT_PADDR; + return; + } + + /* + * Just to keep things simple, if we already have (or are trying to + * setup) any SVCs to our new server, kill the connections so we can + * open a "fresh" SVC for the arpserver connection. + */ + for (i = 0; i < UNIARP_HASHSIZ; i++) { + for (uap = uniarp_arptab[i]; uap; uap = unext) { + unext = uap->ua_next; + + if (ATM_ADDR_EQUAL(&uip->uip_arpsvratm, + &uap->ua_dstatm) && + ATM_ADDR_EQUAL(&uip->uip_arpsvrsub, + &uap->ua_dstatmsub)) { + uap->ua_flags &= ~UAF_VALID; + for (ivp = uap->ua_ivp; ivp; ivp = inext) { + inext = ivp->iv_arpnext; + (*inp->inf_arpnotify)(ivp, MAP_FAILED); + } + } + } + } + for (uap = uniarp_nomaptab; uap; uap = unext) { + unext = uap->ua_next; + + if (ATM_ADDR_EQUAL(&uip->uip_arpsvratm, &uap->ua_dstatm) && + ATM_ADDR_EQUAL(&uip->uip_arpsvrsub, &uap->ua_dstatmsub)) { + uap->ua_flags &= ~UAF_VALID; + for (ivp = uap->ua_ivp; ivp; ivp = inext) { + inext = ivp->iv_arpnext; + (*inp->inf_arpnotify)(ivp, MAP_FAILED); + } + } + } + + /* + * Now, get an arp entry for the server connection + */ + uip->uip_arpstate = UIAS_CLIENT_POPEN; + uap = (struct uniarp *)atm_allocate(&uniarp_pool); + if (uap == NULL) { + UNIIP_ARP_TIMER(uip, 1 * ATM_HZ); + return; + } + + /* + * Next, initiate an SVC to the server + */ + if ((*inp->inf_createsvc)(&inp->inf_nif->nif_if, AF_ATM, + (caddr_t)&uip->uip_arpsvratm, &ivp)) { + atm_free((caddr_t)uap); + UNIIP_ARP_TIMER(uip, 1 * ATM_HZ); + return; + } + + /* + * Finally, get everything set up and wait for the SVC + * connection to complete + */ + uip->uip_arpsvrvcc = ivp; + ivp->iv_flags |= IVF_NOIDLE; + + ATM_ADDR_COPY(&uip->uip_arpsvratm, &uap->ua_dstatm); + ATM_ADDR_COPY(&uip->uip_arpsvrsub, &uap->ua_dstatmsub); + uap->ua_intf = uip; + + LINK2TAIL(ivp, struct ipvcc, uap->ua_ivp, iv_arpnext); + ivp->iv_arpent = (struct arpmap *)uap; + + LINK2TAIL(uap, struct uniarp, uniarp_nomaptab, ua_next); + + return; +} + + +/* + * Process a UNI ARP interface timeout + * + * Called when a previously scheduled uniip arp interface timer expires. + * Processing will be based on the current uniip arp state. + * + * Called at splnet. + * + * Arguments: + * tip pointer to uniip arp timer control block + * + * Returns: + * none + * + */ +void +uniarp_iftimeout(tip) + struct atm_time *tip; +{ + struct ip_nif *inp; + struct uniip *uip; + + + /* + * Back-off to uniip control block + */ + uip = (struct uniip *) + ((caddr_t)tip - (int)(&((struct uniip *)0)->uip_arptime)); + + ATM_DEBUG2("uniarp_iftimeout: uip=0x%x, state=%d\n", (int)uip, + uip->uip_arpstate); + + /* + * Process timeout based on protocol state + */ + switch (uip->uip_arpstate) { + + case UIAS_CLIENT_POPEN: + /* + * Retry opening arp server connection + */ + uniarp_client_mode(uip, NULL); + break; + + case UIAS_CLIENT_REGISTER: + /* + * Resend registration request + */ + inp = uip->uip_ipnif; + (void) uniarp_arp_req(uip, &(IA_SIN(inp->inf_addr)->sin_addr)); + + /* + * Restart timer + */ + UNIIP_ARP_TIMER(uip, 2 * ATM_HZ); + + break; + + case UIAS_CLIENT_ACTIVE: + /* + * Refresh our registration + */ + inp = uip->uip_ipnif; + (void) uniarp_arp_req(uip, &(IA_SIN(inp->inf_addr)->sin_addr)); + + /* + * Restart timer + */ + UNIIP_ARP_TIMER(uip, UNIARP_REGIS_RETRY); + + break; + + default: + log(LOG_ERR, "uniarp_iftimeout: invalid state %d\n", + uip->uip_arpstate); + } +} + + +/* + * UNI ARP IOCTL support + * + * Function will be called at splnet. + * + * Arguments: + * code PF_ATM sub-operation code + * data pointer to code specific parameter data area + * arg1 pointer to code specific argument + * + * Returns: + * 0 request procesed + * errno error processing request - reason indicated + * + */ +int +uniarp_ioctl(code, data, arg1) + int code; + caddr_t data; + caddr_t arg1; +{ + struct atmaddreq *aap; + struct atmdelreq *adp; + struct atmsetreq *asp; + struct atminfreq *aip; + struct air_arp_rsp aar; + struct air_asrv_rsp asr; + struct atm_pif *pip; + struct atm_nif *nip; + struct ipvcc *ivp, *inext; + struct uniip *uip; + struct uniarp *uap; + struct unisig *usp; + struct in_addr ip; + Atm_addr atmsub; + u_long dst; + int err = 0, i, buf_len; + caddr_t buf_addr; + + switch (code) { + + case AIOCS_ADD_ARP: + /* + * Add a permanent ARP mapping + */ + aap = (struct atmaddreq *)data; + uip = (struct uniip *)arg1; + if (aap->aar_arp_addr.address_format != T_ATM_ENDSYS_ADDR) { + err = EINVAL; + break; + } + atmsub.address_format = T_ATM_ABSENT; + atmsub.address_length = 0; + ip = SATOSIN(&aap->aar_arp_dst)->sin_addr; + + /* + * Validate IP address + */ + if (uniarp_validate_ip(uip, &ip, aap->aar_arp_origin) != 0) { + err = EADDRNOTAVAIL; + break; + } + + /* + * Add an entry to the cache + */ + err = uniarp_cache_svc(uip, &ip, &aap->aar_arp_addr, + &atmsub, aap->aar_arp_origin); + break; + + case AIOCS_DEL_ARP: + /* + * Delete an ARP mapping + */ + adp = (struct atmdelreq *)data; + uip = (struct uniip *)arg1; + ip = SATOSIN(&adp->adr_arp_dst)->sin_addr; + + /* + * Now find the entry to be deleted + */ + UNIARP_LOOKUP(ip.s_addr, uap); + if (uap == NULL) { + err = ENOENT; + break; + } + + /* + * Notify all VCCs using this entry that they must finish + * up now. + */ + uap->ua_flags |= UAF_LOCKED; + for (ivp = uap->ua_ivp; ivp; ivp = inext) { + inext = ivp->iv_arpnext; + (*ivp->iv_ipnif->inf_arpnotify)(ivp, MAP_FAILED); + } + + /* + * Now free up the entry + */ + UNIARP_CANCEL(uap); + UNIARP_DELETE(uap); + atm_free((caddr_t)uap); + break; + + case AIOCS_SET_ASV: + /* + * Set interface ARP server address + */ + asp = (struct atmsetreq *)data; + for (uip = uniip_head; uip; uip = uip->uip_next) { + if (uip->uip_ipnif->inf_nif == (struct atm_nif *)arg1) + break; + } + if (uip == NULL) { + err = ENOPROTOOPT; + break; + } + + /* + * Check for our own address + */ + usp = (struct unisig *) + uip->uip_ipnif->inf_nif->nif_pif->pif_siginst; + if (ATM_ADDR_EQUAL(&asp->asr_arp_addr, &usp->us_addr)) { + asp->asr_arp_addr.address_format = T_ATM_ABSENT; + } + + /* + * If we're going into server mode, make sure we can get + * the memory for the prefix list before continuing + */ + if (asp->asr_arp_addr.address_format == T_ATM_ABSENT) { + i = asp->asr_arp_plen / sizeof(struct uniarp_prf); + if (i <= 0) { + err = EINVAL; + break; + } + buf_len = i * sizeof(struct uniarp_prf); + buf_addr = KM_ALLOC(buf_len, M_DEVBUF, M_NOWAIT); + if (buf_addr == NULL) { + err = ENOMEM; + break; + } + err = copyin(asp->asr_arp_pbuf, buf_addr, buf_len); + if (err) { + KM_FREE(buf_addr, buf_len, M_DEVBUF); + break; + } + } else { + /* Silence the compiler */ + i = 0; + buf_addr = NULL; + } + + /* + * Free any existing prefix address list + */ + if (uip->uip_prefix != NULL) { + KM_FREE(uip->uip_prefix, + uip->uip_nprefix * sizeof(struct uniarp_prf), + M_DEVBUF); + uip->uip_prefix = NULL; + uip->uip_nprefix = 0; + } + + if (asp->asr_arp_addr.address_format == T_ATM_ABSENT) { + /* + * Set ATMARP server mode + */ + uip->uip_prefix = (struct uniarp_prf *)buf_addr; + uip->uip_nprefix = i; + uniarp_server_mode(uip); + } else + /* + * Set ATMARP client mode + */ + uniarp_client_mode(uip, &asp->asr_arp_addr); + break; + + case AIOCS_INF_ARP: + /* + * Get ARP table information + */ + aip = (struct atminfreq *)data; + + if (aip->air_arp_addr.sa_family != AF_INET) + break; + dst = SATOSIN(&aip->air_arp_addr)->sin_addr.s_addr; + + buf_addr = aip->air_buf_addr; + buf_len = aip->air_buf_len; + + pip = ((struct siginst *)arg1)->si_pif; + + /* + * Run through entire arp table + */ + for (i = 0; i < UNIARP_HASHSIZ; i++) { + for (uap = uniarp_arptab[i]; uap; uap = uap->ua_next) { + /* + * We only want valid entries learned + * from the supplied interface. + */ + nip = uap->ua_intf->uip_ipnif->inf_nif; + if (nip->nif_pif != pip) + continue; + if ((dst != INADDR_ANY) && + (dst != uap->ua_dstip.s_addr)) + continue; + + /* + * Make sure there's room in the user's buffer + */ + if (buf_len < sizeof(aar)) { + err = ENOSPC; + break; + } + + /* + * Fill in info to be returned + */ + SATOSIN(&aar.aap_arp_addr)->sin_family = + AF_INET; + SATOSIN(&aar.aap_arp_addr)->sin_addr.s_addr = + uap->ua_dstip.s_addr; + (void) sprintf(aar.aap_intf, "%s%d", + nip->nif_if.if_name, + nip->nif_if.if_unit); + aar.aap_flags = uap->ua_flags; + aar.aap_origin = uap->ua_origin; + if (uap->ua_flags & UAF_VALID) + aar.aap_age = uap->ua_aging + + uap->ua_retry * UNIARP_RETRY_AGE; + else + aar.aap_age = 0; + ATM_ADDR_COPY(&uap->ua_dstatm, &aar.aap_addr); + ATM_ADDR_COPY(&uap->ua_dstatmsub, + &aar.aap_subaddr); + + /* + * Copy the response into the user's buffer + */ + if (err = copyout((caddr_t)&aar, buf_addr, + sizeof(aar))) + break; + buf_addr += sizeof(aar); + buf_len -= sizeof(aar); + } + if (err) + break; + } + + /* + * Now go through the 'nomap' table + */ + if (err || (dst != INADDR_ANY)) + goto updbuf; + for (uap = uniarp_nomaptab; uap; uap = uap->ua_next) { + /* + * We only want valid entries learned + * from the supplied interface. + */ + nip = uap->ua_intf->uip_ipnif->inf_nif; + if (nip->nif_pif != pip) + continue; + + /* + * Make sure there's room in the user's buffer + */ + if (buf_len < sizeof(aar)) { + err = ENOSPC; + break; + } + + /* + * Fill in info to be returned + */ + SATOSIN(&aar.aap_arp_addr)->sin_family = AF_INET; + SATOSIN(&aar.aap_arp_addr)->sin_addr.s_addr = 0; + (void) sprintf(aar.aap_intf, "%s%d", + nip->nif_if.if_name, nip->nif_if.if_unit); + aar.aap_flags = 0; + aar.aap_origin = uap->ua_origin; + aar.aap_age = 0; + ATM_ADDR_COPY(&uap->ua_dstatm, &aar.aap_addr); + ATM_ADDR_COPY(&uap->ua_dstatmsub, + &aar.aap_subaddr); + + /* + * Copy the response into the user's buffer + */ + if (err = copyout((caddr_t)&aar, buf_addr, + sizeof(aar))) + break; + buf_addr += sizeof(aar); + buf_len -= sizeof(aar); + } + +updbuf: + /* + * Update the buffer pointer and length + */ + aip->air_buf_addr = buf_addr; + aip->air_buf_len = buf_len; + + /* + * If the user wants the refresh status reset and no + * errors have been encountered, then do the reset + */ + if ((err == 0) && (aip->air_arp_flags & ARP_RESET_REF)) { + for (i = 0; i < UNIARP_HASHSIZ; i++) { + for (uap = uniarp_arptab[i]; uap; + uap = uap->ua_next) { + /* + * We only want valid entries learned + * from the supplied interface. + */ + nip = uap->ua_intf->uip_ipnif->inf_nif; + if (nip->nif_pif != pip) + continue; + if ((dst != INADDR_ANY) && + (dst != uap->ua_dstip.s_addr)) + continue; + + /* + * Reset refresh flag + */ + uap->ua_flags &= ~UAF_REFRESH; + } + } + } + break; + + case AIOCS_INF_ASV: + /* + * Get ARP server information + */ + aip = (struct atminfreq *)data; + + buf_addr = aip->air_buf_addr; + buf_len = aip->air_buf_len; + + for (uip = uniip_head; uip; uip = uip->uip_next) { + + if ((arg1 != NULL) && + (uip->uip_ipnif->inf_nif != (struct atm_nif *)arg1)) + continue; + + /* + * Make sure there's room in the user's buffer + */ + if (buf_len < sizeof(asr)) { + err = ENOSPC; + break; + } + + /* + * Fill in info to be returned + */ + nip = uip->uip_ipnif->inf_nif; + (void) sprintf(asr.asp_intf, "%s%d", + nip->nif_if.if_name, nip->nif_if.if_unit); + asr.asp_state = uip->uip_arpstate; + if (uip->uip_arpstate == UIAS_SERVER_ACTIVE) { + asr.asp_addr.address_format = T_ATM_ABSENT; + asr.asp_addr.address_length = 0; + } else { + ATM_ADDR_COPY(&uip->uip_arpsvratm, + &asr.asp_addr); + } + asr.asp_subaddr.address_format = T_ATM_ABSENT; + asr.asp_subaddr.address_length = 0; + asr.asp_nprefix = uip->uip_nprefix; + + /* + * Copy the response into the user's buffer + */ + if (err = copyout((caddr_t)&asr, buf_addr, sizeof(asr))) + break; + buf_addr += sizeof(asr); + buf_len -= sizeof(asr); + + /* + * Copy the prefix list into the user's buffer + */ + if (uip->uip_nprefix) { + i = uip->uip_nprefix + * sizeof(struct uniarp_prf); + if (buf_len < i) { + err = ENOSPC; + break; + } + if (err = copyout(uip->uip_prefix, buf_addr, i)) + break; + buf_addr += i; + buf_len -= i; + } + } + + /* + * Update the buffer pointer and length + */ + aip->air_buf_addr = buf_addr; + aip->air_buf_len = buf_len; + break; + + default: + err = EOPNOTSUPP; + } + + return (err); +} + + +/* + * Get Connection's Application/Owner Name + * + * Arguments: + * tok uniarp connection token (pointer to ipvcc) + * + * Returns: + * addr pointer to string containing our name + * + */ +caddr_t +uniarp_getname(tok) + void *tok; +{ + return ("ATMARP"); +} + diff --git a/sys/netatm/uni/uniarp_cache.c b/sys/netatm/uni/uniarp_cache.c new file mode 100644 index 0000000..6c9537e --- /dev/null +++ b/sys/netatm/uni/uniarp_cache.c @@ -0,0 +1,420 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: uniarp_cache.c,v 1.8 1998/08/26 23:29:20 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * UNI ATMARP support (RFC1577) - ARP cache processing + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: uniarp_cache.c,v 1.8 1998/08/26 23:29:20 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/uniip_var.h> + + +/* + * Add data to the arp table cache + * + * Called at splnet. + * + * Arguments: + * uip pointer to UNI IP interface + * ip pointer to IP address structure + * atm pointer to ATM address structure + * atmsub pointer to ATM subaddress structure + * origin source of arp information + * + * Returns: + * 0 cache successfully updated + * else updated failed - reason indicated + * + */ +int +uniarp_cache_svc(uip, ip, atm, atmsub, origin) + struct uniip *uip; + struct in_addr *ip; + Atm_addr *atm; + Atm_addr *atmsub; + u_int origin; +{ + struct ip_nif *inp; + struct ipvcc *ivp, *inext, *itail; + struct uniarp *nouap, *ipuap; + char abuf[64]; + +#ifdef DIAGNOSTIC + strncpy(abuf, unisig_addr_print(atmsub), sizeof(abuf)); + ATM_DEBUG4("cache_svc: ip=%s, atm=(%s,%s), origin=%d\n", + inet_ntoa(*ip), unisig_addr_print(atm), abuf, origin); +#endif + + /* + * Get interface info + */ + inp = uip->uip_ipnif; + + /* + * Find both cached entry and 'nomap' entries for this data. + */ + UNIARP_LOOKUP(ip->s_addr, ipuap); + for (nouap = uniarp_nomaptab; nouap; nouap = nouap->ua_next) { + if (ATM_ADDR_EQUAL(atm, &nouap->ua_dstatm) && + ATM_ADDR_EQUAL(atmsub, &nouap->ua_dstatmsub) && + (nouap->ua_intf == uip)) + break; + } + + /* + * If there aren't any entries yet, create one + */ + if ((ipuap == NULL) && (nouap == NULL)) { + ipuap = (struct uniarp *)atm_allocate(&uniarp_pool); + if (ipuap == NULL) + return (ENOMEM); + ipuap->ua_dstip.s_addr = ip->s_addr; + ipuap->ua_dstatm.address_format = T_ATM_ABSENT; + ipuap->ua_dstatmsub.address_format = T_ATM_ABSENT; + ipuap->ua_intf = uip; + UNIARP_ADD(ipuap); + } + + /* + * If there's no cached mapping, then make the 'nomap' entry + * the new cached entry. + */ + if (ipuap == NULL) { + UNLINK(nouap, struct uniarp, uniarp_nomaptab, ua_next); + nouap->ua_dstip.s_addr = ip->s_addr; + ipuap = nouap; + nouap = NULL; + UNIARP_ADD(ipuap); + } + + /* + * We need to check the consistency of the new data with any + * cached data. So taking the easy case first, if there isn't + * an ATM address in the cache then we can skip all these checks. + */ + if (ipuap->ua_dstatm.address_format != T_ATM_ABSENT) { + /* + * See if the new data conflicts with what's in the cache + */ + if (ATM_ADDR_EQUAL(atm, &ipuap->ua_dstatm) && + ATM_ADDR_EQUAL(atmsub, &ipuap->ua_dstatmsub) && + (uip == ipuap->ua_intf)) { + /* + * No conflicts here + */ + goto dataok; + } + + /* + * Data conflict...how we deal with this depends on + * the origins of the conflicting data + */ + if (origin == ipuap->ua_origin) { + /* + * The new data has equal precedence - if there are + * any VCCs using this entry, then we reject this + * "duplicate IP address" update. + */ + if (ipuap->ua_ivp != NULL) { + strncpy(abuf, unisig_addr_print(atmsub), + sizeof(abuf)); + log(LOG_WARNING, + "uniarp: duplicate IP address %s from %s,%s\n", + inet_ntoa(*ip), unisig_addr_print(atm), + abuf); + return (EACCES); + } + + } else if (origin > ipuap->ua_origin) { + /* + * New data's origin has higher precedence, + * so accept the new mapping and notify IP/ATM + * that a mapping change has occurred. IP/ATM will + * close any VCC's which aren't waiting for this map. + */ + ipuap->ua_flags |= UAF_LOCKED; + for (ivp = ipuap->ua_ivp; ivp; ivp = inext) { + inext = ivp->iv_arpnext; + (*inp->inf_arpnotify)(ivp, MAP_CHANGED); + } + ipuap->ua_flags &= ~UAF_LOCKED; + } else { + /* + * New data is of lesser origin precedence, + * so we just reject the update attempt. + */ + return (EACCES); + } + + strncpy(abuf, unisig_addr_print(atmsub), sizeof(abuf)); + log(LOG_WARNING, + "uniarp: ATM address for %s changed to %s,%s\n", + inet_ntoa(*ip), unisig_addr_print(atm), abuf); + } + + /* + * Update the cache entry with the new data + */ + ATM_ADDR_COPY(atm, &ipuap->ua_dstatm); + ATM_ADDR_COPY(atmsub, &ipuap->ua_dstatmsub); + ipuap->ua_intf = uip; + +dataok: + /* + * Update cache data origin + */ + ipuap->ua_origin = MAX(ipuap->ua_origin, origin); + + /* + * Ok, now act on this new/updated cache data + */ + ipuap->ua_flags |= UAF_LOCKED; + + /* + * Save pointer to last VCC currently on cached entry chain that + * will need to be notified of the map becoming valid + */ + itail = NULL; + if ((ipuap->ua_flags & UAF_VALID) == 0) { + + for (itail = ipuap->ua_ivp; itail && itail->iv_arpnext; + itail = itail->iv_arpnext) { + } + } + + /* + * If there was a 'nomap' entry for this mapping, then we need to + * announce the new mapping to them first. + */ + if (nouap) { + + /* + * Move the VCCs from this entry to the cache entry and + * let them know there's a valid mapping now + */ + for (ivp = nouap->ua_ivp; ivp; ivp = inext) { + inext = ivp->iv_arpnext; + + UNLINK(ivp, struct ipvcc, nouap->ua_ivp, iv_arpnext); + + LINK2TAIL(ivp, struct ipvcc, ipuap->ua_ivp, iv_arpnext); + ivp->iv_arpent = (struct arpmap *)ipuap; + + (*inp->inf_arpnotify)(ivp, MAP_VALID); + } + + /* + * Unlink and free the 'nomap' entry + */ + UNLINK(nouap, struct uniarp, uniarp_nomaptab, ua_next); + UNIARP_CANCEL(nouap); + atm_free((caddr_t)nouap); + } + + /* + * Now, if this entry wasn't valid, notify the remaining VCCs + */ + if (itail) { + + for (ivp = ipuap->ua_ivp; ivp; ivp = inext) { + inext = ivp->iv_arpnext; + (*inp->inf_arpnotify)(ivp, MAP_VALID); + if (ivp == itail) + break; + } + } + ipuap->ua_flags &= ~UAF_LOCKED; + + /* + * We now have a valid cache entry, so cancel any retry timer + * and reset the aging timeout + */ + UNIARP_CANCEL(ipuap); + if ((ipuap->ua_origin == UAO_REGISTER) && (origin != UAO_REGISTER)) { + if (((ipuap->ua_flags & UAF_VALID) == 0) || + (ipuap->ua_aging <= + UNIARP_SERVER_AGE - UNIARP_MIN_REFRESH)) { + ipuap->ua_flags |= UAF_REFRESH; + ipuap->ua_aging = UNIARP_SERVER_AGE; + ipuap->ua_retry = UNIARP_SERVER_RETRY; + } + } else { + if (uip->uip_arpstate == UIAS_SERVER_ACTIVE) { + ipuap->ua_aging = UNIARP_SERVER_AGE; + ipuap->ua_retry = UNIARP_SERVER_RETRY; + } else { + ipuap->ua_aging = UNIARP_CLIENT_AGE; + ipuap->ua_retry = UNIARP_CLIENT_RETRY; + } + ipuap->ua_flags |= UAF_REFRESH; + } + ipuap->ua_flags |= UAF_VALID; + ipuap->ua_flags &= ~UAF_USED; + return (0); +} + + +/* + * Process ARP data from a PVC + * + * The arp table cache is never updated with PVC information. + * + * Called at splnet. + * + * Arguments: + * ivp pointer to input PVC's IPVCC control block + * ip pointer to IP address structure + * atm pointer to ATM address structure + * atmsub pointer to ATM subaddress structure + * + * Returns: + * none + * + */ +void +uniarp_cache_pvc(ivp, ip, atm, atmsub) + struct ipvcc *ivp; + struct in_addr *ip; + Atm_addr *atm; + Atm_addr *atmsub; +{ + struct ip_nif *inp; + struct uniarp *uap; + +#ifdef DIAGNOSTIC + char buf[64]; + int vpi = 0, vci = 0; + + if ((ivp->iv_conn) && (ivp->iv_conn->co_connvc)) { + vpi = ivp->iv_conn->co_connvc->cvc_vcc->vc_vpi; + vci = ivp->iv_conn->co_connvc->cvc_vcc->vc_vci; + } + strncpy(buf, unisig_addr_print(atmsub), sizeof(buf)); + ATM_DEBUG5("cache_pvc: vcc=(%d,%d), ip=%s, atm=(%s,%s)\n", + vpi, vci, inet_ntoa(*ip), unisig_addr_print(atm), buf); +#endif + + /* + * Get PVC info + */ + inp = ivp->iv_ipnif; + uap = (struct uniarp *)ivp->iv_arpent; + + /* + * See if IP address for PVC has changed + */ + if (uap->ua_dstip.s_addr != ip->s_addr) { + if (uap->ua_dstip.s_addr != 0) + (*inp->inf_arpnotify)(ivp, MAP_CHANGED); + uap->ua_dstip.s_addr = ip->s_addr; + } + + /* + * Let IP/ATM know if address has become valid + */ + if ((uap->ua_flags & UAF_VALID) == 0) + (*inp->inf_arpnotify)(ivp, MAP_VALID); + uap->ua_flags |= UAF_VALID; + uap->ua_aging = UNIARP_CLIENT_AGE; + uap->ua_retry = UNIARP_CLIENT_RETRY; + + /* + * Save ATM addresses just for debugging + */ + ATM_ADDR_COPY(atm, &uap->ua_dstatm); + ATM_ADDR_COPY(atmsub, &uap->ua_dstatmsub); + + return; +} + + +/* + * Validate IP address + * + * Arguments: + * uip pointer to UNI IP interface + * ip pointer to IP address structure + * origin source of arp information + * + * Returns: + * 0 IP address is acceptable + * else invalid IP address + * + */ +int +uniarp_validate_ip(uip, ip, origin) + struct uniip *uip; + struct in_addr *ip; + u_int origin; +{ + struct uniarp_prf *upp; + int i; + + + /* + * Can't be multicast or broadcast address + */ + if (IN_MULTICAST(ntohl(ip->s_addr)) || +#if (defined(BSD) && (BSD >= 199306)) + in_broadcast(*ip, &uip->uip_ipnif->inf_nif->nif_if)) +#else + in_broadcast(*ip)) +#endif + return (1); + + /* + * For ATMARP registration information (including SCSP data), + * the address must be allowed by the interface's prefix list. + */ + if ((origin == UAO_REGISTER) || (origin == UAO_SCSP)) { + for (i = uip->uip_nprefix, upp = uip->uip_prefix; + i; i--, upp++) { + if ((ip->s_addr & upp->upf_mask.s_addr) == + upp->upf_addr.s_addr) + break; + } + if (i == 0) + return (1); + } + + return (0); +} + diff --git a/sys/netatm/uni/uniarp_input.c b/sys/netatm/uni/uniarp_input.c new file mode 100644 index 0000000..cceeaa9 --- /dev/null +++ b/sys/netatm/uni/uniarp_input.c @@ -0,0 +1,853 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: uniarp_input.c,v 1.10 1998/07/13 00:04:32 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * UNI ATMARP support (RFC1577) - Input packet processing + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: uniarp_input.c,v 1.10 1998/07/13 00:04:32 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/uniip_var.h> + + +/* + * Local functions + */ +static void proc_arp_req __P((struct ipvcc *, KBuffer *)); +static void proc_arp_rsp __P((struct ipvcc *, KBuffer *)); +static void proc_arp_nak __P((struct ipvcc *, KBuffer *)); +static void proc_inarp_req __P((struct ipvcc *, KBuffer *)); +static void proc_inarp_rsp __P((struct ipvcc *, KBuffer *)); + + +/* + * Local variables + */ +static Atm_addr satm; +static Atm_addr satmsub; +static Atm_addr tatm; +static Atm_addr tatmsub; +static struct in_addr sip; +static struct in_addr tip; + + +/* + * Process ATMARP Input Data + * + * Arguments: + * tok uniarp connection token (pointer to ipvcc) + * m pointer to input packet buffer chain + * + * Returns: + * none + * + */ +void +uniarp_cpcs_data(tok, m) + void *tok; + KBuffer *m; +{ + struct ipvcc *ivp = tok; + struct atmarp_hdr *ahp; + KBuffer *n; + int len, plen = sizeof(struct atmarp_hdr); + +#ifdef DIAGNOSTIC + if (uniarp_print) + uniarp_pdu_print(ivp, m, "receive"); +#endif + + /* + * Verify IP's VCC state + */ + if (ivp->iv_state != IPVCC_ACTIVE) { + goto bad; + } + + /* + * Get the fixed fields together + */ + if (KB_LEN(m) < sizeof(struct atmarp_hdr)) { + KB_PULLUP(m, sizeof(struct atmarp_hdr), m); + if (m == NULL) + goto bad; + } + + KB_DATASTART(m, ahp, struct atmarp_hdr *); + + /* + * Initial packet verification + */ + if ((ahp->ah_hrd != htons(ARP_ATMFORUM)) || + (ahp->ah_pro != htons(ETHERTYPE_IP))) + goto bad; + + /* + * Verify/gather source address fields + */ + if (len = (ahp->ah_shtl & ARP_TL_LMASK)) { + if (ahp->ah_shtl & ARP_TL_E164) { + if (len > sizeof(struct atm_addr_e164)) + goto bad; + satm.address_format = T_ATM_E164_ADDR; + } else { + if (len != sizeof(struct atm_addr_nsap)) + goto bad; + satm.address_format = T_ATM_ENDSYS_ADDR; + } + satm.address_length = len; + if (KB_COPYDATA(m, plen, len, (caddr_t)satm.address)) + goto bad; + plen += len; + } else { + satm.address_format = T_ATM_ABSENT; + satm.address_length = 0; + } + + if (len = (ahp->ah_sstl & ARP_TL_LMASK)) { + if (((ahp->ah_sstl & ARP_TL_TMASK) != ARP_TL_NSAPA) || + (len != sizeof(struct atm_addr_nsap))) + goto bad; + satmsub.address_format = T_ATM_ENDSYS_ADDR; + satmsub.address_length = len; + if (KB_COPYDATA(m, plen, len, (caddr_t)satmsub.address)) + goto bad; + plen += len; + } else { + satmsub.address_format = T_ATM_ABSENT; + satmsub.address_length = 0; + } + + if (len = ahp->ah_spln) { + if (len != sizeof(struct in_addr)) + goto bad; + if (KB_COPYDATA(m, plen, len, (caddr_t)&sip)) + goto bad; + plen += len; + } else { + sip.s_addr = 0; + } + + /* + * Verify/gather target address fields + */ + if (len = (ahp->ah_thtl & ARP_TL_LMASK)) { + if (ahp->ah_thtl & ARP_TL_E164) { + if (len > sizeof(struct atm_addr_e164)) + goto bad; + tatm.address_format = T_ATM_E164_ADDR; + } else { + if (len != sizeof(struct atm_addr_nsap)) + goto bad; + tatm.address_format = T_ATM_ENDSYS_ADDR; + } + tatm.address_length = len; + if (KB_COPYDATA(m, plen, len, (caddr_t)tatm.address)) + goto bad; + plen += len; + } else { + tatm.address_format = T_ATM_ABSENT; + tatm.address_length = 0; + } + + if (len = (ahp->ah_tstl & ARP_TL_LMASK)) { + if (((ahp->ah_tstl & ARP_TL_TMASK) != ARP_TL_NSAPA) || + (len != sizeof(struct atm_addr_nsap))) + goto bad; + tatmsub.address_format = T_ATM_ENDSYS_ADDR; + tatmsub.address_length = len; + if (KB_COPYDATA(m, plen, len, (caddr_t)tatmsub.address)) + goto bad; + plen += len; + } else { + tatmsub.address_format = T_ATM_ABSENT; + tatmsub.address_length = 0; + } + + if (len = ahp->ah_tpln) { + if (len != sizeof(struct in_addr)) + goto bad; + if (KB_COPYDATA(m, plen, len, (caddr_t)&tip)) + goto bad; + plen += len; + } else { + tip.s_addr = 0; + } + + /* + * Verify packet length + */ + for (len = 0, n = m; n; n = KB_NEXT(n)) + len += KB_LEN(n); + if (len != plen) + goto bad; + + /* + * Now finish with packet-specific processing + */ + switch (ntohs(ahp->ah_op)) { + case ARP_REQUEST: + proc_arp_req(ivp, m); + break; + + case ARP_REPLY: + proc_arp_rsp(ivp, m); + break; + + case INARP_REQUEST: + proc_inarp_req(ivp, m); + break; + + case INARP_REPLY: + proc_inarp_rsp(ivp, m); + break; + + case ARP_NAK: + proc_arp_nak(ivp, m); + break; + + default: + goto bad; + } + + return; + +bad: + uniarp_stat.uas_rcvdrop++; + if (m) + KB_FREEALL(m); +} + + +/* + * Process an ATMARP request packet + * + * Arguments: + * ivp pointer to input VCC's IPVCC control block + * m pointer to input packet buffer chain + * + * Returns: + * none + * + */ +static void +proc_arp_req(ivp, m) + struct ipvcc *ivp; + KBuffer *m; +{ + struct ip_nif *inp; + struct atm_nif *nip; + struct siginst *sgp; + struct uniip *uip; + struct uniarp *uap; + struct in_addr myip; + int s = splnet(); + + /* + * Only an arp server should receive these + */ + inp = ivp->iv_ipnif; + nip = inp->inf_nif; + uip = (struct uniip *)inp->inf_isintf; + if ((uip == NULL) || + (uip->uip_arpstate != UIAS_SERVER_ACTIVE)) + goto drop; + + /* + * These should be sent only on SVCs + */ + if ((ivp->iv_flags & IVF_SVC) == 0) + goto drop; + + /* + * Locate our addresses + */ + sgp = nip->nif_pif->pif_siginst; + myip.s_addr = IA_SIN(inp->inf_addr)->sin_addr.s_addr; + + /* + * Target IP address must be present + */ + if (tip.s_addr == 0) + goto drop; + + /* + * Drop packet if both Source addresses aren't present + */ + if ((sip.s_addr == 0) || (satm.address_format == T_ATM_ABSENT)) + goto drop; + + /* + * Source addresses can't be ours + */ + if (ATM_ADDR_SEL_EQUAL(&sgp->si_addr, nip->nif_sel, &satm) && + ATM_ADDR_SEL_EQUAL(&sgp->si_subaddr, nip->nif_sel, &satmsub)) { + struct vccb *vcp = ivp->iv_conn->co_connvc->cvc_vcc; + + log(LOG_WARNING, + "uniarp: vcc=(%d,%d) reports our ATM address\n", + vcp->vc_vpi, vcp->vc_vci); + goto drop; + } + if (sip.s_addr == myip.s_addr) { + struct vccb *vcp = ivp->iv_conn->co_connvc->cvc_vcc; + + log(LOG_WARNING, + "uniarp: vcc=(%d,%d) reports our IP address\n", + vcp->vc_vpi, vcp->vc_vci); + goto drop; + } + + /* + * Validate Source IP address + */ + if (uniarp_validate_ip(uip, &sip, UAO_REGISTER) != 0) + goto drop; + + /* + * If the source and target IP addresses are the same, then this + * must be a client registration request (RFC-2225). Otherwise, + * try to accomodate old clients (per RFC-2225 8.4.4). + */ + if (sip.s_addr == tip.s_addr) + (void) uniarp_cache_svc(uip, &sip, &satm, &satmsub, + UAO_REGISTER); + else { + uap = (struct uniarp *)ivp->iv_arpent; + if ((uap == NULL) || (uap->ua_origin < UAO_REGISTER)) + (void) uniarp_cache_svc(uip, &sip, &satm, &satmsub, + UAO_REGISTER); + } + + /* + * Lookup the target IP address in the cache (and also check if + * the query is for our address). + */ + UNIARP_LOOKUP(tip.s_addr, uap); + if (uap && (uap->ua_flags & UAF_VALID)) { + /* + * We've found a valid mapping + */ + (void) uniarp_arp_rsp(uip, &uap->ua_arpmap, &sip, &satm, + &satmsub, ivp); + + } else if (tip.s_addr == myip.s_addr) { + /* + * We're the target, so respond accordingly + */ + (void) uniarp_arp_rsp(uip, &uip->uip_arpsvrmap, &sip, &satm, + &satmsub, ivp); + + } else { + /* + * We don't know who the target is, so NAK the query + */ + (void) uniarp_arp_nak(uip, m, ivp); + m = NULL; + } + +drop: + (void) splx(s); + if (m) + KB_FREEALL(m); + return; +} + + +/* + * Process an ATMARP reply packet + * + * Arguments: + * ivp pointer to input VCC's IPVCC control block + * m pointer to input packet buffer chain + * + * Returns: + * none + * + */ +static void +proc_arp_rsp(ivp, m) + struct ipvcc *ivp; + KBuffer *m; +{ + struct ip_nif *inp; + struct atm_nif *nip; + struct siginst *sgp; + struct uniip *uip; + struct uniarp *uap; + struct in_addr myip; + int s = splnet(); + + /* + * Only the arp server should send these + */ + inp = ivp->iv_ipnif; + nip = inp->inf_nif; + uip = (struct uniip *)inp->inf_isintf; + if ((uip == NULL) || + (uip->uip_arpsvrvcc != ivp)) + goto drop; + + /* + * Locate our addresses + */ + sgp = nip->nif_pif->pif_siginst; + myip.s_addr = IA_SIN(inp->inf_addr)->sin_addr.s_addr; + + /* + * Target addresses must be ours + */ + if ((tip.s_addr != myip.s_addr) || + !ATM_ADDR_SEL_EQUAL(&sgp->si_addr, nip->nif_sel, &tatm) || + !ATM_ADDR_SEL_EQUAL(&sgp->si_subaddr, nip->nif_sel, &tatmsub)) + goto drop; + + /* + * Drop packet if both Source addresses aren't present + */ + if ((sip.s_addr == 0) || (satm.address_format == T_ATM_ABSENT)) + goto drop; + + /* + * If the Source addresses are ours, this is an arp server + * registration response + */ + if (ATM_ADDR_SEL_EQUAL(&sgp->si_addr, nip->nif_sel, &satm) && + ATM_ADDR_SEL_EQUAL(&sgp->si_subaddr, nip->nif_sel, &satmsub)) { + if (sip.s_addr == myip.s_addr) { + /* + * Registration response - update our state and + * set a registration refresh timer + */ + if (uip->uip_arpstate == UIAS_CLIENT_REGISTER) + uip->uip_arpstate = UIAS_CLIENT_ACTIVE; + + if (uip->uip_arpstate == UIAS_CLIENT_ACTIVE) { + UNIIP_ARP_CANCEL(uip); + UNIIP_ARP_TIMER(uip, UNIARP_REGIS_REFRESH); + } + + /* + * If the cache entry for the server VCC isn't valid + * yet, then send an Inverse ATMARP request to solicit + * the server's IP address + */ + uap = (struct uniarp *)ivp->iv_arpent; + if ((uap->ua_flags & UAF_VALID) == 0) { + (void) uniarp_inarp_req(uip, &uap->ua_dstatm, + &uap->ua_dstatmsub, ivp); + } + goto drop; + } else { + log(LOG_WARNING, + "uniarp: arpserver has our IP address wrong\n"); + goto drop; + } + } else if (sip.s_addr == myip.s_addr) { + log(LOG_WARNING, + "uniarp: arpserver has our ATM address wrong\n"); + goto drop; + } + + /* + * Validate the Source IP address + */ + if (uniarp_validate_ip(uip, &sip, UAO_LOOKUP) != 0) + goto drop; + + /* + * Now we believe this packet contains an authoritative mapping, + * which we probably need to setup an outgoing SVC connection + */ + (void) uniarp_cache_svc(uip, &sip, &satm, &satmsub, UAO_LOOKUP); + +drop: + (void) splx(s); + KB_FREEALL(m); + return; +} + + +/* + * Process an ATMARP negative ack packet + * + * Arguments: + * ivp pointer to input VCC's IPVCC control block + * m pointer to input packet buffer chain + * + * Returns: + * none + * + */ +static void +proc_arp_nak(ivp, m) + struct ipvcc *ivp; + KBuffer *m; +{ + struct ip_nif *inp; + struct atm_nif *nip; + struct siginst *sgp; + struct uniip *uip; + struct uniarp *uap; + struct in_addr myip; + struct ipvcc *inext; + int s = splnet(); + + /* + * Only the arp server should send these + */ + inp = ivp->iv_ipnif; + nip = inp->inf_nif; + uip = (struct uniip *)inp->inf_isintf; + if ((uip == NULL) || + (uip->uip_arpsvrvcc != ivp)) + goto drop; + + /* + * Locate our addresses + */ + sgp = nip->nif_pif->pif_siginst; + myip.s_addr = IA_SIN(inp->inf_addr)->sin_addr.s_addr; + + /* + * Source addresses must be ours + */ + if ((sip.s_addr != myip.s_addr) || + !ATM_ADDR_SEL_EQUAL(&sgp->si_addr, nip->nif_sel, &satm) || + !ATM_ADDR_SEL_EQUAL(&sgp->si_subaddr, nip->nif_sel, &satmsub)) + goto drop; + + /* + * Drop packet if the Target IP address isn't there or if this + * is a registration response, indicating an old or flakey server + */ + if ((tip.s_addr == 0) || (tip.s_addr == myip.s_addr)) + goto drop; + + /* + * Otherwise, see who we were looking for + */ + UNIARP_LOOKUP(tip.s_addr, uap); + if (uap == NULL) + goto drop; + + /* + * This entry isn't valid any longer, so notify all VCCs using this + * entry that they must finish up. The last notify should cause + * this entry to be freed by the vcclose() function. + */ + uap->ua_flags &= ~UAF_VALID; + for (ivp = uap->ua_ivp; ivp; ivp = inext) { + inext = ivp->iv_arpnext; + (*inp->inf_arpnotify)(ivp, MAP_FAILED); + } + +drop: + (void) splx(s); + KB_FREEALL(m); + return; +} + + +/* + * Process an InATMARP request packet + * + * Arguments: + * ivp pointer to input VCC's IPVCC control block + * m pointer to input packet buffer chain + * + * Returns: + * none + * + */ +static void +proc_inarp_req(ivp, m) + struct ipvcc *ivp; + KBuffer *m; +{ + struct ip_nif *inp; + struct atm_nif *nip; + struct siginst *sgp; + struct uniip *uip; + struct in_addr myip; + int s = splnet(); + + /* + * Get interface pointers + */ + inp = ivp->iv_ipnif; + nip = inp->inf_nif; + uip = (struct uniip *)inp->inf_isintf; + if (uip == NULL) + goto drop; + + /* + * Locate our addresses + */ + sgp = nip->nif_pif->pif_siginst; + myip.s_addr = IA_SIN(inp->inf_addr)->sin_addr.s_addr; + + /* + * Packet must have a Source IP address and, if it was received + * over an SVC, a Source ATM address too. + */ + if ((sip.s_addr == 0) || + ((ivp->iv_flags & IVF_SVC) && (satm.address_format == T_ATM_ABSENT))) + goto drop; + + /* + * Validate Source ATM address + * - can't be me + */ + if (satm.address_format != T_ATM_ABSENT) { + if (ATM_ADDR_SEL_EQUAL(&sgp->si_addr, nip->nif_sel, &satm) && + ATM_ADDR_SEL_EQUAL(&sgp->si_subaddr, nip->nif_sel, + &satmsub)) + goto drop; + } + + /* + * Validate Source IP address + */ + if ((sip.s_addr == myip.s_addr) || + (uniarp_validate_ip(uip, &sip, UAO_PEER_REQ) != 0)) + goto drop; + + /* + * The Target ATM address is required for a packet received over + * an SVC, optional for a PVC. If one is present, it must be our + * address. + */ + if ((ivp->iv_flags & IVF_SVC) && (tatm.address_format == T_ATM_ABSENT)) + goto drop; + if ((tatm.address_format != T_ATM_ABSENT) && + (!ATM_ADDR_SEL_EQUAL(&sgp->si_addr, nip->nif_sel, &tatm) || + !ATM_ADDR_SEL_EQUAL(&sgp->si_subaddr, nip->nif_sel, &tatmsub))) + goto drop; + + /* + * See where this packet is from + */ + if (ivp->iv_flags & IVF_PVC) { + /* + * Process the PVC arp data, although we don't really + * update the arp cache with this information + */ + uniarp_cache_pvc(ivp, &sip, &satm, &satmsub); + + } else if (uip->uip_arpsvrvcc == ivp) { + /* + * Packet is from the arp server, so we've received a + * registration/refresh request (1577 version). + * + * Therefore, update cache with authoritative data. + */ + (void) uniarp_cache_svc(uip, &sip, &satm, &satmsub, UAO_LOOKUP); + + /* + * Make sure the cache update didn't kill the server VCC + */ + if (uip->uip_arpsvrvcc != ivp) + goto drop; + + /* + * Update the server state and set the + * registration refresh timer + */ + uip->uip_arpstate = UIAS_CLIENT_ACTIVE; + UNIIP_ARP_CANCEL(uip); + UNIIP_ARP_TIMER(uip, UNIARP_REGIS_REFRESH); + } else { + /* + * Otherwise, we consider this source mapping data as + * non-authoritative and update the cache appropriately + */ + if (uniarp_cache_svc(uip, &sip, &satm, &satmsub, UAO_PEER_REQ)) + goto drop; + } + + /* + * Send an InATMARP response back to originator + */ + (void) uniarp_inarp_rsp(uip, &sip, &satm, &satmsub, ivp); + +drop: + (void) splx(s); + KB_FREEALL(m); + return; +} + + +/* + * Process an InATMARP response packet + * + * Arguments: + * ivp pointer to input VCC's IPVCC control block + * m pointer to input packet buffer chain + * + * Returns: + * none + * + */ +static void +proc_inarp_rsp(ivp, m) + struct ipvcc *ivp; + KBuffer *m; +{ + struct ip_nif *inp; + struct atm_nif *nip; + struct siginst *sgp; + struct uniip *uip; + struct uniarp *uap; + struct in_addr myip; + int s = splnet(); + + /* + * Get interface pointers + */ + inp = ivp->iv_ipnif; + nip = inp->inf_nif; + uip = (struct uniip *)inp->inf_isintf; + if (uip == NULL) + goto drop; + + /* + * Locate our addresses + */ + sgp = nip->nif_pif->pif_siginst; + myip.s_addr = IA_SIN(inp->inf_addr)->sin_addr.s_addr; + + /* + * Packet must have a Source IP address and, if it was received + * over an SVC, a Source ATM address too. + */ + if ((sip.s_addr == 0) || + ((ivp->iv_flags & IVF_SVC) && (satm.address_format == T_ATM_ABSENT))) + goto drop; + + /* + * Validate Source ATM address + * - can't be me + */ + if (satm.address_format != T_ATM_ABSENT) { + if (ATM_ADDR_SEL_EQUAL(&sgp->si_addr, nip->nif_sel, &satm) && + ATM_ADDR_SEL_EQUAL(&sgp->si_subaddr, nip->nif_sel, + &satmsub)) + goto drop; + } + + /* + * Validate Source IP address + * - must be in our LIS + * - can't be me + * - can't be broadcast + * - can't be multicast + */ + if ((sip.s_addr == myip.s_addr) || + (uniarp_validate_ip(uip, &sip, UAO_PEER_RSP) != 0)) + goto drop; + + /* + * The Target ATM address is required for a packet received over + * an SVC, optional for a PVC. If one is present, it must be our + * address. + */ + if ((ivp->iv_flags & IVF_SVC) && (tatm.address_format == T_ATM_ABSENT)) + goto drop; + if ((tatm.address_format != T_ATM_ABSENT) && + (!ATM_ADDR_SEL_EQUAL(&sgp->si_addr, nip->nif_sel, &tatm) || + !ATM_ADDR_SEL_EQUAL(&sgp->si_subaddr, nip->nif_sel, &tatmsub))) + goto drop; + + /* + * See where this packet is from + */ + if (ivp->iv_flags & IVF_PVC) { + /* + * Process the PVC arp data, although we don't really + * update the arp cache with this information + */ + uniarp_cache_pvc(ivp, &sip, &satm, &satmsub); + + } else { + /* + * Can't tell the difference between an RFC-1577 registration + * and a data connection from a client of another arpserver + * on our LIS (using SCSP) - so we'll update the cache now + * with what we've got. Our clients will get "registered" + * when (if) they query us with an arp request. + */ + (void) uniarp_cache_svc(uip, &sip, &satm, &satmsub, + UAO_PEER_RSP); + } + +drop: + (void) splx(s); + KB_FREEALL(m); + return; +} + + +/* + * Print an ATMARP PDU + * + * Arguments: + * ivp pointer to input VCC control block + * m pointer to pdu buffer chain + * msg pointer to message string + * + * Returns: + * none + * + */ +void +uniarp_pdu_print(ivp, m, msg) + struct ipvcc *ivp; + KBuffer *m; + char *msg; +{ + char buf[128]; + struct vccb *vcp; + + vcp = ivp->iv_conn->co_connvc->cvc_vcc; + sprintf(buf, "uniarp %s: vcc=(%d,%d)\n", msg, vcp->vc_vpi, vcp->vc_vci); + atm_pdu_print(m, buf); +} + diff --git a/sys/netatm/uni/uniarp_output.c b/sys/netatm/uni/uniarp_output.c new file mode 100644 index 0000000..81fab93 --- /dev/null +++ b/sys/netatm/uni/uniarp_output.c @@ -0,0 +1,797 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: uniarp_output.c,v 1.7 1998/06/29 22:15:41 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * UNI ATMARP support (RFC1577) - Output packet processing + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: uniarp_output.c,v 1.7 1998/06/29 22:15:41 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> +#include <netatm/uni/uniip_var.h> + + +/* + * Issue an ATMARP Request PDU + * + * Arguments: + * uip pointer to IP interface + * tip pointer to target IP address + * + * Returns: + * 0 PDU was successfully sent + * else unable to send PDU + * + */ +int +uniarp_arp_req(uip, tip) + struct uniip *uip; + struct in_addr *tip; +{ + KBuffer *m; + struct atmarp_hdr *ahp; + struct atm_nif *nip; + struct ip_nif *inp; + struct ipvcc *ivp; + struct siginst *sip; + char *cp; + int len, err; + + inp = uip->uip_ipnif; + nip = inp->inf_nif; + sip = inp->inf_nif->nif_pif->pif_siginst; + + /* + * Figure out how long pdu is going to be + */ + len = sizeof(struct atmarp_hdr) + (2 * sizeof(struct in_addr)); + switch (sip->si_addr.address_format) { + case T_ATM_ENDSYS_ADDR: + len += sip->si_addr.address_length; + break; + + case T_ATM_E164_ADDR: + len += sip->si_addr.address_length; + if (sip->si_subaddr.address_format == T_ATM_ENDSYS_ADDR) + len += sip->si_subaddr.address_length; + break; + } + + /* + * Get a buffer for pdu + */ + KB_ALLOCPKT(m, len, KB_F_NOWAIT, KB_T_DATA); + if (m == NULL) + return (1); + + /* + * Place aligned pdu at end of buffer + */ + KB_TAILALIGN(m, len); + KB_DATASTART(m, ahp, struct atmarp_hdr *); + + /* + * Setup variable fields pointer + */ + cp = (char *)ahp + sizeof(struct atmarp_hdr); + + /* + * Build fields + */ + ahp->ah_hrd = htons(ARP_ATMFORUM); + ahp->ah_pro = htons(ETHERTYPE_IP); + len = sip->si_addr.address_length; + switch (sip->si_addr.address_format) { + case T_ATM_ENDSYS_ADDR: + ahp->ah_shtl = ARP_TL_NSAPA | (len & ARP_TL_LMASK); + + /* ah_sha */ + KM_COPY(sip->si_addr.address, cp, len - 1); + ((struct atm_addr_nsap *)cp)->aan_sel = nip->nif_sel; + cp += len; + + ahp->ah_sstl = 0; + break; + + case T_ATM_E164_ADDR: + ahp->ah_shtl = ARP_TL_E164 | (len & ARP_TL_LMASK); + + /* ah_sha */ + KM_COPY(sip->si_addr.address, cp, len); + cp += len; + + if (sip->si_subaddr.address_format == T_ATM_ENDSYS_ADDR) { + len = sip->si_subaddr.address_length; + ahp->ah_sstl = ARP_TL_NSAPA | (len & ARP_TL_LMASK); + + /* ah_ssa */ + KM_COPY(sip->si_subaddr.address, cp, len - 1); + ((struct atm_addr_nsap *)cp)->aan_sel = nip->nif_sel; + cp += len; + } else + ahp->ah_sstl = 0; + break; + + default: + ahp->ah_shtl = 0; + ahp->ah_sstl = 0; + } + + ahp->ah_op = htons(ARP_REQUEST); + ahp->ah_spln = sizeof(struct in_addr); + + /* ah_spa */ + KM_COPY((caddr_t)&(IA_SIN(inp->inf_addr)->sin_addr), cp, + sizeof(struct in_addr)); + cp += sizeof(struct in_addr); + + ahp->ah_thtl = 0; + ahp->ah_tstl = 0; + + ahp->ah_tpln = sizeof(struct in_addr); + + /* ah_tpa */ + KM_COPY((caddr_t)tip, cp, sizeof(struct in_addr)); + + /* + * Finally, send the pdu to the ATMARP server + */ + ivp = uip->uip_arpsvrvcc; + if (uniarp_print) + uniarp_pdu_print(ivp, m, "send"); + err = atm_cm_cpcs_data(ivp->iv_arpconn, m); + if (err) { + /* + * Didn't make it + */ + KB_FREEALL(m); + return (1); + } + + return (0); +} + + +/* + * Issue an ATMARP Response PDU + * + * Arguments: + * uip pointer to IP interface + * amp pointer to source map entry + * tip pointer to target IP address + * tatm pointer to target ATM address + * tsub pointer to target ATM subaddress + * ivp pointer to vcc over which to send pdu + * + * Returns: + * 0 PDU was successfully sent + * else unable to send PDU + * + */ +int +uniarp_arp_rsp(uip, amp, tip, tatm, tsub, ivp) + struct uniip *uip; + struct arpmap *amp; + struct in_addr *tip; + Atm_addr *tatm; + Atm_addr *tsub; + struct ipvcc *ivp; +{ + KBuffer *m; + struct atmarp_hdr *ahp; + char *cp; + int len, err; + + /* + * Figure out how long pdu is going to be + */ + len = sizeof(struct atmarp_hdr) + (2 * sizeof(struct in_addr)); + switch (amp->am_dstatm.address_format) { + case T_ATM_ENDSYS_ADDR: + len += amp->am_dstatm.address_length; + break; + + case T_ATM_E164_ADDR: + len += amp->am_dstatm.address_length; + if (amp->am_dstatmsub.address_format == T_ATM_ENDSYS_ADDR) + len += amp->am_dstatmsub.address_length; + break; + } + + switch (tatm->address_format) { + case T_ATM_ENDSYS_ADDR: + len += tatm->address_length; + break; + + case T_ATM_E164_ADDR: + len += tatm->address_length; + if (tsub->address_format == T_ATM_ENDSYS_ADDR) + len += tsub->address_length; + break; + } + + /* + * Get a buffer for pdu + */ + KB_ALLOCPKT(m, len, KB_F_NOWAIT, KB_T_DATA); + if (m == NULL) + return (1); + + /* + * Place aligned pdu at end of buffer + */ + KB_TAILALIGN(m, len); + KB_DATASTART(m, ahp, struct atmarp_hdr *); + + /* + * Setup variable fields pointer + */ + cp = (char *)ahp + sizeof(struct atmarp_hdr); + + /* + * Build fields + */ + ahp->ah_hrd = htons(ARP_ATMFORUM); + ahp->ah_pro = htons(ETHERTYPE_IP); + len = amp->am_dstatm.address_length; + switch (amp->am_dstatm.address_format) { + case T_ATM_ENDSYS_ADDR: + ahp->ah_shtl = ARP_TL_NSAPA | (len & ARP_TL_LMASK); + + /* ah_sha */ + KM_COPY(amp->am_dstatm.address, cp, len); + cp += len; + + ahp->ah_sstl = 0; + break; + + case T_ATM_E164_ADDR: + ahp->ah_shtl = ARP_TL_E164 | (len & ARP_TL_LMASK); + + /* ah_sha */ + KM_COPY(amp->am_dstatm.address, cp, len); + cp += len; + + if (amp->am_dstatmsub.address_format == T_ATM_ENDSYS_ADDR) { + len = amp->am_dstatmsub.address_length; + ahp->ah_sstl = ARP_TL_NSAPA | (len & ARP_TL_LMASK); + + /* ah_ssa */ + KM_COPY(amp->am_dstatmsub.address, cp, len); + cp += len; + } else + ahp->ah_sstl = 0; + break; + + default: + ahp->ah_shtl = 0; + ahp->ah_sstl = 0; + } + + ahp->ah_op = htons(ARP_REPLY); + ahp->ah_spln = sizeof(struct in_addr); + + /* ah_spa */ + KM_COPY((caddr_t)&->am_dstip, cp, sizeof(struct in_addr)); + cp += sizeof(struct in_addr); + + len = tatm->address_length; + switch (tatm->address_format) { + case T_ATM_ENDSYS_ADDR: + ahp->ah_thtl = ARP_TL_NSAPA | (len & ARP_TL_LMASK); + + /* ah_tha */ + KM_COPY(tatm->address, cp, len); + cp += len; + + ahp->ah_tstl = 0; + break; + + case T_ATM_E164_ADDR: + ahp->ah_thtl = ARP_TL_E164 | (len & ARP_TL_LMASK); + + /* ah_tha */ + KM_COPY(tatm->address, cp, len); + cp += len; + + if (tsub->address_format == T_ATM_ENDSYS_ADDR) { + len = tsub->address_length; + ahp->ah_tstl = ARP_TL_NSAPA | (len & ARP_TL_LMASK); + + /* ah_tsa */ + KM_COPY(tsub->address, cp, len); + cp += len; + } else + ahp->ah_tstl = 0; + break; + + default: + ahp->ah_thtl = 0; + ahp->ah_tstl = 0; + } + + ahp->ah_tpln = sizeof(struct in_addr); + + /* ah_tpa */ + KM_COPY((caddr_t)tip, cp, sizeof(struct in_addr)); + + /* + * Finally, send the pdu to the vcc peer + */ + if (uniarp_print) + uniarp_pdu_print(ivp, m, "send"); + err = atm_cm_cpcs_data(ivp->iv_arpconn, m); + if (err) { + /* + * Didn't make it + */ + KB_FREEALL(m); + return (1); + } + + return (0); +} + + +/* + * Issue an ATMARP NAK PDU + * + * Arguments: + * uip pointer to IP interface + * m pointer to ATMARP_REQ buffer chain + * ivp pointer to vcc over which to send pdu + * + * Returns: + * 0 PDU was successfully sent + * else unable to send PDU + * + */ +int +uniarp_arp_nak(uip, m, ivp) + struct uniip *uip; + KBuffer *m; + struct ipvcc *ivp; +{ + struct atmarp_hdr *ahp; + int err; + + /* + * Get the fixed fields together + */ + if (KB_LEN(m) < sizeof(struct atmarp_hdr)) { + KB_PULLUP(m, sizeof(struct atmarp_hdr), m); + if (m == NULL) + return (1); + } + KB_DATASTART(m, ahp, struct atmarp_hdr *); + + /* + * Set new op-code + */ + ahp->ah_op = htons(ARP_NAK); + + /* + * Finally, send the pdu to the vcc peer + */ + if (uniarp_print) + uniarp_pdu_print(ivp, m, "send"); + err = atm_cm_cpcs_data(ivp->iv_arpconn, m); + if (err) { + /* + * Didn't make it + */ + KB_FREEALL(m); + return (1); + } + + return (0); +} + + +/* + * Issue an InATMARP Request PDU + * + * Arguments: + * uip pointer to IP interface + * tatm pointer to target ATM address + * tsub pointer to target ATM subaddress + * ivp pointer to vcc over which to send pdu + * + * Returns: + * 0 PDU was successfully sent + * else unable to send PDU + * + */ +int +uniarp_inarp_req(uip, tatm, tsub, ivp) + struct uniip *uip; + Atm_addr *tatm; + Atm_addr *tsub; + struct ipvcc *ivp; +{ + KBuffer *m; + struct atmarp_hdr *ahp; + struct atm_nif *nip; + struct ip_nif *inp; + struct siginst *sip; + char *cp; + int len, err; + + inp = uip->uip_ipnif; + nip = inp->inf_nif; + sip = inp->inf_nif->nif_pif->pif_siginst; + + /* + * Figure out how long pdu is going to be + */ + len = sizeof(struct atmarp_hdr) + sizeof(struct in_addr); + switch (sip->si_addr.address_format) { + case T_ATM_ENDSYS_ADDR: + len += sip->si_addr.address_length; + break; + + case T_ATM_E164_ADDR: + len += sip->si_addr.address_length; + if (sip->si_subaddr.address_format == T_ATM_ENDSYS_ADDR) + len += sip->si_subaddr.address_length; + break; + } + + switch (tatm->address_format) { + case T_ATM_ENDSYS_ADDR: + len += tatm->address_length; + break; + + case T_ATM_E164_ADDR: + len += tatm->address_length; + if (tsub->address_format == T_ATM_ENDSYS_ADDR) + len += tsub->address_length; + break; + } + + /* + * Get a buffer for pdu + */ + KB_ALLOCPKT(m, len, KB_F_NOWAIT, KB_T_DATA); + if (m == NULL) + return (1); + + /* + * Place aligned pdu at end of buffer + */ + KB_TAILALIGN(m, len); + KB_DATASTART(m, ahp, struct atmarp_hdr *); + + /* + * Setup variable fields pointer + */ + cp = (char *)ahp + sizeof(struct atmarp_hdr); + + /* + * Build fields + */ + ahp->ah_hrd = htons(ARP_ATMFORUM); + ahp->ah_pro = htons(ETHERTYPE_IP); + len = sip->si_addr.address_length; + switch (sip->si_addr.address_format) { + case T_ATM_ENDSYS_ADDR: + ahp->ah_shtl = ARP_TL_NSAPA | (len & ARP_TL_LMASK); + + /* ah_sha */ + KM_COPY(sip->si_addr.address, cp, len - 1); + ((struct atm_addr_nsap *)cp)->aan_sel = nip->nif_sel; + cp += len; + + ahp->ah_sstl = 0; + break; + + case T_ATM_E164_ADDR: + ahp->ah_shtl = ARP_TL_E164 | (len & ARP_TL_LMASK); + + /* ah_sha */ + KM_COPY(sip->si_addr.address, cp, len); + cp += len; + + if (sip->si_subaddr.address_format == T_ATM_ENDSYS_ADDR) { + len = sip->si_subaddr.address_length; + ahp->ah_sstl = ARP_TL_NSAPA | (len & ARP_TL_LMASK); + + /* ah_ssa */ + KM_COPY(sip->si_subaddr.address, cp, len - 1); + ((struct atm_addr_nsap *)cp)->aan_sel = nip->nif_sel; + cp += len; + } else + ahp->ah_sstl = 0; + break; + + default: + ahp->ah_shtl = 0; + ahp->ah_sstl = 0; + } + + ahp->ah_op = htons(INARP_REQUEST); + ahp->ah_spln = sizeof(struct in_addr); + + /* ah_spa */ + KM_COPY((caddr_t)&(IA_SIN(inp->inf_addr)->sin_addr), cp, + sizeof(struct in_addr)); + cp += sizeof(struct in_addr); + + len = tatm->address_length; + switch (tatm->address_format) { + case T_ATM_ENDSYS_ADDR: + ahp->ah_thtl = ARP_TL_NSAPA | (len & ARP_TL_LMASK); + + /* ah_tha */ + KM_COPY(tatm->address, cp, len); + cp += len; + + ahp->ah_tstl = 0; + break; + + case T_ATM_E164_ADDR: + ahp->ah_thtl = ARP_TL_E164 | (len & ARP_TL_LMASK); + + /* ah_tha */ + KM_COPY(tatm->address, cp, len); + cp += len; + + if (tsub->address_format == T_ATM_ENDSYS_ADDR) { + len = tsub->address_length; + ahp->ah_tstl = ARP_TL_NSAPA | (len & ARP_TL_LMASK); + + /* ah_tsa */ + KM_COPY(tsub->address, cp, len); + cp += len; + } else + ahp->ah_tstl = 0; + break; + + default: + ahp->ah_thtl = 0; + ahp->ah_tstl = 0; + } + + ahp->ah_tpln = 0; + + /* + * Finally, send the pdu to the vcc peer + */ + if (uniarp_print) + uniarp_pdu_print(ivp, m, "send"); + err = atm_cm_cpcs_data(ivp->iv_arpconn, m); + if (err) { + /* + * Didn't make it + */ + KB_FREEALL(m); + return (1); + } + + return (0); +} + + +/* + * Issue an InATMARP Response PDU + * + * Arguments: + * uip pointer to IP interface + * tip pointer to target IP address + * tatm pointer to target ATM address + * tsub pointer to target ATM subaddress + * ivp pointer to vcc over which to send pdu + * + * Returns: + * 0 PDU was successfully sent + * else unable to send PDU + * + */ +int +uniarp_inarp_rsp(uip, tip, tatm, tsub, ivp) + struct uniip *uip; + struct in_addr *tip; + Atm_addr *tatm; + Atm_addr *tsub; + struct ipvcc *ivp; +{ + KBuffer *m; + struct atmarp_hdr *ahp; + struct atm_nif *nip; + struct ip_nif *inp; + struct siginst *sip; + char *cp; + int len, err; + + inp = uip->uip_ipnif; + nip = inp->inf_nif; + sip = inp->inf_nif->nif_pif->pif_siginst; + + /* + * Figure out how long pdu is going to be + */ + len = sizeof(struct atmarp_hdr) + (2 * sizeof(struct in_addr)); + switch (sip->si_addr.address_format) { + case T_ATM_ENDSYS_ADDR: + len += sip->si_addr.address_length; + break; + + case T_ATM_E164_ADDR: + len += sip->si_addr.address_length; + if (sip->si_subaddr.address_format == T_ATM_ENDSYS_ADDR) + len += sip->si_subaddr.address_length; + break; + } + + switch (tatm->address_format) { + case T_ATM_ENDSYS_ADDR: + len += tatm->address_length; + break; + + case T_ATM_E164_ADDR: + len += tatm->address_length; + if (tsub->address_format == T_ATM_ENDSYS_ADDR) + len += tsub->address_length; + break; + } + + /* + * Get a buffer for pdu + */ + KB_ALLOCPKT(m, len, KB_F_NOWAIT, KB_T_DATA); + if (m == NULL) + return (1); + + /* + * Place aligned pdu at end of buffer + */ + KB_TAILALIGN(m, len); + KB_DATASTART(m, ahp, struct atmarp_hdr *); + + /* + * Setup variable fields pointer + */ + cp = (char *)ahp + sizeof(struct atmarp_hdr); + + /* + * Build fields + */ + ahp->ah_hrd = htons(ARP_ATMFORUM); + ahp->ah_pro = htons(ETHERTYPE_IP); + len = sip->si_addr.address_length; + switch (sip->si_addr.address_format) { + case T_ATM_ENDSYS_ADDR: + ahp->ah_shtl = ARP_TL_NSAPA | (len & ARP_TL_LMASK); + + /* ah_sha */ + KM_COPY(sip->si_addr.address, cp, len - 1); + ((struct atm_addr_nsap *)cp)->aan_sel = nip->nif_sel; + cp += len; + + ahp->ah_sstl = 0; + break; + + case T_ATM_E164_ADDR: + ahp->ah_shtl = ARP_TL_E164 | (len & ARP_TL_LMASK); + + /* ah_sha */ + KM_COPY(sip->si_addr.address, cp, len); + cp += len; + + if (sip->si_subaddr.address_format == T_ATM_ENDSYS_ADDR) { + len = sip->si_subaddr.address_length; + ahp->ah_sstl = ARP_TL_NSAPA | (len & ARP_TL_LMASK); + + /* ah_ssa */ + KM_COPY(sip->si_subaddr.address, cp, len - 1); + ((struct atm_addr_nsap *)cp)->aan_sel = nip->nif_sel; + cp += len; + } else + ahp->ah_sstl = 0; + break; + + default: + ahp->ah_shtl = 0; + ahp->ah_sstl = 0; + } + + ahp->ah_op = htons(INARP_REPLY); + ahp->ah_spln = sizeof(struct in_addr); + + /* ah_spa */ + KM_COPY((caddr_t)&(IA_SIN(inp->inf_addr)->sin_addr), cp, + sizeof(struct in_addr)); + cp += sizeof(struct in_addr); + + len = tatm->address_length; + switch (tatm->address_format) { + case T_ATM_ENDSYS_ADDR: + ahp->ah_thtl = ARP_TL_NSAPA | (len & ARP_TL_LMASK); + + /* ah_tha */ + KM_COPY(tatm->address, cp, len); + cp += len; + + ahp->ah_tstl = 0; + break; + + case T_ATM_E164_ADDR: + ahp->ah_thtl = ARP_TL_E164 | (len & ARP_TL_LMASK); + + /* ah_tha */ + KM_COPY(tatm->address, cp, len); + cp += len; + + if (tsub->address_format == T_ATM_ENDSYS_ADDR) { + len = tsub->address_length; + ahp->ah_tstl = ARP_TL_NSAPA | (len & ARP_TL_LMASK); + + /* ah_tsa */ + KM_COPY(tsub->address, cp, len); + cp += len; + } else + ahp->ah_tstl = 0; + break; + + default: + ahp->ah_thtl = 0; + ahp->ah_tstl = 0; + } + + ahp->ah_tpln = sizeof(struct in_addr); + + /* ah_tpa */ + KM_COPY((caddr_t)tip, cp, sizeof(struct in_addr)); + + /* + * Finally, send the pdu to the vcc peer + */ + if (uniarp_print) + uniarp_pdu_print(ivp, m, "send"); + err = atm_cm_cpcs_data(ivp->iv_arpconn, m); + if (err) { + /* + * Didn't make it + */ + KB_FREEALL(m); + return (1); + } + + return (0); +} + diff --git a/sys/netatm/uni/uniarp_timer.c b/sys/netatm/uni/uniarp_timer.c new file mode 100644 index 0000000..1f00202 --- /dev/null +++ b/sys/netatm/uni/uniarp_timer.c @@ -0,0 +1,320 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: uniarp_timer.c,v 1.8 1998/06/29 22:44:31 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * UNI ATMARP support (RFC1577) - Timer processing + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: uniarp_timer.c,v 1.8 1998/06/29 22:44:31 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/uniip_var.h> + + +/* + * Local functions + */ +static void uniarp_svc_oldage __P((struct uniarp *)); +static void uniarp_pvc_oldage __P((struct uniarp *)); + + +/* + * Process a UNI ATMARP entry timeout + * + * Called when a previously scheduled uniarp control block timer expires. + * + * Called at splnet. + * + * Arguments: + * tip pointer to uniarp timer control block + * + * Returns: + * none + * + */ +void +uniarp_timeout(tip) + struct atm_time *tip; +{ + struct uniip *uip; + struct uniarp *uap; + struct ipvcc *ivp; + + + /* + * Back-off to uniarp control block + */ + uap = (struct uniarp *) + ((caddr_t)tip - (int)(&((struct uniarp *)0)->ua_time)); + uip = uap->ua_intf; + + + /* + * Do we know the IP address for this entry yet?? + */ + if (uap->ua_dstip.s_addr == 0) { + + /* + * No, then send another InATMARP_REQ on each active VCC + * associated with this entry to solicit the peer's identity. + */ + for (ivp = uap->ua_ivp; ivp; ivp = ivp->iv_arpnext) { + if (ivp->iv_state != IPVCC_ACTIVE) + continue; + (void) uniarp_inarp_req(uip, &uap->ua_dstatm, + &uap->ua_dstatmsub, ivp); + } + + /* + * Restart retry timer + */ + UNIARP_TIMER(uap, UNIARP_ARP_RETRY); + } else { + /* + * Yes, then we're trying to find the ATM address for this + * IP address - so send another ATMARP_REQ to the arpserver + * (if it's up at the moment) + */ + if (uip->uip_arpstate == UIAS_CLIENT_ACTIVE) + (void) uniarp_arp_req(uip, &uap->ua_dstip); + + /* + * Restart retry timer + */ + UNIARP_TIMER(uap, UNIARP_ARP_RETRY); + } + + return; +} + + +/* + * Process an UNI ARP SVC entry aging timer expiration + * + * This function is called when an SVC arp entry's aging timer has expired. + * + * Called at splnet(). + * + * Arguments: + * uap pointer to atmarp table entry + * + * Returns: + * none + * + */ +static void +uniarp_svc_oldage(uap) + struct uniarp *uap; +{ + struct ipvcc *ivp, *inext; + struct uniip *uip = uap->ua_intf; + + + /* + * Permanent (manually installed) entries are never aged + */ + if (uap->ua_origin >= UAO_PERM) + return; + + /* + * If entry is valid and we're out of retrys, tell + * IP/ATM that the SVCs can't be used + */ + if ((uap->ua_flags & UAF_VALID) && (uap->ua_retry-- == 0)) { + uap->ua_flags |= UAF_LOCKED; + for (ivp = uap->ua_ivp; ivp; ivp = inext) { + inext = ivp->iv_arpnext; + (*ivp->iv_ipnif->inf_arpnotify)(ivp, MAP_INVALID); + } + uap->ua_flags &= ~(UAF_LOCKED | UAF_VALID); + uap->ua_origin = 0; + + /* + * Delete and free an unused entry + */ + if (uap->ua_ivp == NULL) { + UNIARP_CANCEL(uap); + UNIARP_DELETE(uap); + atm_free((caddr_t)uap); + return; + } + } + + /* + * We want to try and refresh this entry but we don't want + * to keep unused entries laying around forever. + */ + if (uap->ua_ivp || (uap->ua_flags & UAF_USED)) { + if (uip->uip_arpstate == UIAS_CLIENT_ACTIVE) { + /* + * If we are a client (and the server VCC is active), + * then we'll ask the server for a refresh + */ + (void) uniarp_arp_req(uip, &uap->ua_dstip); + } else { + /* + * Otherwise, solicit the each active VCC peer with + * an Inverse ATMARP + */ + for (ivp = uap->ua_ivp; ivp; ivp = ivp->iv_arpnext) { + if (ivp->iv_state != IPVCC_ACTIVE) + continue; + (void) uniarp_inarp_req(uip, &uap->ua_dstatm, + &uap->ua_dstatmsub, ivp); + } + } + } + + /* + * Reset timeout + */ + if (uap->ua_flags & UAF_VALID) + uap->ua_aging = UNIARP_RETRY_AGE; + else + uap->ua_aging = UNIARP_REVALID_AGE; + + return; +} + + +/* + * Process an UNI ARP PVC entry aging timer expiration + * + * This function is called when a PVC arp entry's aging timer has expired. + * + * Called at splnet(). + * + * Arguments: + * uap pointer to atmarp table entry + * + * Returns: + * none + * + */ +static void +uniarp_pvc_oldage(uap) + struct uniarp *uap; +{ + struct ipvcc *ivp = uap->ua_ivp; + + /* + * If entry is valid and we're out of retrys, tell + * IP/ATM that PVC can't be used + */ + if ((uap->ua_flags & UAF_VALID) && (uap->ua_retry-- == 0)) { + (*ivp->iv_ipnif->inf_arpnotify)(ivp, MAP_INVALID); + uap->ua_flags &= ~UAF_VALID; + } + + /* + * Solicit peer with Inverse ATMARP + */ + (void) uniarp_inarp_req(uap->ua_intf, &uap->ua_dstatm, + &uap->ua_dstatmsub, ivp); + + /* + * Reset timeout + */ + if (uap->ua_flags & UAF_VALID) + uap->ua_aging = UNIARP_RETRY_AGE; + else + uap->ua_aging = UNIARP_REVALID_AGE; + + return; +} + + +/* + * Process a UNI ARP aging timer tick + * + * This function is called every UNIARP_AGING seconds, in order to age + * all the arp table entries. If an entry's timer is expired, then the + * uniarp old-age timeout function will be called for that entry. + * + * Called at splnet. + * + * Arguments: + * tip pointer to uniarp aging timer control block + * + * Returns: + * none + * + */ +void +uniarp_aging(tip) + struct atm_time *tip; +{ + struct uniarp *uap, *unext; + int i; + + + /* + * Schedule next timeout + */ + atm_timeout(&uniarp_timer, UNIARP_AGING, uniarp_aging); + + /* + * Run through arp table bumping each entry's aging timer. + * If an expired timer is found, process that entry. + */ + for (i = 0; i < UNIARP_HASHSIZ; i++) { + for (uap = uniarp_arptab[i]; uap; uap = unext) { + unext = uap->ua_next; + + if (uap->ua_aging && --uap->ua_aging == 0) + uniarp_svc_oldage(uap); + } + } + + /* + * Check out PVC aging timers too + */ + for (uap = uniarp_pvctab; uap; uap = unext) { + unext = uap->ua_next; + + if (uap->ua_aging && --uap->ua_aging == 0) + uniarp_pvc_oldage(uap); + } + + /* + * Only fully resolved SVC entries need aging, so there's no need + * to examine the 'no map' table + */ +} + diff --git a/sys/netatm/uni/uniarp_vcm.c b/sys/netatm/uni/uniarp_vcm.c new file mode 100644 index 0000000..9b1f211 --- /dev/null +++ b/sys/netatm/uni/uniarp_vcm.c @@ -0,0 +1,708 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: uniarp_vcm.c,v 1.10 1998/06/29 22:15:46 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * UNI ATMARP support (RFC1577) - Virtual Channel Management + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: uniarp_vcm.c,v 1.10 1998/06/29 22:15:46 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/uniip_var.h> + + +/* + * Local variables + */ +static struct attr_llc uniarp_llc = { + T_ATM_PRESENT, + { + T_ATM_LLC_SHARING, + 8, + {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x06} + } +}; + +static struct t_atm_cause uniarp_cause = { + T_ATM_ITU_CODING, + T_ATM_LOC_USER, + T_ATM_CAUSE_TEMPORARY_FAILURE, + {0, 0, 0, 0} +}; + + +/* + * Process a new PVC requiring ATMARP support + * + * This function is called after IP/ATM has successfully opened a PVC which + * requires ATMARP support. We will send an InATMARP request over the PVC + * to elicit a response from the PVC's ATMARP peer informing us of its + * network address. This information will also be used by IP/ATM in order + * to complete its address-to-VC mapping table. + * + * Arguments: + * ivp pointer to PVC's IPVCC control block + * + * Returns: + * MAP_PROCEEDING - OK so far, querying for peer's mapping + * MAP_FAILED - error, unable to allocate resources + * + */ +int +uniarp_pvcopen(ivp) + struct ipvcc *ivp; +{ + struct uniip *uip; + struct uniarp *uap; + int s, err; + + ATM_DEBUG1("uniarp_pvcopen: ivp=0x%x\n", (int)ivp); + + ivp->iv_arpent = NULL; + + /* + * Check things out + */ + if ((ivp->iv_flags & IVF_LLC) == 0) + return (MAP_FAILED); + + /* + * Get uni interface + */ + uip = (struct uniip *)ivp->iv_ipnif->inf_isintf; + if (uip == NULL) + return (MAP_FAILED); + + /* + * Get an arp map entry + */ + uap = (struct uniarp *)atm_allocate(&uniarp_pool); + if (uap == NULL) + return (MAP_FAILED); + + /* + * Create our CM connection + */ + err = atm_cm_addllc(&uniarp_endpt, ivp, &uniarp_llc, + ivp->iv_conn, &ivp->iv_arpconn); + if (err) { + /* + * We don't take no (or maybe) for an answer + */ + if (ivp->iv_arpconn) { + (void) atm_cm_release(ivp->iv_arpconn, &uniarp_cause); + ivp->iv_arpconn = NULL; + } + atm_free((caddr_t)uap); + return (MAP_FAILED); + } + + /* + * Get map entry set up + */ + s = splnet(); + uap->ua_dstatm.address_format = T_ATM_ABSENT; + uap->ua_dstatmsub.address_format = T_ATM_ABSENT; + uap->ua_intf = uip; + + /* + * Put ivp on arp entry chain + */ + LINK2TAIL(ivp, struct ipvcc, uap->ua_ivp, iv_arpnext); + ivp->iv_arpent = (struct arpmap *)uap; + + /* + * Put arp entry on pvc chain + */ + LINK2TAIL(uap, struct uniarp, uniarp_pvctab, ua_next); + + /* + * Send Inverse ATMARP request + */ + (void) uniarp_inarp_req(uip, &uap->ua_dstatm, &uap->ua_dstatmsub, ivp); + + /* + * Start resend timer + */ + uap->ua_aging = UNIARP_REVALID_AGE; + + (void) splx(s); + return (MAP_PROCEEDING); +} + + +/* + * Process a new outgoing SVC requiring ATMARP support + * + * This function is called by the IP/ATM module to resolve a destination + * IP address to an ATM address in order to open an SVC to that destination. + * If a valid mapping is already in our cache, then we just tell the caller + * about it and that's that. Otherwise, we have to allocate a new arp entry + * and issue a query for the mapping. + * + * Arguments: + * ivp pointer to SVC's IPVCC control block + * dst pointer to destination IP address + * + * Returns: + * MAP_VALID - Got the answer, returned via iv_arpent field. + * MAP_PROCEEDING - OK so far, querying for peer's mapping + * MAP_FAILED - error, unable to allocate resources + * + */ +int +uniarp_svcout(ivp, dst) + struct ipvcc *ivp; + struct in_addr *dst; +{ + struct uniip *uip; + struct uniarp *uap; + int s = splnet(); + + ATM_DEBUG2("uniarp_svcout: ivp=0x%x,dst=0x%x\n", (int)ivp, dst->s_addr); + + ivp->iv_arpent = NULL; + + /* + * Get uni interface + */ + uip = (struct uniip *)ivp->iv_ipnif->inf_isintf; + if (uip == NULL) { + (void) splx(s); + return (MAP_FAILED); + } + + /* + * Lookup IP destination address + */ + UNIARP_LOOKUP(dst->s_addr, uap); + + if (uap) { + /* + * We've got an entry, verify interface + */ + if (uap->ua_intf != uip) { + (void) splx(s); + return (MAP_FAILED); + } + + /* + * Chain this vcc onto entry + */ + LINK2TAIL(ivp, struct ipvcc, uap->ua_ivp, iv_arpnext); + ivp->iv_arpent = (struct arpmap *)uap; + uap->ua_flags |= UAF_USED; + + if (uap->ua_flags & UAF_VALID) { + /* + * Entry is valid, we're done + */ + (void) splx(s); + return (MAP_VALID); + } else { + /* + * We're already looking for this address + */ + (void) splx(s); + return (MAP_PROCEEDING); + } + } + + /* + * No info in the cache. If we're the server, then + * we're already authoritative, so just deny request. + * If we're a client but the server VCC isn't open we + * also deny the request. + */ + if (uip->uip_arpstate != UIAS_CLIENT_ACTIVE) { + (void) splx(s); + return (MAP_FAILED); + } + + /* + * We're a client with an open VCC to the server, get a new arp entry + */ + uap = (struct uniarp *)atm_allocate(&uniarp_pool); + if (uap == NULL) { + (void) splx(s); + return (MAP_FAILED); + } + + /* + * Get entry set up + */ + uap->ua_dstip.s_addr = dst->s_addr; + uap->ua_dstatm.address_format = T_ATM_ABSENT; + uap->ua_dstatm.address_length = 0; + uap->ua_dstatmsub.address_format = T_ATM_ABSENT; + uap->ua_dstatmsub.address_length = 0; + uap->ua_intf = uip; + + /* + * Link ipvcc to arp entry for later notification + */ + LINK2TAIL(ivp, struct ipvcc, uap->ua_ivp, iv_arpnext); + ivp->iv_arpent = (struct arpmap *)uap; + uap->ua_flags |= UAF_USED; + + /* + * Add arp entry to table + */ + UNIARP_ADD(uap); + + /* + * Issue arp request for this address + */ + (void) uniarp_arp_req(uip, dst); + + /* + * Start retry timer + */ + UNIARP_TIMER(uap, UNIARP_ARP_RETRY); + + (void) splx(s); + return (MAP_PROCEEDING); +} + + +/* + * Process a new incoming SVC requiring ATMARP support + * + * This function is called by the IP/ATM module to resolve a caller's ATM + * address to its IP address for an incoming call in order to allow a + * bi-directional flow of IP packets on the SVC. If a valid mapping is + * already in our cache, then we will use it. Otherwise, we have to allocate + * a new arp entry and wait for the SVC to become active so that we can issue + * an InATMARP to the peer. + * + * Arguments: + * ivp pointer to SVC's IPVCC control block + * dst pointer to caller's ATM address + * dstsub pointer to caller's ATM subaddress + * + * Returns: + * MAP_VALID - Got the answer, returned via iv_arpent field. + * MAP_PROCEEDING - OK so far, querying for peer's mapping + * MAP_FAILED - error, unable to allocate resources + * + */ +int +uniarp_svcin(ivp, dst, dstsub) + struct ipvcc *ivp; + Atm_addr *dst; + Atm_addr *dstsub; +{ + struct uniip *uip; + struct uniarp *uap; + int found = 0, i, s = splnet(); + + ATM_DEBUG1("uniarp_svcin: ivp=0x%x\n", (int)ivp); + + /* + * Clear ARP entry field + */ + ivp->iv_arpent = NULL; + + /* + * Check things out + */ + if ((ivp->iv_flags & IVF_LLC) == 0) + return (MAP_FAILED); + + /* + * Get uni interface + */ + uip = (struct uniip *)ivp->iv_ipnif->inf_isintf; + if (uip == NULL) { + (void) splx(s); + return (MAP_FAILED); + } + + /* + * Make sure we're configured as a client or server + */ + if (uip->uip_arpstate == UIAS_NOTCONF) { + (void) splx(s); + return (MAP_FAILED); + } + + /* + * If we know the caller's ATM address, look it up + */ + uap = NULL; + if (dst->address_format != T_ATM_ABSENT) { + for (i = 0; (i < UNIARP_HASHSIZ) && (found == 0); i++) { + for (uap = uniarp_arptab[i]; uap; uap = uap->ua_next) { + if (ATM_ADDR_EQUAL(dst, &uap->ua_dstatm) && + ATM_ADDR_EQUAL(dstsub, &uap->ua_dstatmsub)){ + found = 1; + break; + } + } + } + if (uap == NULL) { + for (uap = uniarp_nomaptab; uap; uap = uap->ua_next) { + if (ATM_ADDR_EQUAL(dst, &uap->ua_dstatm) && + ATM_ADDR_EQUAL(dstsub, &uap->ua_dstatmsub)) + break; + } + } + } + + if (uap) { + /* + * We've got an entry, verify interface + */ + if (uap->ua_intf != uip) { + (void) splx(s); + return (MAP_FAILED); + } + + /* + * Chain the vcc onto this entry + */ + LINK2TAIL(ivp, struct ipvcc, uap->ua_ivp, iv_arpnext); + ivp->iv_arpent = (struct arpmap *)uap; + uap->ua_flags |= UAF_USED; + + if (uap->ua_flags & UAF_VALID) { + /* + * Entry is valid, we're done + */ + (void) splx(s); + return (MAP_VALID); + } else { + /* + * We're already looking for this address + */ + (void) splx(s); + return (MAP_PROCEEDING); + } + } + + /* + * No info in the cache - get a new arp entry + */ + uap = (struct uniarp *)atm_allocate(&uniarp_pool); + if (uap == NULL) { + (void) splx(s); + return (MAP_FAILED); + } + + /* + * Get entry set up + */ + ATM_ADDR_COPY(dst, &uap->ua_dstatm); + ATM_ADDR_COPY(dstsub, &uap->ua_dstatmsub); + uap->ua_intf = uip; + + /* + * Link ipvcc to arp entry for later notification + */ + LINK2TAIL(ivp, struct ipvcc, uap->ua_ivp, iv_arpnext); + ivp->iv_arpent = (struct arpmap *)uap; + uap->ua_flags |= UAF_USED; + + /* + * Add arp entry to 'nomap' table + */ + LINK2TAIL(uap, struct uniarp, uniarp_nomaptab, ua_next); + + (void) splx(s); + + /* + * Now we just wait for SVC to become active + */ + return (MAP_PROCEEDING); +} + + +/* + * Process ARP SVC activation notification + * + * This function is called by the IP/ATM module whenever a previously + * opened SVC has successfully been connected. + * + * Arguments: + * ivp pointer to SVC's IPVCC control block + * + * Returns: + * 0 activation processing successful + * errno activation failed - reason indicated + * + */ +int +uniarp_svcactive(ivp) + struct ipvcc *ivp; +{ + struct ip_nif *inp; + struct uniip *uip; + struct uniarp *uap; + int err, s = splnet(); + + ATM_DEBUG1("uniarp_svcactive: ivp=0x%x\n", (int)ivp); + + inp = ivp->iv_ipnif; + uip = (struct uniip *)inp->inf_isintf; + uap = (struct uniarp *)ivp->iv_arpent; + + /* + * First, we need to create our CM connection + */ + err = atm_cm_addllc(&uniarp_endpt, ivp, &uniarp_llc, + ivp->iv_conn, &ivp->iv_arpconn); + if (err) { + /* + * We don't take no (or maybe) for an answer + */ + if (ivp->iv_arpconn) { + (void) atm_cm_release(ivp->iv_arpconn, &uniarp_cause); + ivp->iv_arpconn = NULL; + } + return (err); + } + + /* + * Is this the client->server vcc?? + */ + if (uip->uip_arpsvrvcc == ivp) { + + /* + * Yep, go into the client registration phase + */ + uip->uip_arpstate = UIAS_CLIENT_REGISTER; + + /* + * To register ourselves, RFC1577 says we should wait + * around for the server to send us an InATMARP_Request. + * However, draft-1577+ just has us send an ATMARP_Request + * for our own address. To keep everyone happy, we'll go + * with both and see what works! + */ + (void) uniarp_arp_req(uip, &(IA_SIN(inp->inf_addr)->sin_addr)); + + /* + * Start retry timer + */ + UNIIP_ARP_TIMER(uip, 1 * ATM_HZ); + + (void) splx(s); + return (0); + } + + /* + * Send an InATMARP_Request on this VCC to find out/notify who's at + * the other end. If we're the server, this will start off the + * RFC1577 registration procedure. If we're a client, then this + * SVC is for user data and it's pretty likely that both ends are + * going to be sending packets. So, if we're the caller, we'll be + * nice and let the callee know right away who we are. If we're the + * callee, let's find out asap the caller's IP address. + */ + (void) uniarp_inarp_req(uip, &uap->ua_dstatm, &uap->ua_dstatmsub, ivp); + + /* + * Start retry timer if entry isn't valid yet + */ + if (((uap->ua_flags & UAF_VALID) == 0) && + ((uap->ua_time.ti_flag & TIF_QUEUED) == 0)) + UNIARP_TIMER(uap, UNIARP_ARP_RETRY); + + (void) splx(s); + return (0); +} + + +/* + * Process VCC close + * + * This function is called just prior to IP/ATM closing a VCC which + * supports ATMARP. We'll sever our links to the VCC and then + * figure out how much more cleanup we need to do for now. + * + * Arguments: + * ivp pointer to VCC's IPVCC control block + * + * Returns: + * none + * + */ +void +uniarp_vcclose(ivp) + struct ipvcc *ivp; +{ + struct uniip *uip; + struct uniarp *uap; + int s; + + ATM_DEBUG1("uniarp_vcclose: ivp=0x%x\n", (int)ivp); + + /* + * Close our CM connection + */ + if (ivp->iv_arpconn) { + (void) atm_cm_release(ivp->iv_arpconn, &uniarp_cause); + ivp->iv_arpconn = NULL; + } + + /* + * Get atmarp entry + */ + if ((uap = (struct uniarp *)ivp->iv_arpent) == NULL) + return; + uip = uap->ua_intf; + + s = splnet(); + + /* + * If this is the arpserver VCC, then schedule ourselves to + * reopen the connection soon + */ + if (uip->uip_arpsvrvcc == ivp) { + uip->uip_arpsvrvcc = NULL; + uip->uip_arpstate = UIAS_CLIENT_POPEN; + UNIIP_ARP_CANCEL(uip); + UNIIP_ARP_TIMER(uip, 5 * ATM_HZ); + } + + /* + * Remove IP VCC from chain + */ + UNLINK(ivp, struct ipvcc, uap->ua_ivp, iv_arpnext); + + /* + * SVCs and PVCs are handled separately + */ + if (ivp->iv_flags & IVF_SVC) { + /* + * If the mapping is currently valid or in use, or if there + * are other VCCs still using this mapping, we're done for now + */ + if ((uap->ua_flags & (UAF_VALID | UAF_LOCKED)) || + (uap->ua_origin >= UAO_PERM) || + (uap->ua_ivp != NULL)) { + (void) splx(s); + return; + } + + /* + * Unlink the entry + */ + if (uap->ua_dstip.s_addr == 0) { + UNLINK(uap, struct uniarp, uniarp_nomaptab, ua_next); + } else { + UNIARP_DELETE(uap); + } + } else { + /* + * Remove entry from pvc table + */ + UNLINK(uap, struct uniarp, uniarp_pvctab, ua_next); + } + + UNIARP_CANCEL(uap); + + /* + * Finally, free the entry + */ + atm_free((caddr_t)uap); + + (void) splx(s); + return; +} + + +/* + * Process ATMARP VCC Connected Notification + * + * Arguments: + * toku owner's connection token (ipvcc protocol block) + * + * Returns: + * none + * + */ +void +uniarp_connected(toku) + void *toku; +{ + + /* + * Since we only do atm_cm_addllc()'s on active connections, + * we should never get called here... + */ + panic("uniarp_connected"); +} + + +/* + * Process ATMARP VCC Cleared Notification + * + * Arguments: + * toku owner's connection token (ipvcc protocol block) + * cause pointer to cause code + * + * Returns: + * none + * + */ +void +uniarp_cleared(toku, cause) + void *toku; + struct t_atm_cause *cause; +{ + struct ipvcc *ivp = toku; + int s; + + s = splnet(); + + /* + * We're done with VCC + */ + ivp->iv_arpconn = NULL; + + /* + * If IP is finished with VCC, then we'll free it + */ + if (ivp->iv_state == IPVCC_FREE) + atm_free((caddr_t)ivp); + + (void) splx(s); +} + diff --git a/sys/netatm/uni/uniip.c b/sys/netatm/uni/uniip.c new file mode 100644 index 0000000..0039585 --- /dev/null +++ b/sys/netatm/uni/uniip.c @@ -0,0 +1,252 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: uniip.c,v 1.6 1998/05/18 19:18:42 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * UNI IP interface module + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: uniip.c,v 1.6 1998/05/18 19:18:42 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> +#include <netatm/uni/uniip_var.h> + + +/* + * Local functions + */ +static int uniip_ipact __P((struct ip_nif *)); +static int uniip_ipdact __P((struct ip_nif *)); + + +/* + * Global variables + */ +struct uniip *uniip_head = NULL; + +struct ip_serv uniip_ipserv = { + uniip_ipact, + uniip_ipdact, + uniarp_ioctl, + uniarp_pvcopen, + uniarp_svcout, + uniarp_svcin, + uniarp_svcactive, + uniarp_vcclose, + NULL, + {ATM_AAL5, ATM_ENC_LLC}, +}; + + +/* + * Local variables + */ +static struct sp_info uniip_pool = { + "uni ip pool", /* si_name */ + sizeof(struct uniip), /* si_blksiz */ + 2, /* si_blkcnt */ + 100 /* si_maxallow */ +}; + + +/* + * Process module loading notification + * + * Called whenever the uni module is initializing. + * + * Arguments: + * none + * + * Returns: + * 0 initialization successful + * errno initialization failed - reason indicated + * + */ +int +uniip_start() +{ + int err; + + /* + * Tell arp to initialize stuff + */ + err = uniarp_start(); + + return (err); +} + + +/* + * Process module unloading notification + * + * Called whenever the uni module is about to be unloaded. All signalling + * instances will have been previously detached. All uniip resources + * must be freed now. + * + * Arguments: + * none + * + * Returns: + * 0 shutdown was successful + * errno shutdown failed - reason indicated + * + */ +int +uniip_stop() +{ + + /* + * All IP interfaces should be gone + */ + if (uniip_head) + return (EBUSY); + + /* + * Tell arp to stop + */ + uniarp_stop(); + + /* + * Free our storage pools + */ + atm_release_pool(&uniip_pool); + + return (0); +} + + +/* + * Process IP Network Interface Activation + * + * Called whenever an IP network interface becomes active. + * + * Called at splnet. + * + * Arguments: + * inp pointer to IP network interface + * + * Returns: + * 0 command successful + * errno command failed - reason indicated + * + */ +static int +uniip_ipact(inp) + struct ip_nif *inp; +{ + struct uniip *uip; + + /* + * Make sure we don't already have this interface + */ + for (uip = uniip_head; uip; uip = uip->uip_next) { + if (uip->uip_ipnif == inp) + return (EEXIST); + } + + /* + * Get a new interface control block + */ + uip = (struct uniip *)atm_allocate(&uniip_pool); + if (uip == NULL) + return (ENOMEM); + + /* + * Initialize and link up + */ + uip->uip_ipnif = inp; + LINK2TAIL(uip, struct uniip, uniip_head, uip_next); + + /* + * Link from IP world + */ + inp->inf_isintf = (caddr_t)uip; + + /* + * Tell arp about new interface + */ + uniarp_ipact(uip); + + return (0); +} + + +/* + * Process IP Network Interface Deactivation + * + * Called whenever an IP network interface becomes inactive. + * + * Called at splnet. + * + * Arguments: + * inp pointer to IP network interface + * + * Returns: + * 0 command successful + * errno command failed - reason indicated + * + */ +static int +uniip_ipdact(inp) + struct ip_nif *inp; +{ + struct uniip *uip; + + /* + * Get the appropriate IP interface block + */ + uip = (struct uniip *)inp->inf_isintf; + if (uip == NULL) + return (ENXIO); + + /* + * Let arp know about this + */ + uniarp_ipdact(uip); + + /* + * Free interface info + */ + UNLINK(uip, struct uniip, uniip_head, uip_next); + if (uip->uip_prefix != NULL) + KM_FREE(uip->uip_prefix, + uip->uip_nprefix * sizeof(struct uniarp_prf), M_DEVBUF); + atm_free((caddr_t)uip); + + return (0); +} + diff --git a/sys/netatm/uni/uniip_var.h b/sys/netatm/uni/uniip_var.h new file mode 100644 index 0000000..ea1eb8c --- /dev/null +++ b/sys/netatm/uni/uniip_var.h @@ -0,0 +1,318 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: uniip_var.h,v 1.9 1998/07/13 00:00:39 mks Exp $ + * + */ + +/* + * ATM Forum UNI Support + * --------------------- + * + * IP interface control blocks + * + */ + +#ifndef _UNI_UNIIP_VAR_H +#define _UNI_UNIIP_VAR_H + +#ifdef ATM_KERNEL +/* + * UNI IP network interface structure. There will be one such structure for + * each IP network interface attached via a UNI signalling instance. + */ +struct uniip { + struct uniip *uip_next; /* Next attached IP interface */ + struct ip_nif *uip_ipnif; /* IP network interface */ + u_char uip_flags; /* Interface flags (see below) */ + + /* ATMARP (RFC1577) */ + u_char uip_arpstate; /* ARP interface state (see below) */ + struct arpmap uip_arpsvrmap; /* ATMARP server map info */ + struct ipvcc *uip_arpsvrvcc; /* ATMARP server's VCC */ + int uip_nprefix; /* Count of IP prefixes (server only) */ + struct uniarp_prf *uip_prefix; /* Array of IP prefixes (server only) */ + struct atm_time uip_arptime; /* ARP timer controls */ +}; +#define uip_arpsvrip uip_arpsvrmap.am_dstip +#define uip_arpsvratm uip_arpsvrmap.am_dstatm +#define uip_arpsvrsub uip_arpsvrmap.am_dstatmsub +#endif /* ATM_KERNEL */ + +/* + * UNI Interface Flags + */ +#define UIF_IFADDR 0x01 /* Interface address is set */ + +/* + * UNI ARP Interface States + */ +#define UIAS_NOTCONF 1 /* Not configured */ +#define UIAS_SERVER_ACTIVE 2 /* Server - active */ +#define UIAS_CLIENT_PADDR 3 /* Client - pending ATM address */ +#define UIAS_CLIENT_POPEN 4 /* Client - pending server vcc open */ +#define UIAS_CLIENT_REGISTER 5 /* Client - registering with server */ +#define UIAS_CLIENT_ACTIVE 6 /* Client - active */ + + +#ifdef ATM_KERNEL +/* + * Structure for allowable IP prefixes for ATMARP server registration + */ +struct uniarp_prf { + struct in_addr upf_addr; /* Prefix address */ + struct in_addr upf_mask; /* Prefix mask */ +}; + + +/* + * UNI ARP protocol constants + */ +#define UNIARP_AGING (60 * ATM_HZ) /* Aging timer tick */ +#define UNIARP_HASHSIZ 19 /* Hash table size */ +#define UNIARP_REGIS_REFRESH (15 * 60 * ATM_HZ) + /* Client registration refresh timer */ +#define UNIARP_REGIS_RETRY (60 * ATM_HZ) + /* Client registration retry timer */ +#define UNIARP_ARP_RETRY (3 * ATM_HZ) /* ARP command retry timer */ +#define UNIARP_CLIENT_AGE 12 /* Client validation timeout */ +#define UNIARP_CLIENT_RETRY 3 /* Client validation retrys */ +#define UNIARP_SERVER_AGE 17 /* Server validation timeout */ +#define UNIARP_SERVER_RETRY 3 /* Server validation retrys */ +#define UNIARP_RETRY_AGE 1 /* Retry timeout */ +#define UNIARP_REVALID_AGE 2 /* Revalidation timeout */ +#define UNIARP_MIN_REFRESH 10 /* Minimum entry refresh time */ + + +/* + * Structure for ATMARP mappings. Each of these structures will contain + * IP address to ATM hardware address mappings. There will be one such + * structure for each IP address and for each unresolved ATM address + * currently in use. + */ +struct uniarp { + struct arpmap ua_arpmap; /* Common entry header */ + struct uniip *ua_intf; /* Interface where we learned answer */ + struct uniarp *ua_next; /* Hash chain link */ + u_char ua_flags; /* Flags (see below) */ + u_char ua_origin; /* Source of mapping (see below) */ + u_char ua_retry; /* Retry counter */ + u_char ua_aging; /* Aging timeout value (minutes) */ + struct ipvcc *ua_ivp; /* Head of IP VCC chain */ + struct atm_time ua_time; /* Timer controls */ +}; +#define ua_dstip ua_arpmap.am_dstip +#define ua_dstatm ua_arpmap.am_dstatm +#define ua_dstatmsub ua_arpmap.am_dstatmsub +#endif /* ATM_KERNEL */ + +/* + * UNIARP Entry Flags + */ +#define UAF_VALID ARPF_VALID /* Entry is valid */ +#define UAF_REFRESH ARPF_REFRESH /* Entry has been refreshed */ +#define UAF_LOCKED 0x04 /* Entry is locked */ +#define UAF_USED 0x08 /* Entry has been used recently */ + +/* + * UNIARP Entry Origin + * + * The origin values are ranked according to the source precedence. + * Larger values are more preferred. + */ +#define UAO_LOCAL 100 /* Local address */ +#define UAO_PERM ARP_ORIG_PERM /* Permanently installed */ +#define UAO_REGISTER 40 /* Learned via client registration */ +#define UAO_SCSP 30 /* Learned via SCSP */ +#define UAO_LOOKUP 20 /* Learned via server lookup */ +#define UAO_PEER_RSP 15 /* Learned from peer - inarp rsp */ +#define UAO_PEER_REQ 10 /* Learned from peer - inarp req */ + +/* + * ATMARP/InATMARP Packet Format + */ +struct atmarp_hdr { + u_short ah_hrd; /* Hardware type (see below) */ + u_short ah_pro; /* Protocol type */ + u_char ah_shtl; /* Type/len of source ATM address */ + u_char ah_sstl; /* Type/len of source ATM subaddress */ + u_short ah_op; /* Operation code (see below) */ + u_char ah_spln; /* Length of source protocol address */ + u_char ah_thtl; /* Type/len of target ATM address */ + u_char ah_tstl; /* Type/len of target ATM subaddress */ + u_char ah_tpln; /* Length of target protocol address */ +#ifdef notdef + /* Variable size fields */ + u_char ah_sha[]; /* Source ATM address */ + u_char ah_ssa[]; /* Source ATM subaddress */ + u_char ah_spa[]; /* Source protocol address */ + u_char ah_tha[]; /* Target ATM subaddress */ + u_char ah_tsa[]; /* Target ATM address */ + u_char ah_tpa[]; /* Target protocol subaddress */ +#endif +}; + +/* + * Hardware types + */ +#define ARP_ATMFORUM 19 + +/* + * Operation types + */ +#define ARP_REQUEST 1 /* ATMARP request */ +#define ARP_REPLY 2 /* ATMARP response */ +#define INARP_REQUEST 8 /* InATMARP request */ +#define INARP_REPLY 9 /* InATMARP response */ +#define ARP_NAK 10 /* ATMARP negative ack */ + +/* + * Type/length fields + */ +#define ARP_TL_TMASK 0x40 /* Type mask */ +#define ARP_TL_NSAPA 0x00 /* Type = ATM Forum NSAPA */ +#define ARP_TL_E164 0x40 /* Type = E.164 */ +#define ARP_TL_LMASK 0x3f /* Length mask */ + + +#ifdef ATM_KERNEL +/* + * Timer macros + */ +#define UNIIP_ARP_TIMER(s, t) atm_timeout(&(s)->uip_arptime, (t), uniarp_iftimeout) +#define UNIIP_ARP_CANCEL(s) atm_untimeout(&(s)->uip_arptime) +#define UNIARP_TIMER(s, t) atm_timeout(&(s)->ua_time, (t), uniarp_timeout) +#define UNIARP_CANCEL(s) atm_untimeout(&(s)->ua_time) + + +/* + * Macros for manipulating UNIARP tables and entries + */ +#define UNIARP_HASH(ip) ((u_long)(ip) % UNIARP_HASHSIZ) + +#define UNIARP_ADD(ua) \ +{ \ + struct uniarp **h; \ + h = &uniarp_arptab[UNIARP_HASH((ua)->ua_dstip.s_addr)]; \ + LINK2TAIL((ua), struct uniarp, *h, ua_next); \ +} + +#define UNIARP_DELETE(ua) \ +{ \ + struct uniarp **h; \ + h = &uniarp_arptab[UNIARP_HASH((ua)->ua_dstip.s_addr)]; \ + UNLINK((ua), struct uniarp, *h, ua_next); \ +} + +#define UNIARP_LOOKUP(ip, ua) \ +{ \ + for ((ua) = uniarp_arptab[UNIARP_HASH(ip)]; \ + (ua); (ua) = (ua)->ua_next) { \ + if ((ua)->ua_dstip.s_addr == (ip)) \ + break; \ + } \ +} + + +/* + * Global UNIARP Statistics + */ +struct uniarp_stat { + u_long uas_rcvdrop; /* Input packets dropped */ +}; + + +/* + * External variables + */ +extern struct uniip *uniip_head; +extern struct ip_serv uniip_ipserv; +extern struct uniarp *uniarp_arptab[]; +extern struct uniarp *uniarp_nomaptab; +extern struct uniarp *uniarp_pvctab; +extern struct sp_info uniarp_pool; +extern struct atm_time uniarp_timer; +extern int uniarp_print; +extern Atm_endpoint uniarp_endpt; +extern struct uniarp_stat uniarp_stat; + + +/* + * Global function declarations + */ + /* uniarp.c */ +int uniarp_start __P((void)); +void uniarp_stop __P((void)); +void uniarp_ipact __P((struct uniip *)); +void uniarp_ipdact __P((struct uniip *)); +void uniarp_ifaddr __P((struct siginst *)); +void uniarp_iftimeout __P((struct atm_time *)); +int uniarp_ioctl __P((int, caddr_t, caddr_t)); +caddr_t uniarp_getname __P((void *)); + + /* uniarp_cache.c */ +int uniarp_cache_svc __P((struct uniip *, struct in_addr *, + Atm_addr *, Atm_addr *, u_int)); +void uniarp_cache_pvc __P((struct ipvcc *, struct in_addr *, + Atm_addr *, Atm_addr *)); +int uniarp_validate_ip __P((struct uniip *, struct in_addr *, + u_int)); + + /* uniarp_input.c */ +void uniarp_cpcs_data __P((void *, KBuffer *)); +void uniarp_pdu_print __P((struct ipvcc *, KBuffer *, char *)); + + /* uniarp_output.c */ +int uniarp_arp_req __P((struct uniip *, struct in_addr *)); +int uniarp_arp_rsp __P((struct uniip *, struct arpmap *, + struct in_addr *, Atm_addr *, + Atm_addr *, struct ipvcc *)); +int uniarp_arp_nak __P((struct uniip *, KBuffer *, struct ipvcc *)); +int uniarp_inarp_req __P((struct uniip *, Atm_addr *, + Atm_addr *, struct ipvcc *)); +int uniarp_inarp_rsp __P((struct uniip *, struct in_addr *, + Atm_addr *, Atm_addr *, struct ipvcc *)); + + /* uniarp_timer.c */ +void uniarp_timeout __P((struct atm_time *)); +void uniarp_aging __P((struct atm_time *)); + + /* uniarp_vcm.c */ +int uniarp_pvcopen __P((struct ipvcc *)); +int uniarp_svcout __P((struct ipvcc *, struct in_addr *)); +int uniarp_svcin __P((struct ipvcc *, Atm_addr *, Atm_addr *)); +int uniarp_svcactive __P((struct ipvcc *)); +void uniarp_vcclose __P((struct ipvcc *)); +void uniarp_connected __P((void *)); +void uniarp_cleared __P((void *, struct t_atm_cause *)); + + /* uniip.c */ +int uniip_start __P((void)); +int uniip_stop __P((void)); + + +#endif /* ATM_KERNEL */ + +#endif /* _UNI_UNIIP_VAR_H */ diff --git a/sys/netatm/uni/unisig.h b/sys/netatm/uni/unisig.h new file mode 100644 index 0000000..b69714d --- /dev/null +++ b/sys/netatm/uni/unisig.h @@ -0,0 +1,49 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig.h,v 1.2 1997/05/06 22:21:33 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * Protocol control blocks + * + */ + +#ifndef _UNISIG_H +#define _UNISIG_H + +/* + * ATM Forum UNI 3.0/3.1 Signalling + */ +#define UNISIG_SIG_VPI 0 /* Signalling VPI */ +#define UNISIG_SIG_VCI 5 /* Signalling VCI */ + +#define STACK_SSCF "uni_sscf" + +#endif /* _UNISIG_H */ diff --git a/sys/netatm/uni/unisig_decode.c b/sys/netatm/uni/unisig_decode.c new file mode 100644 index 0000000..98f5dfd --- /dev/null +++ b/sys/netatm/uni/unisig_decode.c @@ -0,0 +1,2474 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_decode.c,v 1.13 1998/08/26 23:29:20 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * Message formatting module + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: unisig_decode.c,v 1.13 1998/08/26 23:29:20 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/unisig.h> +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/unisig_msg.h> +#include <netatm/uni/unisig_mbuf.h> +#include <netatm/uni/unisig_decode.h> + +#define ALLOC_IE(ie) \ + (ie) = (struct ie_generic *) atm_allocate(&unisig_iepool); \ + if (!ie) \ + return(ENOMEM); + + +/* + * Local functions + */ +static int usf_dec_ie __P((struct usfmt *, struct unisig_msg *, struct ie_generic *)); +static int usf_dec_ie_hdr __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_aalp __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_clrt __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_bbcp __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_bhli __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_blli __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_clst __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_cdad __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_cdsa __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_cgad __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_cgsa __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_caus __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_cnid __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_qosp __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_brpi __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_rsti __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_bsdc __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_trnt __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_uimp __P((struct usfmt *, struct ie_generic *)); +static int usf_dec_ie_ident __P((struct usfmt *, struct ie_generic *, + struct ie_decode_tbl *)); +static int usf_dec_atm_addr __P((struct usfmt *, Atm_addr *, int)); + + +/* + * Table associating IE type with IE vector index + */ +u_char unisig_ie_ident_vec[] = { + UNI_IE_AALP, + UNI_IE_CLRT, + UNI_IE_BBCP, + UNI_IE_BHLI, + UNI_IE_BLLI, + UNI_IE_CLST, + UNI_IE_CDAD, + UNI_IE_CDSA, + UNI_IE_CGAD, + UNI_IE_CGSA, + UNI_IE_CAUS, + UNI_IE_CNID, + UNI_IE_QOSP, + UNI_IE_BRPI, + UNI_IE_RSTI, + UNI_IE_BLSH, + UNI_IE_BNSH, + UNI_IE_BSDC, + UNI_IE_TRNT, + UNI_IE_EPRF, + UNI_IE_EPST +}; + + +/* + * Tables specifying which IEs are mandatory, optional, and + * not allowed for each Q.2931 message type + */ +static u_char uni_calp_ie_tbl[] = { + IE_NA, /* ATM AAL Parameters */ + IE_NA, /* ATM User Cell Rate */ + IE_NA, /* Broadband Bearer Capability */ + IE_NA, /* Broadband High Layer Information */ + IE_NA, /* Broadband Low Layer Information */ + IE_NA, /* Call State */ + IE_NA, /* Called Party Number */ + IE_NA, /* Called Party Subaddress */ + IE_NA, /* Calling Party Number */ + IE_NA, /* Calling Party Subaddress */ + IE_NA, /* Cause */ + IE_OPT, /* Connection Identifier */ + IE_NA, /* Quality of Service Parameters */ + IE_NA, /* Broadband Repeat Indicator */ + IE_NA, /* Restart Indicator */ + IE_NA, /* Broadband Locking Shift */ + IE_NA, /* Broadband Non-locking Shift */ + IE_NA, /* Broadband Sending Complete */ + IE_NA, /* Transit Net */ + IE_OPT, /* Endpoint Reference */ + IE_NA /* Endpoint State */ +}; + +static u_char uni_conn_ie_tbl[] = { + IE_OPT, /* ATM AAL Parameters */ + IE_NA, /* ATM User Cell Rate */ + IE_NA, /* Broadband Bearer Capability */ + IE_NA, /* Broadband High Layer Information */ + IE_OPT, /* Broadband Low Layer Information */ + IE_NA, /* Call State */ + IE_NA, /* Called Party Number */ + IE_NA, /* Called Party Subaddress */ + IE_NA, /* Calling Party Number */ + IE_NA, /* Calling Party Subaddress */ + IE_NA, /* Cause */ + IE_OPT, /* Connection Identifier */ + IE_NA, /* Quality of Service Parameters */ + IE_NA, /* Broadband Repeat Indicator */ + IE_NA, /* Restart Indicator */ + IE_NA, /* Broadband Locking Shift */ + IE_NA, /* Broadband Non-locking Shift */ + IE_NA, /* Broadband Sending Complete */ + IE_NA, /* Transit Net */ + IE_OPT, /* Endpoint Reference */ + IE_NA /* Endpoint State */ +}; + +static u_char uni_cack_ie_tbl[] = { + IE_NA, /* ATM AAL Parameters */ + IE_NA, /* ATM User Cell Rate */ + IE_NA, /* Broadband Bearer Capability */ + IE_NA, /* Broadband High Layer Information */ + IE_NA, /* Broadband Low Layer Information */ + IE_NA, /* Call State */ + IE_NA, /* Called Party Number */ + IE_NA, /* Called Party Subaddress */ + IE_NA, /* Calling Party Number */ + IE_NA, /* Calling Party Subaddress */ + IE_NA, /* Cause */ + IE_NA, /* Connection Identifier */ + IE_NA, /* Quality of Service Parameters */ + IE_NA, /* Broadband Repeat Indicator */ + IE_NA, /* Restart Indicator */ + IE_NA, /* Broadband Locking Shift */ + IE_NA, /* Broadband Non-locking Shift */ + IE_NA, /* Broadband Sending Complete */ + IE_NA, /* Transit Net */ + IE_NA, /* Endpoint Reference */ + IE_NA /* Endpoint State */ +}; + +static u_char uni_setu_ie_tbl[] = { + IE_MAND, /* ATM AAL Parameters (not required by + UNI 3.0) */ + IE_MAND, /* ATM User Cell Rate */ + IE_MAND, /* Broadband Bearer Capability */ + IE_OPT, /* Broadband High Layer Information */ + IE_MAND, /* Broadband Low Layer Information (not required by UNI 3.0 */ + IE_NA, /* Call State */ + IE_MAND, /* Called Party Number */ + IE_OPT, /* Called Party Subaddress */ + IE_OPT, /* Calling Party Number */ + IE_OPT, /* Calling Party Subaddress */ + IE_NA, /* Cause */ + IE_MAND, /* Connection Identifier */ + IE_MAND, /* Quality of Service Parameters */ + IE_OPT, /* Broadband Repeat Indicator */ + IE_NA, /* Restart Indicator */ + IE_NA, /* Broadband Locking Shift */ + IE_NA, /* Broadband Non-locking Shift */ + IE_OPT, /* Broadband Sending Complete */ + IE_NA, /* Transit Net */ + IE_OPT, /* Endpoint Reference */ + IE_NA /* Endpoint State */ +}; + +static u_char uni_rlse_ie_tbl[] = { + IE_NA, /* ATM AAL Parameters */ + IE_NA, /* ATM User Cell Rate */ + IE_NA, /* Broadband Bearer Capability */ + IE_NA, /* Broadband High Layer Information */ + IE_NA, /* Broadband Low Layer Information */ + IE_NA, /* Call State */ + IE_NA, /* Called Party Number */ + IE_NA, /* Called Party Subaddress */ + IE_NA, /* Calling Party Number */ + IE_NA, /* Calling Party Subaddress */ + IE_MAND, /* Cause */ + IE_NA, /* Connection Identifier */ + IE_NA, /* Quality of Service Parameters */ + IE_NA, /* Broadband Repeat Indicator */ + IE_NA, /* Restart Indicator */ + IE_NA, /* Broadband Locking Shift */ + IE_NA, /* Broadband Non-locking Shift */ + IE_NA, /* Broadband Sending Complete */ + IE_NA, /* Transit Net */ + IE_NA, /* Endpoint Reference */ + IE_NA /* Endpoint State */ +}; + +static u_char uni_rlsc_ie_tbl[] = { + IE_NA, /* ATM AAL Parameters */ + IE_NA, /* ATM User Cell Rate */ + IE_NA, /* Broadband Bearer Capability */ + IE_NA, /* Broadband High Layer Information */ + IE_NA, /* Broadband Low Layer Information */ + IE_NA, /* Call State */ + IE_NA, /* Called Party Number */ + IE_NA, /* Called Party Subaddress */ + IE_NA, /* Calling Party Number */ + IE_NA, /* Calling Party Subaddress */ + IE_MAND, /* Cause */ + IE_NA, /* Connection Identifier */ + IE_NA, /* Quality of Service Parameters */ + IE_NA, /* Broadband Repeat Indicator */ + IE_NA, /* Restart Indicator */ + IE_NA, /* Broadband Locking Shift */ + IE_NA, /* Broadband Non-locking Shift */ + IE_NA, /* Broadband Sending Complete */ + IE_NA, /* Transit Net */ + IE_NA, /* Endpoint Reference */ + IE_NA /* Endpoint State */ +}; + +static u_char uni_rstr_ie_tbl[] = { + IE_NA, /* ATM AAL Parameters */ + IE_NA, /* ATM User Cell Rate */ + IE_NA, /* Broadband Bearer Capability */ + IE_NA, /* Broadband High Layer Information */ + IE_NA, /* Broadband Low Layer Information */ + IE_NA, /* Call State */ + IE_NA, /* Called Party Number */ + IE_NA, /* Called Party Subaddress */ + IE_NA, /* Calling Party Number */ + IE_NA, /* Calling Party Subaddress */ + IE_NA, /* Cause */ + IE_OPT, /* Connection Identifier */ + IE_NA, /* Quality of Service Parameters */ + IE_NA, /* Broadband Repeat Indicator */ + IE_MAND, /* Restart Indicator */ + IE_NA, /* Broadband Locking Shift */ + IE_NA, /* Broadband Non-locking Shift */ + IE_NA, /* Broadband Sending Complete */ + IE_NA, /* Transit Net */ + IE_NA, /* Endpoint Reference */ + IE_NA /* Endpoint State */ +}; + +static u_char uni_rsta_ie_tbl[] = { + IE_NA, /* ATM AAL Parameters */ + IE_NA, /* ATM User Cell Rate */ + IE_NA, /* Broadband Bearer Capability */ + IE_NA, /* Broadband High Layer Information */ + IE_NA, /* Broadband Low Layer Information */ + IE_NA, /* Call State */ + IE_NA, /* Called Party Number */ + IE_NA, /* Called Party Subaddress */ + IE_NA, /* Calling Party Number */ + IE_NA, /* Calling Party Subaddress */ + IE_NA, /* Cause */ + IE_OPT, /* Connection Identifier */ + IE_NA, /* Quality of Service Parameters */ + IE_NA, /* Broadband Repeat Indicator */ + IE_MAND, /* Restart Indicator */ + IE_NA, /* Broadband Locking Shift */ + IE_NA, /* Broadband Non-locking Shift */ + IE_NA, /* Broadband Sending Complete */ + IE_NA, /* Transit Net */ + IE_NA, /* Endpoint Reference */ + IE_NA /* Endpoint State */ +}; + +static u_char uni_stat_ie_tbl[] = { + IE_NA, /* ATM AAL Parameters */ + IE_NA, /* ATM User Cell Rate */ + IE_NA, /* Broadband Bearer Capability */ + IE_NA, /* Broadband High Layer Information */ + IE_NA, /* Broadband Low Layer Information */ + IE_MAND, /* Call State */ + IE_NA, /* Called Party Number */ + IE_NA, /* Called Party Subaddress */ + IE_NA, /* Calling Party Number */ + IE_NA, /* Calling Party Subaddress */ + IE_MAND, /* Cause */ + IE_NA, /* Connection Identifier */ + IE_NA, /* Quality of Service Parameters */ + IE_NA, /* Broadband Repeat Indicator */ + IE_NA, /* Restart Indicator */ + IE_NA, /* Broadband Locking Shift */ + IE_NA, /* Broadband Non-locking Shift */ + IE_NA, /* Broadband Sending Complete */ + IE_NA, /* Transit Net */ + IE_OPT, /* Endpoint Reference */ + IE_OPT /* Endpoint State */ +}; + +static u_char uni_senq_ie_tbl[] = { + IE_NA, /* ATM AAL Parameters */ + IE_NA, /* ATM User Cell Rate */ + IE_NA, /* Broadband Bearer Capability */ + IE_NA, /* Broadband High Layer Information */ + IE_NA, /* Broadband Low Layer Information */ + IE_NA, /* Call State */ + IE_NA, /* Called Party Number */ + IE_NA, /* Called Party Subaddress */ + IE_NA, /* Calling Party Number */ + IE_NA, /* Calling Party Subaddress */ + IE_NA, /* Cause */ + IE_NA, /* Connection Identifier */ + IE_NA, /* Quality of Service Parameters */ + IE_NA, /* Broadband Repeat Indicator */ + IE_NA, /* Restart Indicator */ + IE_NA, /* Broadband Locking Shift */ + IE_NA, /* Broadband Non-locking Shift */ + IE_NA, /* Broadband Sending Complete */ + IE_NA, /* Transit Net */ + IE_OPT, /* Endpoint Reference */ + IE_NA /* Endpoint State */ +}; + +static u_char uni_addp_ie_tbl[] = { + IE_OPT, /* ATM AAL Parameters */ + IE_NA, /* ATM User Cell Rate */ + IE_NA, /* Broadband Bearer Capability */ + IE_OPT, /* Broadband High Layer Information */ + IE_OPT, /* Broadband Low Layer Information */ + IE_NA, /* Call State */ + IE_MAND, /* Called Party Number */ + IE_OPT, /* Called Party Subaddress */ + IE_OPT, /* Calling Party Number */ + IE_OPT, /* Calling Party Subaddress */ + IE_NA, /* Cause */ + IE_NA, /* Connection Identifier */ + IE_NA, /* Quality of Service Parameters */ + IE_NA, /* Broadband Repeat Indicator */ + IE_NA, /* Restart Indicator */ + IE_NA, /* Broadband Locking Shift */ + IE_NA, /* Broadband Non-locking Shift */ + IE_OPT, /* Broadband Sending Complete */ + IE_NA, /* Transit Net */ + IE_MAND, /* Endpoint Reference */ + IE_NA /* Endpoint State */ +}; + +static u_char uni_adpa_ie_tbl[] = { + IE_NA, /* ATM AAL Parameters */ + IE_NA, /* ATM User Cell Rate */ + IE_NA, /* Broadband Bearer Capability */ + IE_NA, /* Broadband High Layer Information */ + IE_NA, /* Broadband Low Layer Information */ + IE_NA, /* Call State */ + IE_NA, /* Called Party Number */ + IE_NA, /* Called Party Subaddress */ + IE_NA, /* Calling Party Number */ + IE_NA, /* Calling Party Subaddress */ + IE_NA, /* Cause */ + IE_NA, /* Connection Identifier */ + IE_NA, /* Quality of Service Parameters */ + IE_NA, /* Broadband Repeat Indicator */ + IE_NA, /* Restart Indicator */ + IE_NA, /* Broadband Locking Shift */ + IE_NA, /* Broadband Non-locking Shift */ + IE_NA, /* Broadband Sending Complete */ + IE_NA, /* Transit Net */ + IE_MAND, /* Endpoint Reference */ + IE_NA /* Endpoint State */ +}; + +static u_char uni_adpr_ie_tbl[] = { + IE_NA, /* ATM AAL Parameters */ + IE_NA, /* ATM User Cell Rate */ + IE_NA, /* Broadband Bearer Capability */ + IE_NA, /* Broadband High Layer Information */ + IE_NA, /* Broadband Low Layer Information */ + IE_NA, /* Call State */ + IE_NA, /* Called Party Number */ + IE_NA, /* Called Party Subaddress */ + IE_NA, /* Calling Party Number */ + IE_NA, /* Calling Party Subaddress */ + IE_MAND, /* Cause */ + IE_NA, /* Connection Identifier */ + IE_NA, /* Quality of Service Parameters */ + IE_NA, /* Broadband Repeat Indicator */ + IE_NA, /* Restart Indicator */ + IE_NA, /* Broadband Locking Shift */ + IE_NA, /* Broadband Non-locking Shift */ + IE_NA, /* Broadband Sending Complete */ + IE_NA, /* Transit Net */ + IE_MAND, /* Endpoint Reference */ + IE_NA /* Endpoint State */ +}; + +static u_char uni_drpp_ie_tbl[] = { + IE_NA, /* ATM AAL Parameters */ + IE_NA, /* ATM User Cell Rate */ + IE_NA, /* Broadband Bearer Capability */ + IE_NA, /* Broadband High Layer Information */ + IE_NA, /* Broadband Low Layer Information */ + IE_NA, /* Call State */ + IE_NA, /* Called Party Number */ + IE_NA, /* Called Party Subaddress */ + IE_NA, /* Calling Party Number */ + IE_NA, /* Calling Party Subaddress */ + IE_MAND, /* Cause */ + IE_NA, /* Connection Identifier */ + IE_NA, /* Quality of Service Parameters */ + IE_NA, /* Broadband Repeat Indicator */ + IE_NA, /* Restart Indicator */ + IE_NA, /* Broadband Locking Shift */ + IE_NA, /* Broadband Non-locking Shift */ + IE_NA, /* Broadband Sending Complete */ + IE_NA, /* Transit Net */ + IE_MAND, /* Endpoint Reference */ + IE_NA /* Endpoint State */ +}; + +static u_char uni_drpa_ie_tbl[] = { + IE_NA, /* ATM AAL Parameters */ + IE_NA, /* ATM User Cell Rate */ + IE_NA, /* Broadband Bearer Capability */ + IE_NA, /* Broadband High Layer Information */ + IE_NA, /* Broadband Low Layer Information */ + IE_NA, /* Call State */ + IE_NA, /* Called Party Number */ + IE_NA, /* Called Party Subaddress */ + IE_NA, /* Calling Party Number */ + IE_NA, /* Calling Party Subaddress */ + IE_OPT, /* Cause */ + IE_NA, /* Connection Identifier */ + IE_NA, /* Quality of Service Parameters */ + IE_NA, /* Broadband Repeat Indicator */ + IE_NA, /* Restart Indicator */ + IE_NA, /* Broadband Locking Shift */ + IE_NA, /* Broadband Non-locking Shift */ + IE_NA, /* Broadband Sending Complete */ + IE_NA, /* Transit Net */ + IE_MAND, /* Endpoint Reference */ + IE_NA /* Endpoint State */ +}; + +/* + * Table of Q.2931 message types + */ +static struct { + u_char msg_type; + u_char *msg_ie_tbl; +} uni_msg_types[] = { + { UNI_MSG_CALP, uni_calp_ie_tbl }, + { UNI_MSG_CONN, uni_conn_ie_tbl }, + { UNI_MSG_CACK, uni_cack_ie_tbl }, + { UNI_MSG_SETU, uni_setu_ie_tbl }, + { UNI_MSG_RLSE, uni_rlse_ie_tbl }, + { UNI_MSG_RLSC, uni_rlsc_ie_tbl }, + { UNI_MSG_RSTR, uni_rstr_ie_tbl }, + { UNI_MSG_RSTA, uni_rsta_ie_tbl }, + { UNI_MSG_STAT, uni_stat_ie_tbl }, + { UNI_MSG_SENQ, uni_senq_ie_tbl }, + { UNI_MSG_ADDP, uni_addp_ie_tbl }, + { UNI_MSG_ADPA, uni_adpa_ie_tbl }, + { UNI_MSG_ADPR, uni_adpr_ie_tbl }, + { UNI_MSG_DRPP, uni_drpp_ie_tbl }, + { UNI_MSG_DRPA, uni_drpa_ie_tbl }, +}; + + +/* + * Table of information elements + */ +static struct ie_ent ie_table[] = { + { UNI_IE_AALP, 5, 16, UNI_MSG_IE_AALP, usf_dec_ie_aalp }, + { UNI_IE_CLRT, 0, 26, UNI_MSG_IE_CLRT, usf_dec_ie_clrt }, + { UNI_IE_BBCP, 2, 3, UNI_MSG_IE_BBCP, usf_dec_ie_bbcp }, + { UNI_IE_BHLI, 1, 9, UNI_MSG_IE_BHLI, usf_dec_ie_bhli }, + { UNI_IE_BLLI, 0, 13, UNI_MSG_IE_BLLI, usf_dec_ie_blli }, + { UNI_IE_CLST, 1, 1, UNI_MSG_IE_CLST, usf_dec_ie_clst }, + { UNI_IE_CDAD, 1, 21, UNI_MSG_IE_CDAD, usf_dec_ie_cdad }, + { UNI_IE_CDSA, 1, 21, UNI_MSG_IE_CDSA, usf_dec_ie_cdsa }, + { UNI_IE_CGAD, 1, 22, UNI_MSG_IE_CGAD, usf_dec_ie_cgad }, + { UNI_IE_CGSA, 1, 21, UNI_MSG_IE_CGSA, usf_dec_ie_cgsa }, + { UNI_IE_CAUS, 2, 30, UNI_MSG_IE_CAUS, usf_dec_ie_caus }, + { UNI_IE_CNID, 5, 5, UNI_MSG_IE_CNID, usf_dec_ie_cnid }, + { UNI_IE_QOSP, 2, 2, UNI_MSG_IE_QOSP, usf_dec_ie_qosp }, + { UNI_IE_BRPI, 1, 1, UNI_MSG_IE_BRPI, usf_dec_ie_brpi }, + { UNI_IE_RSTI, 1, 1, UNI_MSG_IE_RSTI, usf_dec_ie_rsti }, + { UNI_IE_BLSH, 1, 1, UNI_MSG_IE_ERR, usf_dec_ie_uimp }, + { UNI_IE_BNSH, 1, 1, UNI_MSG_IE_ERR, usf_dec_ie_uimp }, + { UNI_IE_BSDC, 1, 1, UNI_MSG_IE_BSDC, usf_dec_ie_bsdc }, + { UNI_IE_TRNT, 1, 5, UNI_MSG_IE_TRNT, usf_dec_ie_trnt }, + { UNI_IE_EPRF, 3, 3, UNI_MSG_IE_ERR, usf_dec_ie_uimp }, + { UNI_IE_EPST, 1, 1, UNI_MSG_IE_ERR, usf_dec_ie_uimp }, + { 0, 0, 0, 0, 0 } +}; + +/* + * Decoding table for AAL 1 + */ +struct ie_decode_tbl ie_aal1_tbl[] = { + { 133, 1, IE_OFF_SIZE(ie_aalp_1_subtype) }, + { 134, 1, IE_OFF_SIZE(ie_aalp_1_cbr_rate) }, + { 135, 2, IE_OFF_SIZE(ie_aalp_1_multiplier) }, + { 136, 1, IE_OFF_SIZE(ie_aalp_1_clock_recovery) }, + { 137, 1, IE_OFF_SIZE(ie_aalp_1_error_correction) }, + { 138, 1, IE_OFF_SIZE(ie_aalp_1_struct_data_tran) }, + { 139, 1, IE_OFF_SIZE(ie_aalp_1_partial_cells) }, + { 0, 0, 0, 0 } +}; + +/* + * Decoding table for AAL 3/4 + */ +struct ie_decode_tbl ie_aal4_tbl_30[] = { + { 140, 2, IE_OFF_SIZE(ie_aalp_4_fwd_max_sdu) }, + { 129, 2, IE_OFF_SIZE(ie_aalp_4_bkwd_max_sdu) }, + { 130, 2, IE_OFF_SIZE(ie_aalp_4_mid_range) }, + { 131, 1, IE_OFF_SIZE(ie_aalp_4_mode) }, + { 132, 1, IE_OFF_SIZE(ie_aalp_4_sscs_type) }, + { 0, 0, 0, 0 } +}; +struct ie_decode_tbl ie_aal4_tbl_31[] = { + { 140, 2, IE_OFF_SIZE(ie_aalp_4_fwd_max_sdu) }, + { 129, 2, IE_OFF_SIZE(ie_aalp_4_bkwd_max_sdu) }, + { 130, 4, IE_OFF_SIZE(ie_aalp_4_mid_range) }, + { 132, 1, IE_OFF_SIZE(ie_aalp_4_sscs_type) }, + { 0, 0, 0, 0 } +}; + +/* + * Decoding table for AAL 5 + */ +struct ie_decode_tbl ie_aal5_tbl_30[] = { + { 140, 2, IE_OFF_SIZE(ie_aalp_5_fwd_max_sdu) }, + { 129, 2, IE_OFF_SIZE(ie_aalp_5_bkwd_max_sdu) }, + { 131, 1, IE_OFF_SIZE(ie_aalp_5_mode) }, + { 132, 1, IE_OFF_SIZE(ie_aalp_5_sscs_type) }, + { 0, 0, 0, 0 } +}; +struct ie_decode_tbl ie_aal5_tbl_31[] = { + { 140, 2, IE_OFF_SIZE(ie_aalp_5_fwd_max_sdu) }, + { 129, 2, IE_OFF_SIZE(ie_aalp_5_bkwd_max_sdu) }, + { 132, 1, IE_OFF_SIZE(ie_aalp_5_sscs_type) }, + { 0, 0, 0, 0 } +}; + +/* + * Decoding table for ATM user cell rate + */ +struct ie_decode_tbl ie_clrt_tbl[] = { + {UNI_IE_CLRT_FWD_PEAK_ID, 3, IE_OFF_SIZE(ie_clrt_fwd_peak)}, + {UNI_IE_CLRT_BKWD_PEAK_ID, 3, IE_OFF_SIZE(ie_clrt_bkwd_peak)}, + {UNI_IE_CLRT_FWD_PEAK_01_ID, 3, IE_OFF_SIZE(ie_clrt_fwd_peak_01)}, + {UNI_IE_CLRT_BKWD_PEAK_01_ID, 3, IE_OFF_SIZE(ie_clrt_bkwd_peak_01)}, + {UNI_IE_CLRT_FWD_SUST_ID, 3, IE_OFF_SIZE(ie_clrt_fwd_sust)}, + {UNI_IE_CLRT_BKWD_SUST_ID, 3, IE_OFF_SIZE(ie_clrt_bkwd_sust)}, + {UNI_IE_CLRT_FWD_SUST_01_ID, 3, IE_OFF_SIZE(ie_clrt_fwd_sust_01)}, + {UNI_IE_CLRT_BKWD_SUST_01_ID, 3, IE_OFF_SIZE(ie_clrt_bkwd_sust_01)}, + {UNI_IE_CLRT_FWD_BURST_ID, 3, IE_OFF_SIZE(ie_clrt_fwd_burst)}, + {UNI_IE_CLRT_BKWD_BURST_ID, 3, IE_OFF_SIZE(ie_clrt_bkwd_burst)}, + {UNI_IE_CLRT_FWD_BURST_01_ID, 3, IE_OFF_SIZE(ie_clrt_fwd_burst_01)}, + {UNI_IE_CLRT_BKWD_BURST_01_ID, 3, IE_OFF_SIZE(ie_clrt_bkwd_burst_01)}, + {UNI_IE_CLRT_BEST_EFFORT_ID, 0, IE_OFF_SIZE(ie_clrt_best_effort)}, + {UNI_IE_CLRT_TM_OPTIONS_ID, 1, IE_OFF_SIZE(ie_clrt_tm_options)}, + {0, 0, 0, 0 } +}; + +/* + * IEs initialized to empty values + */ +struct ie_aalp ie_aalp_absent = { + T_ATM_ABSENT +}; + +struct ie_clrt ie_clrt_absent = { + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT +}; + +struct ie_bbcp ie_bbcp_absent = { + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT +}; + +struct ie_bhli ie_bhli_absent = { + T_ATM_ABSENT, + { 0, 0, 0, 0, 0, 0, 0, 0 } +}; + +struct ie_blli ie_blli_absent = { + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + { 0, 0, 0 }, + { 0, 0 } +}; + +struct ie_clst ie_clst_absent = { + T_ATM_ABSENT +}; + +struct ie_cdad ie_cdad_absent = { + T_ATM_ABSENT, + T_ATM_ABSENT, + { T_ATM_ABSENT, 0 } +}; + +struct ie_cdsa ie_cdsa_absent = { + { T_ATM_ABSENT, 0 } +}; + +struct ie_cgad ie_cgad_absent = { + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + { T_ATM_ABSENT, 0 } +}; + +struct ie_cgsa ie_cgsa_absent = { + { T_ATM_ABSENT, 0 } +}; + +struct ie_caus ie_caus_absent = { + T_ATM_ABSENT, + T_ATM_ABSENT, + 0 +}; + +struct ie_cnid ie_cnid_absent = { + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT, + T_ATM_ABSENT +}; + +struct ie_qosp ie_qosp_absent = { + T_ATM_ABSENT, + T_ATM_ABSENT +}; + +struct ie_brpi ie_brpi_absent = { + T_ATM_ABSENT +}; + +struct ie_rsti ie_rsti_absent = { + T_ATM_ABSENT +}; + +struct ie_blsh ie_blsh_absent = { + T_ATM_ABSENT +}; + +struct ie_bnsh ie_bnsh_absent = { + T_ATM_ABSENT +}; + +struct ie_bsdc ie_bsdc_absent = { + T_ATM_ABSENT +}; + +struct ie_trnt ie_trnt_absent = { + T_ATM_ABSENT, + T_ATM_ABSENT, + 0 +}; + +struct ie_eprf ie_eprf_absent = { + T_ATM_ABSENT, + T_ATM_ABSENT +}; + +struct ie_epst ie_epst_absent = { + T_ATM_ABSENT +}; + + +/* + * Decode a UNI signalling message + * + * Arguments: + * usf pointer to a unisig formatting structure + * msg pointer to a signalling message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +int +usf_dec_msg(usf, msg) + struct usfmt *usf; + struct unisig_msg *msg; +{ + int i, len, rc; + short s; + u_char c, *ie_tbl; + struct ie_generic *ie; + + ATM_DEBUG2("usf_dec_msg: usf=0x%x, msg=0x%x\n", (int) usf, + (int) msg); + + /* + * Check the total message length + */ + if (usf_count(usf) < UNI_MSG_MIN_LEN) { + return(EIO); + } + + /* + * Get and check the protocol discriminator + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + if (c != UNI_MSG_DISC_Q93B) + return(EIO); + + /* + * Get and check the call reference length + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + if (c != 3) + return(EIO); + + /* + * Get the call reference + */ + rc = usf_int3(usf, &msg->msg_call_ref); + if (rc) + return(rc); + + /* + * Get the message type + */ + rc = usf_byte(usf, &msg->msg_type); + if (rc) + return(rc); + + /* + * Get the message type extension + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + msg->msg_type_flag = (c >> UNI_MSG_TYPE_FLAG_SHIFT) & + UNI_MSG_TYPE_FLAG_MASK; + msg->msg_type_action = c & UNI_MSG_TYPE_ACT_MASK; + + /* + * Get the message length and make sure we actually have + * enough data for the whole message + */ + rc = usf_short(usf, &s); + if (rc) + return(rc); + msg->msg_length = s; + if (usf_count(usf) != msg->msg_length) { + return(EMSGSIZE); + } + + /* + * Process information elements + */ + len = msg->msg_length; + while (len) { + ALLOC_IE(ie); + rc = usf_dec_ie(usf, msg, ie); + if (rc) { + atm_free(ie); + return(rc); + } + len -= (ie->ie_length + UNI_IE_HDR_LEN); + } + + /* + * Make sure that mandatory IEs are included and + * unwanted ones aren't + */ + for (i=0; msg->msg_type!=uni_msg_types[i].msg_type && + uni_msg_types[i].msg_type!=0; i++) { + } + if (!uni_msg_types[i].msg_ie_tbl) + goto done; + + /* + * If the message type is in the table, check the IEs. + * If it isn't, the receive routine will catch the error. + */ + ie_tbl = uni_msg_types[i].msg_ie_tbl; + for (i=0; i<UNI_MSG_IE_CNT-1; i++) { + switch(ie_tbl[i]) { + case IE_MAND: + if (!msg->msg_ie_vec[i]) { + /* + * Mandatory IE missing + */ + ALLOC_IE(ie); + ie->ie_ident = unisig_ie_ident_vec[i]; + ie->ie_err_cause = UNI_IE_CAUS_MISSING; + MSG_IE_ADD(msg, ie, UNI_MSG_IE_ERR); + } + break; + case IE_NA: + if (msg->msg_ie_vec[i]) { + /* + * Disallowed IE present + */ + ie = msg->msg_ie_vec[i]; + msg->msg_ie_vec[i] = + (struct ie_generic *) 0; + MSG_IE_ADD(msg, ie, UNI_MSG_IE_ERR); + while (ie) { + ie->ie_err_cause = + UNI_IE_CAUS_IEEXIST; + ie = ie->ie_next; + } + } + break; + case IE_OPT: + break; + } + } + +done: + return(0); +} + + +/* + * Decode an information element + * + * This routine will be called repeatedly as long as there are + * information elements left to be decoded. It will decode the + * first part of the IE, look its type up in a table, and call + * the appropriate routine to decode the rest. After an IE is + * successfully decoded, it is linked into the UNI signalling + * message structure. If an error is discovered, the IE is linked + * into the IE error chain and an error cause is set in the header. + * + * Arguments: + * usf pointer to a UNISIG formatting structure + * msg pointer to a UNISIG message structure + * ie pointer to a generic IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie(usf, msg, ie) + struct usfmt *usf; + struct unisig_msg *msg; + struct ie_generic *ie; +{ + int i, ie_index, rc; + + /* + * Decode the IE header (identifier, instruction field, + * and length) + */ + rc = usf_dec_ie_hdr(usf, ie); + if (rc) + return(rc); + /* + * Ignore the IE if it is of zero length. + */ + if (!ie->ie_length) { + atm_free(ie); + return(0); + } + + /* + * Look up the information element in the table + */ + for (i=0; (ie->ie_ident != ie_table[i].ident) && + (ie_table[i].decode != NULL); i++) { + } + if (ie_table[i].decode == NULL) { + /* + * Unrecognized IE + */ + ie_index = UNI_MSG_IE_ERR; + } else { + ie_index = ie_table[i].p_idx; + } + + /* + * Check for unimplemented or unrecognized IEs + */ + if (ie_index == UNI_MSG_IE_ERR) { + ie->ie_err_cause = UNI_IE_CAUS_IEEXIST; + + /* + * Skip over the invalid IE + */ + rc = usf_dec_ie_uimp(usf, ie); + if (rc) + return(rc); + goto done; + } + + /* + * Check the length against the IE table + */ + if (ie->ie_length < ie_table[i].min_len || + ie->ie_length > ie_table[i].max_len) { + ie_index = UNI_MSG_IE_ERR; + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + + /* + * Skip over the invalid IE + */ + rc = usf_dec_ie_uimp(usf, ie); + if (rc) + return(rc); + goto done; + } + + /* + * Process the IE by calling the function indicated + * in the IE table + */ + rc = ie_table[i].decode(usf, ie); + if (rc) + return(rc); + + /* + * Link the IE into the signalling message + */ +done: + if (ie->ie_err_cause) { + ie_index = UNI_MSG_IE_ERR; + } + MSG_IE_ADD(msg, ie, ie_index); + + return(0); +} + + +/* + * Decode an information element header + * + * Arguments: + * usf pointer to a UNISIG formatting structure + * ie pointer to a generic IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_hdr(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + u_char c; + short s; + int rc; + + /* + * Get the IE identifier + */ + rc = usf_byte(usf, &ie->ie_ident); + if (rc) + return(rc); + + /* + * Get the extended type + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_coding = (c >> UNI_IE_CODE_SHIFT) & UNI_IE_CODE_MASK; + ie->ie_flag = (c >> UNI_IE_FLAG_SHIFT) & UNI_IE_FLAG_MASK; + ie->ie_action = c & UNI_IE_ACT_MASK; + + /* + * Get the length. + */ + rc = usf_short(usf, &s); + if (rc) + return(rc); + ie->ie_length = s; + + return(0); +} + + +/* + * Decode an AAL parameters information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to an AAL parms IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_aalp(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int i, rc = 0; + + /* + * Clear the IE + */ + KM_COPY(&ie_aalp_absent, &ie->ie_u.ie_aalp, + sizeof(ie_aalp_absent)); + + /* + * Get the AAL type + */ + rc = usf_byte(usf, &ie->ie_aalp_aal_type); + if (rc) + return(rc); + + /* + * Subtract the length of the AAL type from the total. + * It will be readjusted after usf_dec_ie_ident is finished. + */ + ie->ie_length--; + + /* + * Process based on AAL type + */ + switch (ie->ie_aalp_aal_type) { + case UNI_IE_AALP_AT_AAL1: + /* + * Clear the AAL 1 subparameters + */ + ie->ie_aalp_1_subtype = T_ATM_ABSENT; + ie->ie_aalp_1_cbr_rate = T_ATM_ABSENT; + ie->ie_aalp_1_multiplier = T_ATM_ABSENT; + ie->ie_aalp_1_clock_recovery = T_ATM_ABSENT; + ie->ie_aalp_1_error_correction = T_ATM_ABSENT; + ie->ie_aalp_1_struct_data_tran = T_ATM_ABSENT; + ie->ie_aalp_1_partial_cells = T_ATM_ABSENT; + + /* + * Parse the AAL fields based on their IDs + */ + rc = usf_dec_ie_ident(usf, ie, ie_aal1_tbl); + break; + case UNI_IE_AALP_AT_AAL3: + /* + * Clear the AAL 3/4 subparameters + */ + ie->ie_aalp_4_fwd_max_sdu = T_ATM_ABSENT; + ie->ie_aalp_4_bkwd_max_sdu = T_ATM_ABSENT; + ie->ie_aalp_4_mid_range = T_ATM_ABSENT; + ie->ie_aalp_4_mode = T_ATM_ABSENT; + ie->ie_aalp_4_sscs_type = T_ATM_ABSENT; + + /* + * Parse the AAL fields based on their IDs + */ + if (usf->usf_sig->us_proto == ATM_SIG_UNI30) + rc = usf_dec_ie_ident(usf, ie, ie_aal4_tbl_30); + else + rc = usf_dec_ie_ident(usf, ie, ie_aal4_tbl_31); + + /* + * If either forward or backward maximum SDU + * size is specified, the other must also be + * specified. + */ + if ((ie->ie_aalp_4_fwd_max_sdu != T_ATM_ABSENT && + ie->ie_aalp_4_bkwd_max_sdu == T_ATM_ABSENT) || + (ie->ie_aalp_4_fwd_max_sdu == T_ATM_ABSENT && + ie->ie_aalp_4_bkwd_max_sdu != T_ATM_ABSENT)) { + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + } + break; + case UNI_IE_AALP_AT_AAL5: + /* + * Clear the AAL 5 subparameters + */ + ie->ie_aalp_5_fwd_max_sdu = T_ATM_ABSENT; + ie->ie_aalp_5_bkwd_max_sdu = T_ATM_ABSENT; + ie->ie_aalp_5_mode = T_ATM_ABSENT; + ie->ie_aalp_5_sscs_type = T_ATM_ABSENT; + + /* + * Parse the AAL fields based on their IDs + */ + if (usf->usf_sig->us_proto == ATM_SIG_UNI30) + rc = usf_dec_ie_ident(usf, ie, ie_aal5_tbl_30); + else + rc = usf_dec_ie_ident(usf, ie, ie_aal5_tbl_31); + + /* + * If either forward or backward maximum SDU + * size is specified, the other must also be + * specified. + */ + if ((ie->ie_aalp_5_fwd_max_sdu != T_ATM_ABSENT && + ie->ie_aalp_5_bkwd_max_sdu == T_ATM_ABSENT) || + (ie->ie_aalp_5_fwd_max_sdu == T_ATM_ABSENT && + ie->ie_aalp_5_bkwd_max_sdu != T_ATM_ABSENT)) { + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + } + break; + case UNI_IE_AALP_AT_AALU: + /* + * Check user parameter length + */ + if (ie->ie_length > + sizeof(ie->ie_aalp_user_info) + + 1) { + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + } + + /* + * Get the user data + */ + i = 0; + while (i < ie->ie_length - 2) { + rc = usf_byte(usf, &ie->ie_aalp_user_info[i]); + if (rc) + break; + i++; + } + break; + default: + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + } + ie->ie_length++; + + return(rc); +} + + +/* + * Decode a user cell rate information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_clrt(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int rc; + + /* + * Clear the IE + */ + KM_COPY(&ie_clrt_absent, &ie->ie_u.ie_clrt, + sizeof(ie_clrt_absent)); + + /* + * Parse the IE using field identifiers + */ + rc = usf_dec_ie_ident(usf, ie, ie_clrt_tbl); + return(rc); +} + + +/* + * Decode a broadband bearer capability information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_bbcp(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int rc; + u_char c; + + /* + * Clear the IE + */ + KM_COPY(&ie_bbcp_absent, &ie->ie_u.ie_bbcp, + sizeof(ie_bbcp_absent)); + + /* + * Get the broadband bearer class + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_bbcp_bearer_class = c & UNI_IE_BBCP_BC_MASK; + + /* + * If the broadband bearer class was X, the next + * byte has the traffic type and timing requirements + */ + if (ie->ie_bbcp_bearer_class == UNI_IE_BBCP_BC_BCOB_X && + !(c & UNI_IE_EXT_BIT)) { + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_bbcp_traffic_type = (c >> UNI_IE_BBCP_TT_SHIFT) & + UNI_IE_BBCP_TT_MASK; + ie->ie_bbcp_timing_req = c & UNI_IE_BBCP_TR_MASK; + } + + /* + * Get the clipping and user plane connection configuration + */ + if (c & UNI_IE_EXT_BIT) { + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_bbcp_clipping = (c >> UNI_IE_BBCP_SC_SHIFT) & + UNI_IE_BBCP_SC_MASK; + ie->ie_bbcp_conn_config = c & UNI_IE_BBCP_CC_MASK; + } + + return(0); +} + + +/* + * Decode a broadband high layer information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_bhli(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int i, rc; + u_char c; + + /* + * Clear the IE + */ + KM_COPY(&ie_bhli_absent, &ie->ie_u.ie_bhli, + sizeof(ie_bhli_absent)); + + /* + * Get the high layer information type + */ + rc = usf_ext(usf, &i); + ie->ie_bhli_type = i & UNI_IE_EXT_MASK; + if (rc) + return(rc); + + /* + * What comes next depends on the type + */ + switch (ie->ie_bhli_type) { + case UNI_IE_BHLI_TYPE_ISO: + case UNI_IE_BHLI_TYPE_USER: + /* + * ISO or user-specified parameters -- take the + * length of information from the IE length + */ + for (i=0; i<ie->ie_length-1; i++) { + rc = usf_byte(usf, &ie->ie_bhli_info[i]); + if (rc) + return(rc); + } + break; + case UNI_IE_BHLI_TYPE_HLP: + /* + * Make sure the IE is long enough for the high + * layer profile information, then get it + */ + if (usf->usf_sig->us_proto != ATM_SIG_UNI30) + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + if (ie->ie_length < UNI_IE_BHLI_HLP_LEN+1) + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + for (i=0; i<ie->ie_length && + i<UNI_IE_BHLI_HLP_LEN; i++) { + rc = usf_byte(usf, &ie->ie_bhli_info[i]); + if (rc) + return(rc); + } + break; + case UNI_IE_BHLI_TYPE_VSA: + /* + * Make sure the IE is long enough for the vendor- + * specific application information, then get it + */ + if (ie->ie_length < UNI_IE_BHLI_VSA_LEN+1) + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + for (i=0; i<ie->ie_length && + i<UNI_IE_BHLI_VSA_LEN; i++) { + rc = usf_byte(usf, &ie->ie_bhli_info[i]); + if (rc) + return(rc); + } + break; + default: + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + for (i=0; i<ie->ie_length; i++) { + rc = usf_byte(usf, &c); + if (rc) + return(rc); + } + } + + return(0); +} + + +/* + * Decode a broadband low layer information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_blli(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + u_char c, id; + int bc, i, rc; + u_int ipi; + + /* + * Clear the IE + */ + KM_COPY(&ie_blli_absent, &ie->ie_u.ie_blli, + sizeof(ie_blli_absent)); + + /* + * Get paramteters for the protocol layers as long as + * there is still information left in the IE + */ + bc = ie->ie_length; + while (bc) { + /* + * Get the type and process based on what it is + */ + rc = usf_byte(usf, &id); + if (rc) + return(rc); + switch (((id & UNI_IE_EXT_MASK) >> + UNI_IE_BLLI_LID_SHIFT) & + UNI_IE_BLLI_LID_MASK) { + case UNI_IE_BLLI_L1_ID: + /* + * Layer 1 info + */ + ie->ie_blli_l1_id = id & UNI_IE_BLLI_LP_MASK; + bc--; + break; + case UNI_IE_BLLI_L2_ID: + /* + * Layer 2 info--contents vary based on type + */ + ie->ie_blli_l2_id = id & UNI_IE_BLLI_LP_MASK; + bc--; + if (id & UNI_IE_EXT_BIT) + break; + switch (ie->ie_blli_l2_id) { + case UNI_IE_BLLI_L2P_X25L: + case UNI_IE_BLLI_L2P_X25M: + case UNI_IE_BLLI_L2P_HDLC1: + case UNI_IE_BLLI_L2P_HDLC2: + case UNI_IE_BLLI_L2P_HDLC3: + case UNI_IE_BLLI_L2P_Q922: + case UNI_IE_BLLI_L2P_ISO7776: + rc = usf_byte(usf, &c); + if (rc) + return(rc); + bc--; + ie->ie_blli_l2_mode = (c >> + UNI_IE_BLLI_L2MODE_SHIFT) & + UNI_IE_BLLI_L2MODE_MASK; + if (!(c & UNI_IE_EXT_BIT)) + break; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + bc--; + ie->ie_blli_l2_window = + c & UNI_IE_EXT_MASK; + break; + case UNI_IE_BLLI_L2P_USER: + rc = usf_byte(usf, &c); + if (rc) + return(rc); + bc--; + ie->ie_blli_l2_user_proto = + c & UNI_IE_EXT_MASK; + break; + } + break; + case UNI_IE_BLLI_L3_ID: + /* + * Layer 3 info--contents vary based on type + */ + ie->ie_blli_l3_id = id & UNI_IE_BLLI_LP_MASK; + bc--; + switch (ie->ie_blli_l3_id) { + case UNI_IE_BLLI_L3P_X25: + case UNI_IE_BLLI_L3P_ISO8208: + case UNI_IE_BLLI_L3P_ISO8878: + rc = usf_byte(usf, &c); + if (rc) + return(rc); + bc--; + ie->ie_blli_l3_mode = (c >> + UNI_IE_BLLI_L3MODE_SHIFT) & + UNI_IE_BLLI_L3MODE_MASK; + if (!(c & UNI_IE_EXT_BIT)) + break; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + bc--; + ie->ie_blli_l3_packet_size = + c & UNI_IE_BLLI_L3PS_MASK; + if (!(c & UNI_IE_EXT_BIT)) + break; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + bc--; + ie->ie_blli_l3_window = + c & UNI_IE_EXT_MASK; + break; + case UNI_IE_BLLI_L3P_USER: + rc = usf_byte(usf, &c); + if (rc) + return(rc); + bc--; + ie->ie_blli_l3_mode = + c & UNI_IE_EXT_MASK; + break; + case UNI_IE_BLLI_L3P_ISO9577: + rc = usf_ext(usf, &ipi); + if (rc) + return(rc); + bc -= 2; + ie->ie_blli_l3_ipi = ipi >> + UNI_IE_BLLI_L3IPI_SHIFT; + if (ie->ie_blli_l3_ipi != + UNI_IE_BLLI_L3IPI_SNAP) + break; + + rc = usf_byte(usf, &c); + ie->ie_blli_l3_snap_id = c & UNI_IE_EXT_MASK; + if (rc) + return(rc); + bc --; + + rc = usf_byte(usf, + &ie->ie_blli_l3_oui[0]); + if (rc) + return(rc); + rc = usf_byte(usf, + &ie->ie_blli_l3_oui[1]); + if (rc) + return(rc); + rc = usf_byte(usf, + &ie->ie_blli_l3_oui[2]); + if (rc) + return(rc); + rc = usf_byte(usf, + &ie->ie_blli_l3_pid[0]); + if (rc) + return(rc); + rc = usf_byte(usf, + &ie->ie_blli_l3_pid[1]); + if (rc) + return(rc); + bc -= 5; + break; + } + break; + default: + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + for (i=0; i<ie->ie_length; i++) { + rc = usf_byte(usf, &c); + if (rc) + return(rc); + } + } + } + + return(0); +} + + +/* + * Decode a call state information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_clst(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int rc; + u_char c; + + /* + * Clear the IE + */ + KM_COPY(&ie_clst_absent, &ie->ie_u.ie_clst, + sizeof(ie_clst_absent)); + + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_clst_state = c & UNI_IE_CLST_STATE_MASK; + + return(0); +} + + +/* + * Decode a called party number information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_cdad(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int len, rc; + u_char c; + + /* + * Clear the IE + */ + KM_COPY(&ie_cdad_absent, &ie->ie_u.ie_cdad, + sizeof(ie_cdad_absent)); + + /* + * Get and check the numbering plan + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_cdad_plan = c & UNI_IE_CDAD_PLAN_MASK; + len = ie->ie_length - 1; + switch (ie->ie_cdad_plan) { + case UNI_IE_CDAD_PLAN_E164: + ie->ie_cdad_addr.address_format = T_ATM_E164_ADDR; + break; + case UNI_IE_CDAD_PLAN_NSAP: + ie->ie_cdad_addr.address_format = T_ATM_ENDSYS_ADDR; + break; + default: + /* + * Invalid numbering plan + */ + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + while (len) { + rc = usf_byte(usf, &c); + if (rc) + return(rc); + len--; + } + + return(0); + } + + /* + * Get the ATM address + */ + rc = usf_dec_atm_addr(usf, &ie->ie_cdad_addr, len); + if (rc == EINVAL) { + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + rc = 0; + } + + return(rc); +} + + +/* + * Decode a called party subaddress information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_cdsa(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int len, rc; + u_char c; + + /* + * Clear the IE + */ + KM_COPY(&ie_cdsa_absent, &ie->ie_u.ie_cdsa, + sizeof(ie_cdsa_absent)); + + /* + * Get and check the subaddress type + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + len = ie->ie_length - 1; + if (((c >> UNI_IE_CDSA_TYPE_SHIFT) & UNI_IE_CDSA_TYPE_MASK) != + UNI_IE_CDSA_TYPE_AESA) { + /* + * Invalid subaddress type + */ + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + while (len) { + rc = usf_byte(usf, &c); + if (rc) + return(rc); + len--; + } + + return(0); + } + + /* + * Get the ATM address + */ + ie->ie_cdsa_addr.address_format = T_ATM_ENDSYS_ADDR; + rc = usf_dec_atm_addr(usf, &ie->ie_cdsa_addr, len); + if (rc == EINVAL) { + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + rc = 0; + } + + return(rc); +} + + +/* + * Decode a calling party number information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_cgad(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int len, rc; + u_char c; + + /* + * Clear the IE + */ + KM_COPY(&ie_cgad_absent, &ie->ie_u.ie_cgad, + sizeof(ie_cgad_absent)); + + /* + * Get and check the numbering plan + */ + len = ie->ie_length; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_cgad_type = (c >> UNI_IE_CGAD_TYPE_SHIFT) & + UNI_IE_CGAD_TYPE_MASK; + ie->ie_cgad_plan = c & UNI_IE_CGAD_PLAN_MASK; + len--; + switch (ie->ie_cgad_plan) { + case UNI_IE_CGAD_PLAN_E164: + ie->ie_cgad_addr.address_format = T_ATM_E164_ADDR; + break; + case UNI_IE_CGAD_PLAN_NSAP: + ie->ie_cgad_addr.address_format = T_ATM_ENDSYS_ADDR; + break; + default: + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + while (len) { + rc = usf_byte(usf, &c); + if (rc) + return(rc); + len--; + } + + return(0); + } + + /* + * Get the presentation and screening indicators, if present + */ + if (!(c & UNI_IE_EXT_BIT)) { + rc = usf_byte(usf, &c); + if (rc) + return(rc); + len--; + ie->ie_cgad_pres_ind = (c >> UNI_IE_CGAD_PRES_SHIFT) & + UNI_IE_CGAD_PRES_MASK; + ie->ie_cgad_screen_ind = c & UNI_IE_CGAD_SCR_MASK; + } else { + ie->ie_cgad_pres_ind = 0; + ie->ie_cgad_screen_ind =0; + } + + /* + * Get the ATM address + */ + rc = usf_dec_atm_addr(usf, &ie->ie_cgad_addr, len); + if (rc == EINVAL) { + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + rc = 0; + } + + return(rc); +} + + +/* + * Decode a calling party subaddress information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_cgsa(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int len, rc; + u_char c; + + /* + * Clear the IE + */ + KM_COPY(&ie_cgsa_absent, &ie->ie_u.ie_cgsa, + sizeof(ie_cgsa_absent)); + + /* + * Get and check the subaddress type + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + len = ie->ie_length - 1; + if (((c >> UNI_IE_CGSA_TYPE_SHIFT) & UNI_IE_CGSA_TYPE_MASK) != + UNI_IE_CGSA_TYPE_AESA) { + /* + * Invalid subaddress type + */ + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + while (len) { + rc = usf_byte(usf, &c); + if (rc) + return(rc); + len--; + } + + return(0); + } + + /* + * Get the ATM address + */ + ie->ie_cgsa_addr.address_format = T_ATM_ENDSYS_ADDR; + rc = usf_dec_atm_addr(usf, &ie->ie_cgsa_addr, len); + if (rc == EINVAL) { + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + rc = 0; + } + + return(rc); +} + + +/* + * Decode a cause information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_caus(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int i, len, rc; + u_char c; + + /* + * Clear the IE + */ + KM_COPY(&ie_caus_absent, &ie->ie_u.ie_caus, + sizeof(ie_caus_absent)); + + /* + * Get the cause location + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_caus_loc = c & UNI_IE_CAUS_LOC_MASK; + + /* + * Get the cause value + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_caus_cause = c & UNI_IE_EXT_MASK; + + /* + * Get any included diagnostics + */ + len = ie->ie_length - 2; + for (i = 0, ie->ie_caus_diag_len = 0; + len && i < sizeof(ie->ie_caus_diagnostic); + len--, i++, ie->ie_caus_diag_len++) { + rc = usf_byte(usf, &ie->ie_caus_diagnostic[i]); + if (rc) + return(rc); + } + + return(0); +} + + +/* + * Decode a conection identifier information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_cnid(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int i, rc; + + /* + * Clear the IE + */ + KM_COPY(&ie_cnid_absent, &ie->ie_u.ie_cnid, + sizeof(ie_cnid_absent)); + + rc = usf_ext(usf, &i); + if (rc) + return(rc); + ie->ie_cnid_vp_sig = (i >> UNI_IE_CNID_VPSIG_SHIFT) & + UNI_IE_CNID_VPSIG_MASK; + ie->ie_cnid_pref_excl = i & UNI_IE_CNID_PREX_MASK; + + rc = usf_short(usf, &ie->ie_cnid_vpci); + if (rc) + return(rc); + rc = usf_short(usf, &ie->ie_cnid_vci); + return(rc); +} + + +/* + * Decode a quality of service parameters information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_qosp(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int rc; + + /* + * Clear the IE + */ + KM_COPY(&ie_qosp_absent, &ie->ie_u.ie_qosp, + sizeof(ie_qosp_absent)); + + /* + * Get forward QoS class + */ + rc = usf_byte(usf, &ie->ie_qosp_fwd_class); + if (rc) + return(rc); + + /* + * Get backward QoS class + */ + rc = usf_byte(usf, &ie->ie_qosp_bkwd_class); + + return(rc); +} + + +/* + * Decode a broadband repeat indicator information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_brpi(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int rc; + u_char c; + + /* + * Clear the IE + */ + KM_COPY(&ie_brpi_absent, &ie->ie_u.ie_brpi, + sizeof(ie_brpi_absent)); + + /* + * Get the repeat indicator + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + + ie->ie_brpi_ind = c & UNI_IE_BRPI_IND_MASK; + + return(0); +} + + +/* + * Decode a restart indicator information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_rsti(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int rc; + u_char c; + + /* + * Clear the IE + */ + KM_COPY(&ie_rsti_absent, &ie->ie_u.ie_rsti, + sizeof(ie_rsti_absent)); + + /* + * Get the restart class + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + + ie->ie_rsti_class = c & UNI_IE_RSTI_CLASS_MASK; + + return(0); +} + + +/* + * Decode a broadband sending complete information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a broadband sending complete IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_bsdc(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int rc; + u_char c; + + /* + * Clear the IE + */ + KM_COPY(&ie_bsdc_absent, &ie->ie_u.ie_bsdc, + sizeof(ie_bsdc_absent)); + + /* + * Get the sending complete indicator + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + + /* + * Validate the indicator + */ + c &= UNI_IE_EXT_MASK; + if (c != UNI_IE_BSDC_IND) + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + ie->ie_bsdc_ind = c; + + return(0); +} + + +/* + * Decode a transit network selection information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a transit network selection IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_trnt(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int i, len, rc; + u_char c; + + /* + * Clear the IE + */ + KM_COPY(&ie_trnt_absent, &ie->ie_u.ie_trnt, + sizeof(ie_trnt_absent)); + + /* + * Get the network ID type and plan + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_trnt_id_type = (c >> UNI_IE_TRNT_IDT_SHIFT) & + UNI_IE_TRNT_IDT_MASK; + ie->ie_trnt_id_plan = c & UNI_IE_TRNT_IDP_MASK; + + /* + * Get the length of the network ID + */ + len = ie->ie_length - 1; + ie->ie_trnt_id_len = MIN(len, sizeof(ie->ie_trnt_id)); + + /* + * Get the network ID + */ + for (i=0; i<len; i++) { + if (i<sizeof(ie->ie_trnt_id)) + rc = usf_byte(usf, &ie->ie_trnt_id[i]); + else + rc = usf_byte(usf, &c); + if (rc) + return(rc); + } + + return(0); +} + + +/* + * Decode an unimplemented information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_uimp(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int i, rc; + u_char c; + + /* + * Skip over the IE contents + */ + for (i=0; i<ie->ie_length; i++) { + rc = usf_byte(usf, &c); + if (rc) + return(rc); + } + + return(0); +} + + +/* + * Decode an information element using field identifiers + * + * The AAL parameters and ATM user cell rate IEs are formatted + * with a one-byte identifier preceeding each field. The routine + * parses these IEs by using a table which relates the field + * identifiers with the fields in the appropriate IE structure. + * Field order in the received message is immaterial. + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * tbl pointer to an IE decoding table + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_ie_ident(usf, ie, tbl) + struct usfmt *usf; + struct ie_generic *ie; + struct ie_decode_tbl *tbl; +{ + int i, len, rc; + u_char c; + u_int8_t cv; + u_int16_t sv; + u_int32_t iv; + void *dest; + + /* + * Scan through the IE + */ + len = ie->ie_length; + while (len) { + /* + * Get the field identifier + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + len--; + + /* + * Look up the field in the table + */ + for (i=0; (tbl[i].ident != c) && tbl[i].len; i++) { + } + if (tbl[i].ident == 0) { + /* + * Bad subfield identifier -- flag an + * error and skip over the rest of the IE + */ + ie->ie_err_cause = UNI_IE_CAUS_IECONTENT; + while (len) { + rc = usf_byte(usf, &c); + if (rc) + return(rc); + } + return(0); + } + + /* + * Save final destination address + */ + dest = (void *)((int)ie + tbl[i].f_offs); + + /* + * Get the field value + */ + switch (tbl[i].len) { + case 0: + cv = 1; + goto savec; + + case 1: + rc = usf_byte(usf, &cv); + if (rc) + break; +savec: + /* + * Save field value + */ + switch (tbl[i].f_size) { + case 1: + *(u_int8_t *)dest = cv; + break; + case 2: + *(u_int16_t *)dest = cv; + break; + case 4: + *(u_int32_t *)dest = cv; + break; + default: + goto badtbl; + } + break; + + case 2: + rc = usf_short(usf, &sv); + if (rc) + break; + + /* + * Save field value + */ + switch (tbl[i].f_size) { + case 2: + *(u_int16_t *)dest = sv; + break; + case 4: + *(u_int32_t *)dest = sv; + break; + default: + goto badtbl; + } + break; + + case 3: + rc = usf_int3(usf, &iv); + goto savei; + + case 4: + rc = usf_int(usf, &iv); +savei: + /* + * Save field value + */ + if (rc) + break; + switch (tbl[i].f_size) { + case 4: + *(u_int32_t *)dest = iv; + break; + default: + goto badtbl; + } + break; + + default: +badtbl: + log(LOG_ERR, + "uni decode: id=%d,len=%d,off=%d,size=%d\n", + tbl[i].ident, tbl[i].len, + tbl[i].f_offs, tbl[i].f_size); + rc = EFAULT; + break; + } + + if (rc) + return(rc); + + len -= tbl[i].len; + + } + + return(0); +} + + +/* + * Decode an ATM address + * + * Arguments: + * usf pointer to a unisig formatting structure + * addr pointer to an ATM address structure + * len length of data remainig in the IE + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_dec_atm_addr(usf, addr, len) + struct usfmt *usf; + Atm_addr *addr; + int len; +{ + int rc; + u_char c, *cp; + + /* + * Check the address type + */ + addr->address_length = len; + switch (addr->address_format) { + case T_ATM_E164_ADDR: + if (len > sizeof(Atm_addr_e164)) { + goto flush; + } + cp = (u_char *) addr->address; + break; + case T_ATM_ENDSYS_ADDR: + if (len != sizeof(Atm_addr_nsap)) { + goto flush; + } + cp = (u_char *) addr->address; + break; + default: + /* Silence the compiler */ + cp = NULL; + } + + /* + * Get the ATM address + */ + while (len) { + rc = usf_byte(usf, cp); + if (rc) + return(rc); + len--; + cp++; + } + + return(0); + +flush: + while (len) { + rc = usf_byte(usf, &c); + if (rc) + return(rc); + len--; + } + + return(EINVAL); +} diff --git a/sys/netatm/uni/unisig_decode.h b/sys/netatm/uni/unisig_decode.h new file mode 100644 index 0000000..dbd184a --- /dev/null +++ b/sys/netatm/uni/unisig_decode.h @@ -0,0 +1,87 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_decode.h,v 1.5 1998/08/26 23:29:21 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * Message formats + * + */ + +#ifndef _UNI_SIG_DECODE_H +#define _UNI_SIG_DECODE_H + + +/* + * Values specifying which IEs are required in messages + */ +#define IE_NA 0 +#define IE_MAND 1 +#define IE_OPT 2 + +/* + * Structure for information element decoding information + */ +struct ie_ent { + u_char ident; /* IE identifier */ + int min_len; /* Min. length */ + int max_len; /* Max. length */ + int p_idx; /* IE pointer index in msg */ + int (*decode) /* Decoding function */ + __P((struct usfmt *, struct ie_generic *)); +}; + +/* + * Macro to give the offset of a field in a generic IE structure + */ +#define IE_OFFSET(f) \ + ((int)&((struct ie_generic *) 0)->f) + +/* + * Macro to give the size of a field in a generic IE structure + */ +#define IE_FSIZE(f) \ + (sizeof(((struct ie_generic *) 0)->f)) + +#define IE_OFF_SIZE(f) IE_OFFSET(f),IE_FSIZE(f) + + +/* + * Structure to define a field-driven decoding table (for AAL + * parameters and ATM user cell rate IEs) + */ +struct ie_decode_tbl { + u_char ident; + int len; + int f_offs; + int f_size; +}; + +#endif /* _UNI_SIG_DECODE_H */ diff --git a/sys/netatm/uni/unisig_encode.c b/sys/netatm/uni/unisig_encode.c new file mode 100644 index 0000000..0920acc --- /dev/null +++ b/sys/netatm/uni/unisig_encode.c @@ -0,0 +1,1681 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_encode.c,v 1.11 1998/08/26 23:29:21 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * Message formatting module + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: unisig_encode.c,v 1.11 1998/08/26 23:29:21 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/unisig.h> +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/unisig_msg.h> +#include <netatm/uni/unisig_mbuf.h> +#include <netatm/uni/unisig_decode.h> + + +/* + * Local functions + */ +static int usf_enc_ie __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_aalp __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_clrt __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_bbcp __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_bhli __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_blli __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_clst __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_cdad __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_cdsa __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_cgad __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_cgsa __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_caus __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_cnid __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_qosp __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_brpi __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_rsti __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_bsdc __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_trnt __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_uimp __P((struct usfmt *, struct ie_generic *)); +static int usf_enc_ie_ident __P((struct usfmt *, struct ie_generic *, + struct ie_decode_tbl *)); +static int usf_enc_atm_addr __P((struct usfmt *, Atm_addr *)); + + +/* + * Local variables + */ +static struct { + u_char ident; /* IE identifier */ + int (*encode) __P((struct usfmt *, struct ie_generic *)); + /* Encoding function */ +} ie_table[] = { + { UNI_IE_AALP, usf_enc_ie_aalp }, + { UNI_IE_CLRT, usf_enc_ie_clrt }, + { UNI_IE_BBCP, usf_enc_ie_bbcp }, + { UNI_IE_BHLI, usf_enc_ie_bhli }, + { UNI_IE_BLLI, usf_enc_ie_blli }, + { UNI_IE_CLST, usf_enc_ie_clst }, + { UNI_IE_CDAD, usf_enc_ie_cdad }, + { UNI_IE_CDSA, usf_enc_ie_cdsa }, + { UNI_IE_CGAD, usf_enc_ie_cgad }, + { UNI_IE_CGSA, usf_enc_ie_cgsa }, + { UNI_IE_CAUS, usf_enc_ie_caus }, + { UNI_IE_CNID, usf_enc_ie_cnid }, + { UNI_IE_QOSP, usf_enc_ie_qosp }, + { UNI_IE_BRPI, usf_enc_ie_brpi }, + { UNI_IE_RSTI, usf_enc_ie_rsti }, + { UNI_IE_BLSH, usf_enc_ie_uimp }, + { UNI_IE_BNSH, usf_enc_ie_uimp }, + { UNI_IE_BSDC, usf_enc_ie_bsdc }, + { UNI_IE_TRNT, usf_enc_ie_trnt }, + { UNI_IE_EPRF, usf_enc_ie_uimp }, + { UNI_IE_EPST, usf_enc_ie_uimp }, + { 0, 0 } +}; + +extern struct ie_decode_tbl ie_aal1_tbl[]; +extern struct ie_decode_tbl ie_aal4_tbl_30[]; +extern struct ie_decode_tbl ie_aal4_tbl_31[]; +extern struct ie_decode_tbl ie_aal5_tbl_30[]; +extern struct ie_decode_tbl ie_aal5_tbl_31[]; +extern struct ie_decode_tbl ie_clrt_tbl[]; + + +/* + * Encode a UNI signalling message + * + * Arguments: + * usf pointer to a unisig formatting structure + * msg pointer to a signalling message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +int +usf_enc_msg(usf, msg) + struct usfmt *usf; + struct unisig_msg *msg; +{ + int i, len, rc; + u_char c; + u_char *lp0, *lp1; + struct ie_generic *ie; + + union { + short s; + u_char sb[sizeof(short)]; + } su; + + ATM_DEBUG2("usf_enc_msg: usf=0x%x, msg=0x%x\n", + (int)usf, (int)msg); + + /* + * Encode the protocol discriminator + */ + c = UNI_MSG_DISC_Q93B; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + + /* + * Encode the call reference length + */ + c = 3; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + + /* + * Encode the call reference + */ + rc = usf_int3(usf, &msg->msg_call_ref); + if (rc) + return(rc); + + /* + * Encode the message type + */ + rc = usf_byte(usf, &msg->msg_type); + if (rc) + return(rc); + + /* + * Encode the message type extension + */ + c = ((msg->msg_type_flag & UNI_MSG_TYPE_FLAG_MASK) << + UNI_MSG_TYPE_FLAG_SHIFT) + + (msg->msg_type_action & UNI_MSG_TYPE_ACT_MASK) + + UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + + /* + * Save the location of the message length and encode a length + * of zero for now. We'll fix the length up at the end. + */ + su.s = 0; + rc = usf_byte_mark(usf, &su.sb[sizeof(short)-2], &lp0); + if (rc) + return(rc); + rc = usf_byte_mark(usf, &su.sb[sizeof(short)-1], &lp1); + if (rc) + return(rc); + + /* + * Process information elements + */ + len = 0; + for (i=0; i<UNI_MSG_IE_CNT; i++) { + ie = msg->msg_ie_vec[i]; + while (ie) { + rc = usf_enc_ie(usf, ie); + if (rc) + return(rc); + len += (ie->ie_length + UNI_IE_HDR_LEN); + ie = ie->ie_next; + } + } + + /* + * Fix the message length in the encoded message + */ + su.s = htons((u_short)len); + *lp0 = su.sb[sizeof(short)-2]; + *lp1 = su.sb[sizeof(short)-1]; + + return(0); +} + + +/* + * Encode an information element + * + * Arguments: + * usf pointer to a UNISIG formatting structure + * msg pointer to a UNISIG message structure + * ie pointer to a generic IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int i, rc; + u_char c; + u_char *lp0, *lp1; + + union { + short s; + u_char sb[sizeof(short)]; + } su; + + ATM_DEBUG2("usf_enc_ie: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + + /* + * Encode the IE identifier + */ + rc = usf_byte(usf, &ie->ie_ident); + if (rc) + return(rc); + + /* + * Encode the extended type + */ + c = ((ie->ie_coding & UNI_IE_CODE_MASK) << UNI_IE_CODE_SHIFT) + + ((ie->ie_flag & UNI_IE_FLAG_MASK) << + UNI_IE_FLAG_SHIFT) + + (ie->ie_action & UNI_IE_ACT_MASK) + + UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + + /* + * Mark the current location in the output stream. Encode a + * length of zero for now; we'll come back and fix it up at + * the end. + */ + su.s = 0; + rc = usf_byte_mark(usf, &su.sb[sizeof(short)-2], &lp0); + if (rc) + return(rc); + rc = usf_byte_mark(usf, &su.sb[sizeof(short)-1], &lp1); + if (rc) + return(rc); + + /* + * Look up the information element in the table + */ + for (i=0; (ie->ie_ident != ie_table[i].ident) && + (ie_table[i].encode != NULL); i++) { + } + if (ie_table[i].encode == NULL) { + /* + * Unrecognized IE + */ + return(EINVAL); + } + + /* + * Process the IE by calling the function indicated + * in the IE table + */ + rc = ie_table[i].encode(usf, ie); + if (rc) + return(rc); + + /* + * Set the length in the output stream + */ + su.s = htons((u_short)ie->ie_length); + *lp0 = su.sb[sizeof(short)-2]; + *lp1 = su.sb[sizeof(short)-1]; + + return(0); +} + + +/* + * Encode an AAL parameters information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to an AAL parms IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_aalp(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int i, rc = 0; + + ATM_DEBUG2("usf_enc_ie_aalp: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + + ie->ie_length = 0; + + /* + * Encode the AAL type + */ + if (ie->ie_aalp_aal_type == T_ATM_ABSENT) + return(0); + rc = usf_byte(usf, &ie->ie_aalp_aal_type); + if (rc) + return(rc); + + /* + * Process based on AAL type + */ + switch (ie->ie_aalp_aal_type) { + case UNI_IE_AALP_AT_AAL1: + rc = usf_enc_ie_ident(usf, ie, ie_aal1_tbl); + break; + case UNI_IE_AALP_AT_AAL3: + if (usf->usf_sig->us_proto == ATM_SIG_UNI30) + rc = usf_enc_ie_ident(usf, ie, ie_aal4_tbl_30); + else + rc = usf_enc_ie_ident(usf, ie, ie_aal4_tbl_31); + break; + case UNI_IE_AALP_AT_AAL5: + if (usf->usf_sig->us_proto == ATM_SIG_UNI30) + rc = usf_enc_ie_ident(usf, ie, ie_aal5_tbl_30); + else + rc = usf_enc_ie_ident(usf, ie, ie_aal5_tbl_31); + break; + case UNI_IE_AALP_AT_AALU: + /* + * Encode the user data + */ + i = 0; + while (i < sizeof(ie->ie_aalp_user_info)) { + rc = usf_byte(usf, &ie->ie_aalp_user_info[i]); + if (rc) + break; + i++; + ie->ie_length++; + } + break; + default: + return(EINVAL); + } + + ie->ie_length++; + return(rc); +} + + +/* + * Encode a user cell rate information element + * + * This routine just encodes the parameters required for best + * effort service. + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_clrt(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int rc; + + ATM_DEBUG2("usf_enc_ie_clrt: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + +#ifdef NOTDEF + /* + * Encode Peak Cell Rate Forward CLP = 0 + 1 + */ + c = UNI_IE_CLRT_FWD_PEAK_01_ID; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + rc = usf_int3(usf, &ie->ie_clrt_fwd_peak_01); + if (rc) + return(rc); + + /* + * Encode Peak Cell Rate Backward CLP = 0 + 1 + */ + c = UNI_IE_CLRT_BKWD_PEAK_01_ID; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + rc = usf_int3(usf, &ie->ie_clrt_bkwd_peak_01); + if (rc) + return(rc); + + /* + * Encode Best Effort Flag + */ + c = UNI_IE_CLRT_BEST_EFFORT_ID; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + + /* + * Set IE length + */ + ie->ie_length = 9; +#endif + + /* + * Encode the user cell rate IE using the table + */ + ie->ie_length = 0; + rc = usf_enc_ie_ident(usf, ie, ie_clrt_tbl); + + return(rc); +} + + +/* + * Encode a broadband bearer capability information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_bbcp(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int rc; + u_char c; + + ATM_DEBUG2("usf_enc_ie_bbcp: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + + ie->ie_length = 0; + + /* + * Encode the broadband bearer class + */ + if (ie->ie_bbcp_bearer_class == T_ATM_ABSENT) + return(0); + c = ie->ie_bbcp_bearer_class & UNI_IE_BBCP_BC_MASK; + if (ie->ie_bbcp_bearer_class != UNI_IE_BBCP_BC_BCOB_X) + c |= UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + + /* + * If the broadband bearer class was X, the next + * byte has the traffic type and timing requirements + */ + if (ie->ie_bbcp_bearer_class == UNI_IE_BBCP_BC_BCOB_X) { + c = ((ie->ie_bbcp_traffic_type & UNI_IE_BBCP_TT_MASK) << + UNI_IE_BBCP_TT_SHIFT) + + (ie->ie_bbcp_timing_req & + UNI_IE_BBCP_TR_MASK) + + UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + } + + /* + * Encode the clipping and user plane connection configuration + */ + c = ((ie->ie_bbcp_clipping & UNI_IE_BBCP_SC_MASK) << + UNI_IE_BBCP_SC_SHIFT) + + (ie->ie_bbcp_conn_config & + UNI_IE_BBCP_CC_MASK) + + UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + + return(0); +} + + +/* + * Encode a broadband high layer information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_bhli(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int i, rc; + u_int type; + + ATM_DEBUG2("usf_enc_ie_bhli: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + + ie->ie_length = 0; + + /* + * Encode the high layer information type + */ + if (ie->ie_bhli_type == T_ATM_ABSENT) + return(0); + type = ie->ie_bhli_type | UNI_IE_EXT_BIT; + rc = usf_ext(usf, &type); + if (rc) + return(rc); + ie->ie_length++; + + /* + * What comes next depends on the type + */ + switch (ie->ie_bhli_type) { + case UNI_IE_BHLI_TYPE_ISO: + case UNI_IE_BHLI_TYPE_USER: + /* + * ISO or user-specified parameters -- take the + * length of information from the IE length + */ + for (i=0; i<ie->ie_length-1; i++) { + rc = usf_byte(usf, &ie->ie_bhli_info[i]); + if (rc) + return(rc); + ie->ie_length++; + } + break; + case UNI_IE_BHLI_TYPE_HLP: + /* + * Make sure the IE is long enough for the high + * layer profile information, then get it + */ + if (usf->usf_sig->us_proto != ATM_SIG_UNI30) + return (EINVAL); + for (i=0; i<UNI_IE_BHLI_HLP_LEN; i++) { + rc = usf_byte(usf, &ie->ie_bhli_info[i]); + if (rc) + return(rc); + ie->ie_length++; + } + break; + case UNI_IE_BHLI_TYPE_VSA: + /* + * Make sure the IE is long enough for the vendor- + * specific application information, then get it + */ + for (i=0; i<UNI_IE_BHLI_VSA_LEN; i++) { + rc = usf_byte(usf, &ie->ie_bhli_info[i]); + if (rc) + return(rc); + ie->ie_length++; + } + break; + default: + return(EINVAL); + } + + return(0); +} + + +/* + * Encode a broadband low layer information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_blli(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + u_char c; + int rc; + u_int ipi; + + ATM_DEBUG2("usf_enc_ie_blli: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + + ie->ie_length = 0; + + /* + * Encode paramteters for whichever protocol layers the + * user specified + */ + + /* + * Layer 1 information + */ + if (ie->ie_blli_l1_id && ie->ie_blli_l1_id != T_ATM_ABSENT) { + c = (UNI_IE_BLLI_L1_ID << UNI_IE_BLLI_LID_SHIFT) + + (ie->ie_blli_l1_id & + UNI_IE_BLLI_LP_MASK) + + UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + } + + /* + * Layer 2 information + */ + if (ie->ie_blli_l2_id && ie->ie_blli_l2_id != T_ATM_ABSENT) { + c = (UNI_IE_BLLI_L2_ID << UNI_IE_BLLI_LID_SHIFT) + + (ie->ie_blli_l2_id & + UNI_IE_BLLI_LP_MASK); + + switch (ie->ie_blli_l2_id) { + case UNI_IE_BLLI_L2P_X25L: + case UNI_IE_BLLI_L2P_X25M: + case UNI_IE_BLLI_L2P_HDLC1: + case UNI_IE_BLLI_L2P_HDLC2: + case UNI_IE_BLLI_L2P_HDLC3: + case UNI_IE_BLLI_L2P_Q922: + case UNI_IE_BLLI_L2P_ISO7776: + /* + * Write the Layer 2 type + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + + /* + * Encode the Layer 2 mode + */ + if (ie->ie_blli_l2_mode) { + c = (ie->ie_blli_l2_mode & + UNI_IE_BLLI_L2MODE_MASK) << + UNI_IE_BLLI_L2MODE_SHIFT; + if (!ie->ie_blli_l2_window) + c |= UNI_IE_EXT_BIT; + + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + } + + /* + * Encode the Layer 2 window size + */ + if (ie->ie_blli_l2_window) { + c = (ie->ie_blli_l2_window & + UNI_IE_EXT_MASK) + + UNI_IE_EXT_BIT; + + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + } + break; + case UNI_IE_BLLI_L2P_USER: + /* + * Write the Layer 2 type + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + + /* + * Encode the user-specified layer 2 info + */ + c = (ie->ie_blli_l2_user_proto & + UNI_IE_EXT_MASK) + + UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + break; + default: + /* + * Write the Layer 2 type + */ + c |= UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + break; + } + } + + /* + * Layer 3 information + */ + if (ie->ie_blli_l3_id && ie->ie_blli_l3_id != T_ATM_ABSENT) { + /* + * Encode the layer 3 protocol ID + */ + c = (UNI_IE_BLLI_L3_ID << UNI_IE_BLLI_LID_SHIFT) + + (ie->ie_blli_l3_id & + UNI_IE_BLLI_LP_MASK); + + /* + * Process other fields based on protocol ID + */ + switch(ie->ie_blli_l3_id) { + case UNI_IE_BLLI_L3P_X25: + case UNI_IE_BLLI_L3P_ISO8208: + case UNI_IE_BLLI_L3P_ISO8878: + /* + * Write the protocol ID + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + + if (ie->ie_blli_l3_mode || + ie->ie_blli_l3_packet_size || + ie->ie_blli_l3_window) { + c = (ie->ie_blli_l3_mode & + UNI_IE_BLLI_L3MODE_MASK) << + UNI_IE_BLLI_L3MODE_SHIFT; + if (!ie->ie_blli_l3_packet_size && + !ie->ie_blli_l3_window) + c |= UNI_IE_EXT_BIT; + + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + } + + if (ie->ie_blli_l3_packet_size || + ie->ie_blli_l3_window) { + c = ie->ie_blli_l3_packet_size & + UNI_IE_BLLI_L3PS_MASK; + if (!ie->ie_blli_l3_window) + c |= UNI_IE_EXT_BIT; + + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + } + + if (ie->ie_blli_l3_window) { + c = (ie->ie_blli_l3_window & + UNI_IE_EXT_MASK) + + UNI_IE_EXT_BIT; + + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + } + break; + case UNI_IE_BLLI_L3P_USER: + /* + * Write the protocol ID + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + + /* + * Encode the user-specified protocol info + */ + c = (ie->ie_blli_l3_user_proto & + UNI_IE_EXT_MASK) + + UNI_IE_EXT_BIT; + + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + break; + case UNI_IE_BLLI_L3P_ISO9577: + /* + * Write the protocol ID + */ + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + + /* + * Encode the IPI + */ + ipi = ie->ie_blli_l3_ipi << + UNI_IE_BLLI_L3IPI_SHIFT; + rc = usf_ext(usf, &ipi); + if (rc) + return(rc); + ie->ie_length += 2; + + if (ie->ie_blli_l3_ipi == + UNI_IE_BLLI_L3IPI_SNAP) { + c = UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + + rc = usf_byte(usf, + &ie->ie_blli_l3_oui[0]); + if (rc) + return(rc); + + rc = usf_byte(usf, + &ie->ie_blli_l3_oui[1]); + if (rc) + return(rc); + + rc = usf_byte(usf, + &ie->ie_blli_l3_oui[2]); + if (rc) + return(rc); + + rc = usf_byte(usf, + &ie->ie_blli_l3_pid[0]); + if (rc) + return(rc); + + rc = usf_byte(usf, + &ie->ie_blli_l3_pid[1]); + if (rc) + return(rc); + + ie->ie_length += 6; + } + break; + default: + /* + * Write the layer 3 protocol ID + */ + c |= UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + break; + } + } + + return(0); +} + + +/* + * Encode a call state information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_clst(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int rc; + u_char c; + + ATM_DEBUG2("usf_enc_ie_clst: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + + c = ie->ie_clst_state & UNI_IE_CLST_STATE_MASK; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length = 1; + + return(0); +} + + +/* + * Encode a called party number information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_cdad(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + u_char c; + int rc; + + ATM_DEBUG2("usf_enc_ie_cdad: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + + /* + * Encode the numbering plan + */ + switch(ie->ie_cdad_addr.address_format) { + case T_ATM_E164_ADDR: + c = UNI_IE_CDAD_PLAN_E164 + + (UNI_IE_CDAD_TYPE_INTL + << UNI_IE_CDAD_TYPE_SHIFT); + ie->ie_length = sizeof(Atm_addr_e164) + 1; + break; + case T_ATM_ENDSYS_ADDR: + c = UNI_IE_CDAD_PLAN_NSAP + + (UNI_IE_CDAD_TYPE_UNK + << UNI_IE_CDAD_TYPE_SHIFT); + ie->ie_length = sizeof(Atm_addr_nsap) + 1; + break; + default: + return(EINVAL); + } + c |= UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + + /* + * Encode the ATM address + */ + rc = usf_enc_atm_addr(usf, &ie->ie_cdad_addr); + + return(rc); +} + + +/* + * Encode a called party subaddress information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_cdsa(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + u_char c; + int rc; + + /* + * Encode the subaddress type + */ + switch(ie->ie_cdsa_addr.address_format) { + case T_ATM_ENDSYS_ADDR: + c = UNI_IE_CDSA_TYPE_AESA << UNI_IE_CDSA_TYPE_SHIFT; + ie->ie_length = sizeof(Atm_addr_nsap) + 1; + break; + default: + return(EINVAL); + } + c |= UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + + /* + * Encode the ATM address + */ + rc = usf_enc_atm_addr(usf, &ie->ie_cdsa_addr); + + return(rc); +} + + +/* + * Encode a calling party number information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_cgad(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + u_char c; + int rc; + + ATM_DEBUG2("usf_enc_ie_cgad: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + + /* + * Encode the numbering plan + */ + switch(ie->ie_cgad_addr.address_format) { + case T_ATM_E164_ADDR: + c = UNI_IE_CGAD_PLAN_E164 + + (UNI_IE_CGAD_TYPE_INTL + << UNI_IE_CGAD_TYPE_SHIFT) + + UNI_IE_EXT_BIT; + ie->ie_length = sizeof(Atm_addr_e164) + 1; + break; + case T_ATM_ENDSYS_ADDR: + c = UNI_IE_CGAD_PLAN_NSAP + + (UNI_IE_CGAD_TYPE_UNK + << UNI_IE_CGAD_TYPE_SHIFT) + + UNI_IE_EXT_BIT; + ie->ie_length = sizeof(Atm_addr_nsap) + 1; + break; + default: + return(EINVAL); + } + rc = usf_byte(usf, &c); + if (rc) + return(rc); + + /* + * Encode the presentation and screening indicators + */ +#ifdef NOTDEF + c = ((ie->ie_cgad_pres_ind & UNI_IE_CGAD_PRES_MASK) + << UNI_IE_CGAD_PRES_SHIFT) + + (ie->ie_cgad_screen_ind & + UNI_IE_CGAD_SCR_MASK) + + UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); +#endif + + + /* + * Encode the ATM address + */ + rc = usf_enc_atm_addr(usf, &ie->ie_cgad_addr); + + return(rc); +} + + +/* + * Encode a calling party subaddress information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_cgsa(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + u_char c; + int rc; + + /* + * Encode the subaddress type + */ + switch(ie->ie_cgsa_addr.address_format) { + case T_ATM_ENDSYS_ADDR: + c = UNI_IE_CGSA_TYPE_AESA << UNI_IE_CGSA_TYPE_SHIFT; + ie->ie_length = sizeof(Atm_addr_nsap) + 1; + break; + default: + return(EINVAL); + } + c |= UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + + /* + * Encode the ATM address + */ + rc = usf_enc_atm_addr(usf, &ie->ie_cgsa_addr); + + return(rc); +} + + +/* + * Encode a cause information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_caus(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int i, rc; + u_char c; + + ATM_DEBUG2("usf_enc_ie_caus: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + + ie->ie_length = 0; + + /* + * Encode the cause location + */ + c = (ie->ie_caus_loc & UNI_IE_CAUS_LOC_MASK) | UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + + /* + * Encode the cause value + */ + c = ie->ie_caus_cause | UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length++; + + /* + * Encode any included diagnostics + */ + for (i = 0; i < ie->ie_caus_diag_len && + i < sizeof(ie->ie_caus_diagnostic); + i++) { + rc = usf_byte(usf, &ie->ie_caus_diagnostic[i]); + if (rc) + return(rc); + ie->ie_length++; + } + + return(0); +} + + +/* + * Encode a conection identifier information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_cnid(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int rc; + u_char c; + + ATM_DEBUG2("usf_enc_ie_cnid: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + + c = ((ie->ie_cnid_vp_sig & UNI_IE_CNID_VPSIG_MASK) + << UNI_IE_CNID_VPSIG_SHIFT) + + (ie->ie_cnid_pref_excl & UNI_IE_CNID_PREX_MASK) + + UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + + rc = usf_short(usf, &ie->ie_cnid_vpci); + if (rc) + return(rc); + rc = usf_short(usf, &ie->ie_cnid_vci); + if (rc) + return(rc); + + ie->ie_length = 5; + return(0); +} + + +/* + * Encode a quality of service parameters information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_qosp(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int rc; + + ATM_DEBUG2("usf_enc_ie_qosp: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + + /* + * Encode forward QoS class + */ + if (ie->ie_qosp_fwd_class == T_ATM_ABSENT || + ie->ie_qosp_bkwd_class == T_ATM_ABSENT) + return(0); + rc = usf_byte(usf, &ie->ie_qosp_fwd_class); + if (rc) + return(rc); + + /* + * Encode backward QoS class + */ + rc = usf_byte(usf, &ie->ie_qosp_bkwd_class); + + ie->ie_length = 2; + return(rc); +} + + +/* + * Encode a broadband repeat indicator information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_brpi(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int rc; + u_char c; + + ATM_DEBUG2("usf_enc_ie_brpi: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + + /* + * Encode the repeat indicator + */ + c = ie->ie_brpi_ind + UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + + return(rc); +} + + +/* + * Encode a restart indicator information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_rsti(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int rc; + u_char c; + + ATM_DEBUG2("usf_enc_ie_rsti: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + + /* + * Encode the restart class + */ + c = (ie->ie_rsti_class & UNI_IE_RSTI_CLASS_MASK) | + UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + ie->ie_length = 1; + + return(rc); +} + + +/* + * Encode a broadband sending complete information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a broadband sending complete IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_bsdc(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int rc; + u_char c; + + ATM_DEBUG2("usf_enc_ie_bsdc: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + + /* + * Encode the sending complete indicator + */ + c = UNI_IE_BSDC_IND | UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + ie->ie_length = 1; + + return(rc); +} + + +/* + * Encode a transit network selection information element + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a transit network selection rate IE structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_trnt(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + int i, rc; + u_char c; + + ATM_DEBUG2("usf_enc_ie_trnt: usf=0x%x, ie=0x%x\n", + (int)usf, (int)ie); + + /* + * Encode the sending complete indicator + */ + c = ((ie->ie_trnt_id_type & UNI_IE_TRNT_IDT_MASK) << + UNI_IE_TRNT_IDT_SHIFT) + + (ie->ie_trnt_id_plan & UNI_IE_TRNT_IDP_MASK) + + UNI_IE_EXT_BIT; + rc = usf_byte(usf, &c); + if (rc) + return(rc); + ie->ie_length = 1; + + /* + * Encode the network identification + */ + for (i=0; i<ie->ie_trnt_id_len; i++) { + rc = usf_byte(usf, &ie->ie_trnt_id[i]); + if (rc) + return(rc); + ie->ie_length++; + } + + return(rc); +} + + +/* + * Encode an unsupported IE type + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to an IE structure + * + * Returns: + * 0 success + * + */ +static int +usf_enc_ie_uimp(usf, ie) + struct usfmt *usf; + struct ie_generic *ie; +{ + return(0); +} + + +/* + * Encode an information element using field identifiers + * + * The AAL parameters and ATM user cell rate IEs are formatted + * with a one-byte identifier preceeding each field. The routine + * encodes these IEs by using a table which relates the field + * identifiers with the fields in the appropriate IE structure. + * + * Arguments: + * usf pointer to a unisig formatting structure + * ie pointer to a cell rate IE structure + * tbl pointer to an IE decoding table + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_ie_ident(usf, ie, tbl) + struct usfmt *usf; + struct ie_generic *ie; + struct ie_decode_tbl *tbl; +{ + int i, len, rc; + char *cp; + u_int8_t cv; + u_int16_t sv; + u_int32_t iv; + + ATM_DEBUG3("usf_enc_ie_ident: usf=0x%x, ie=0x%x, tbl=0x%x\n", + (int)usf, (int)ie, (int)tbl); + + /* + * Scan through the IE table + */ + len = 0; + for (i=0; tbl[i].ident; i++) { + /* + * Check whether to send the field + */ + cp = (char *) ((int)ie + tbl[i].f_offs); + if (tbl[i].len == 0) { + if ((*cp == T_NO || *cp == T_ATM_ABSENT)) + continue; + } else { + switch (tbl[i].f_size) { + case 1: + if (*(int8_t *)cp == T_ATM_ABSENT) + continue; + break; + case 2: + if (*(int16_t *)cp == T_ATM_ABSENT) + continue; + break; + case 4: + if (*(int32_t *)cp == T_ATM_ABSENT) + continue; + break; + default: +badtbl: + log(LOG_ERR, + "uni encode: id=%d,len=%d,off=%d,size=%d\n", + tbl[i].ident, tbl[i].len, + tbl[i].f_offs, tbl[i].f_size); + return (EFAULT); + } + } + + /* + * Encode the field identifier + */ + rc = usf_byte(usf, &tbl[i].ident); + if (rc) + return(rc); + len++; + + /* + * Encode the field value + */ + switch (tbl[i].len) { + case 0: + break; + case 1: + switch (tbl[i].f_size) { + case 1: + cv = *(u_int8_t *)cp; + break; + case 2: + cv = *(u_int16_t *)cp; + break; + case 4: + cv = *(u_int32_t *)cp; + break; + default: + goto badtbl; + } + rc = usf_byte(usf, &cv); + break; + + case 2: + switch (tbl[i].f_size) { + case 2: + sv = *(u_int16_t *)cp; + break; + case 4: + sv = *(u_int32_t *)cp; + break; + default: + goto badtbl; + } + rc = usf_short(usf, &sv); + break; + + case 3: + switch (tbl[i].f_size) { + case 4: + iv = *(u_int32_t *)cp; + break; + default: + goto badtbl; + } + rc = usf_int3(usf, &iv); + break; + + case 4: + switch (tbl[i].f_size) { + case 4: + iv = *(u_int32_t *)cp; + break; + default: + goto badtbl; + } + rc = usf_int(usf, &iv); + break; + + default: + goto badtbl; + } + + len += tbl[i].len; + + if (rc) + return(rc); + } + + ie->ie_length = len; + return(0); +} + + +/* + * Encode an ATM address + * + * Arguments: + * usf pointer to a unisig formatting structure + * addr pointer to an ATM address structure. The address + * type must already be set correctly. + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +usf_enc_atm_addr(usf, addr) + struct usfmt *usf; + Atm_addr *addr; +{ + int len, rc; + u_char *cp; + + /* + * Check the address type + */ + switch (addr->address_format) { + case T_ATM_E164_ADDR: + cp = (u_char *) addr->address; + len = sizeof(Atm_addr_e164); + break; + case T_ATM_ENDSYS_ADDR: + cp = (u_char *) addr->address; + len = sizeof(Atm_addr_nsap); + break; + default: + return(EINVAL); + } + + /* + * Get the address bytes + */ + while (len) { + rc = usf_byte(usf, cp); + if (rc) + return(rc); + len--; + cp++; + } + + return(0); +} diff --git a/sys/netatm/uni/unisig_if.c b/sys/netatm/uni/unisig_if.c new file mode 100644 index 0000000..784b6c5 --- /dev/null +++ b/sys/netatm/uni/unisig_if.c @@ -0,0 +1,1012 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_if.c,v 1.12 1998/07/30 22:36:57 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * System interface module + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: unisig_if.c,v 1.12 1998/07/30 22:36:57 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/ipatm/ipatm_var.h> +#include <netatm/ipatm/ipatm_serv.h> +#include <netatm/uni/uniip_var.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/unisig.h> +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/unisig_msg.h> + + +/* + * Global variables + */ +struct sp_info unisig_vcpool = { + "unisig vcc pool", /* si_name */ + sizeof(struct unisig_vccb), /* si_blksiz */ + 10, /* si_blkcnt */ + 50 /* si_maxallow */ +}; + +struct sp_info unisig_msgpool = { + "unisig message pool", /* si_name */ + sizeof(struct unisig_msg), /* si_blksiz */ + 10, /* si_blkcnt */ + 50 /* si_maxallow */ +}; + +struct sp_info unisig_iepool = { + "unisig ie pool", /* si_name */ + sizeof(struct ie_generic), /* si_blksiz */ + 10, /* si_blkcnt */ + 50 /* si_maxallow */ +}; + + +/* + * Local functions + */ +static int unisig_attach __P((struct sigmgr *, struct atm_pif *)); +static int unisig_detach __P((struct atm_pif *)); +static int unisig_setup __P((Atm_connvc *, int *)); +static int unisig_release __P((struct vccb *, int *)); +static int unisig_accept __P((struct vccb *, int *)); +static int unisig_reject __P((struct vccb *, int *)); +static int unisig_abort __P((struct vccb *)); +static int unisig_ioctl __P((int, caddr_t, caddr_t)); + + +/* + * Local variables + */ +static struct sigmgr unisig_mgr30 = { + NULL, + ATM_SIG_UNI30, + NULL, + unisig_attach, + unisig_detach, + unisig_setup, + unisig_accept, + unisig_reject, + unisig_release, + unisig_free, + unisig_ioctl +}; + +static struct sigmgr unisig_mgr31 = { + NULL, + ATM_SIG_UNI31, + NULL, + unisig_attach, + unisig_detach, + unisig_setup, + unisig_accept, + unisig_reject, + unisig_release, + unisig_free, + unisig_ioctl +}; + + +/* + * Initialize UNISIG processing + * + * This will be called during module loading. We'll just register + * the UNISIG protocol descriptor and wait for a UNISIG ATM interface + * to come online. + * + * Arguments: + * none + * + * Returns: + * 0 startup was successful + * errno startup failed - reason indicated + * + */ +int +unisig_start() +{ + int err = 0; + + /* + * Verify software version + */ + if (atm_version != ATM_VERSION) { + log(LOG_ERR, "version mismatch: unisig=%d.%d kernel=%d.%d\n", + ATM_VERS_MAJ(ATM_VERSION), + ATM_VERS_MIN(ATM_VERSION), + ATM_VERS_MAJ(atm_version), + ATM_VERS_MIN(atm_version)); + return (EINVAL); + } + + /* + * Register ourselves with system + */ + err = atm_sigmgr_register(&unisig_mgr30); + if (err) + goto done; + + err = atm_sigmgr_register(&unisig_mgr31); + +done: + return (err); +} + + +/* + * Halt UNISIG processing + * + * This should be called just prior to unloading the module from + * memory. All UNISIG interfaces must be deregistered before the + * protocol can be shutdown. + * + * Arguments: + * none + * + * Returns: + * 0 startup was successful + * errno startup failed - reason indicated + * + */ +int +unisig_stop() +{ + int err = 0; + int s = splnet(); + + + /* + * Any protocol instances still registered? + */ + if ((unisig_mgr30.sm_prinst != NULL) || + (unisig_mgr31.sm_prinst != NULL)) { + + /* Yes, can't stop now */ + err = EBUSY; + goto done; + } + + /* + * De-register from system + */ + (void) atm_sigmgr_deregister(&unisig_mgr30); + (void) atm_sigmgr_deregister(&unisig_mgr31); + + /* + * Free up our storage pools + */ + atm_release_pool(&unisig_vcpool); + atm_release_pool(&unisig_msgpool); + atm_release_pool(&unisig_iepool); + +done: + (void) splx(s); + return (err); +} + + +/* + * Attach a UNISIG-controlled interface + * + * Each ATM physical interface must be attached with the signalling + * manager for the interface's signalling protocol (via the + * atm_sigmgr_attach function). This function will handle the + * attachment for UNISIG-controlled interfaces. A new UNISIG protocol + * instance will be created and then we'll just sit around waiting for + * status or connection requests. + * + * Function must be called at splnet. + * + * Arguments: + * smp pointer to UNISIG signalling manager control block + * pip pointer to ATM physical interface control block + * + * Returns: + * 0 attach successful + * errno attach failed - reason indicated + * + */ +static int +unisig_attach(smp, pip) + struct sigmgr *smp; + struct atm_pif *pip; +{ + int err = 0, s; + struct unisig *usp = NULL; + + ATM_DEBUG2("unisig_attach: smp=%x, pip=%x\n", smp, pip); + + /* + * Allocate UNISIG protocol instance control block + */ + usp = (struct unisig *) + KM_ALLOC(sizeof(struct unisig), M_DEVBUF, M_NOWAIT); + if (usp == NULL) { + err = ENOMEM; + goto done; + } + KM_ZERO(usp, sizeof(struct unisig)); + + /* + * Set state in UNISIG protocol instance control block + */ + usp->us_state = UNISIG_NULL; + usp->us_proto = smp->sm_proto; + + /* + * Set initial call reference allocation value + */ + usp->us_cref = 1; + + /* + * Link instance into manager's chain + */ + LINK2TAIL((struct siginst *)usp, struct siginst, smp->sm_prinst, + si_next); + + /* + * Link in interface + */ + usp->us_pif = pip; + s = splimp(); + pip->pif_sigmgr = smp; + pip->pif_siginst = (struct siginst *) usp; + (void) splx(s); + + /* + * Clear our ATM address. The address will be set by user + * command or by registration via ILMI. + */ + usp->us_addr.address_format = T_ATM_ABSENT; + usp->us_addr.address_length = 0; + usp->us_subaddr.address_format = T_ATM_ABSENT; + usp->us_subaddr.address_length = 0; + + /* + * Set pointer to IP + */ + usp->us_ipserv = &uniip_ipserv; + + /* + * Kick-start the UNISIG protocol + */ + UNISIG_TIMER(usp, 0); + + /* + * Log the fact that we've attached + */ + log(LOG_INFO, "unisig: attached to interface %s%d\n", + pip->pif_name, pip->pif_unit); + +done: + /* + * Reset our work if attach fails + */ + if (err) { + if (usp) { + UNISIG_CANCEL(usp); + UNLINK((struct siginst *)usp, struct siginst, + smp->sm_prinst, si_next); + KM_FREE(usp, sizeof(struct unisig), M_DEVBUF); + } + s = splimp(); + pip->pif_sigmgr = NULL; + pip->pif_siginst = NULL; + (void) splx(s); + } + + return (err); +} + + +/* + * Detach a UNISIG-controlled interface + * + * Each ATM physical interface may be detached from its signalling + * manager (via the atm_sigmgr_detach function). This function will + * handle the detachment for all UNISIG-controlled interfaces. All + * circuits will be immediately terminated. + * + * Function must be called at splnet. + * + * Arguments: + * pip pointer to ATM physical interface control block + * + * Returns: + * 0 detach successful + * errno detach failed - reason indicated + * + */ +static int +unisig_detach(pip) + struct atm_pif *pip; +{ + struct unisig *usp; + int err; + + ATM_DEBUG1("unisig_detach: pip=0x%x\n", pip); + + /* + * Get UNISIG protocol instance + */ + usp = (struct unisig *)pip->pif_siginst; + + /* + * Return an error if we're already detaching + */ + if (usp->us_state == UNISIG_DETACH) { + return(EALREADY); + } + + /* + * Pass the detach event to the signalling manager + * state machine + */ + err = unisig_sigmgr_state(usp, UNISIG_SIGMGR_DETACH, + (KBuffer *)0); + + /* + * Log the fact that we've detached + */ + if (!err) + log(LOG_INFO, "unisig: detached from interface %s%d\n", + pip->pif_name, pip->pif_unit); + + return (0); +} + + +/* + * Open a UNISIG ATM Connection + * + * All service user requests to open a VC connection (via + * atm_open_connection) over an ATM interface attached to the UNISIG + * signalling manager are handled here. + * + * Function will be called at splnet. + * + * Arguments: + * cvp pointer to user's requested connection parameters + * errp pointer to an int for extended error information + * + * Returns: + * CALL_PROCEEDING connection establishment is in progress + * CALL_FAILED connection establishment failed + * CALL_CONNECTED connection has been successfully established + * + */ +static int +unisig_setup(cvp, errp) + Atm_connvc *cvp; + int *errp; +{ + struct atm_pif *pip = cvp->cvc_attr.nif->nif_pif; + struct unisig *usp = (struct unisig *)pip->pif_siginst; + int rc = 0; + + ATM_DEBUG1("unisig_setup: cvp=0x%x\n", cvp); + + /* + * Intialize the returned error code + */ + *errp = 0; + + /* + * Open the connection + */ + switch (cvp->cvc_attr.called.addr.address_format) { + case T_ATM_PVC_ADDR: + /* + * Create a PVC + */ + *errp = unisig_open_vcc(usp, cvp); + rc = (*errp ? CALL_FAILED : CALL_CONNECTED); + break; + + case T_ATM_ENDSYS_ADDR: + case T_ATM_E164_ADDR: + + /* + * Create an SVC + */ + *errp = unisig_open_vcc(usp, cvp); + rc = (*errp ? CALL_FAILED : CALL_PROCEEDING); + break; + + default: + *errp = EPROTONOSUPPORT; + rc = CALL_FAILED; + } + + return (rc); +} + + +/* + * Close a UNISIG ATM Connection + * + * All service user requests to terminate a previously open VC + * connection (via the atm_close_connection function), which is running + * over an interface attached to the UNISIG signalling manager, are + * handled here. + * + * Function will be called at splnet. + * + * Arguments: + * vcp pointer to connection's VC control block + * errp pointer to an int for extended error information + * + * Returns: + * CALL_PROCEEDING connection termination is in progress + * CALL_FAILED connection termination failed + * CALL_CLEARED connection has been successfully terminated + * + */ +static int +unisig_release(vcp, errp) + struct vccb *vcp; + int *errp; +{ + int rc = 0; + struct atm_pif *pip = vcp->vc_pif; + struct unisig *usp = (struct unisig *)pip->pif_siginst; + + ATM_DEBUG1("unisig_release: vcp=0x%x\n", vcp); + + /* + * Initialize returned error code + */ + *errp = 0; + + /* + * Validate the connection type (PVC or SVC) + */ + if (!(vcp->vc_type & (VCC_PVC | VCC_SVC))) { + *errp = EPROTONOSUPPORT; + return(CALL_FAILED); + } + + /* + * Close the VCCB + */ + *errp = unisig_close_vcc(usp, (struct unisig_vccb *)vcp); + + /* + * Set the return code + */ + if (*errp) { + rc = CALL_FAILED; + } else if (vcp->vc_sstate == UNI_NULL || + vcp->vc_sstate == UNI_FREE) { + rc = CALL_CLEARED; + } else { + rc = CALL_PROCEEDING; + } + + return (rc); +} + + +/* + * Accept a UNISIG Open from a remote host + * + * A user calls this routine (via the atm_accept_call function) + * after it is notified that an open request was received for it. + * + * Function will be called at splnet. + * + * Arguments: + * vcp pointer to user's VCCB + * errp pointer to an int for extended error information + * + * Returns: + * CALL_PROCEEDING connection establishment is in progress + * CALL_FAILED connection establishment failed + * CALL_CONNECTED connection has been successfully established + * + */ +static int +unisig_accept(vcp, errp) + struct vccb *vcp; + int *errp; +{ + struct unisig_vccb *uvp = (struct unisig_vccb *)vcp; + struct atm_pif *pip = uvp->uv_pif; + struct unisig *usp = (struct unisig *)pip->pif_siginst; + + ATM_DEBUG1("unisig_accept: vcp=0x%x\n", vcp); + + /* + * Initialize the returned error code + */ + *errp = 0; + + /* + * Return an error if we're detaching + */ + if (usp->us_state == UNISIG_DETACH) { + *errp = ENETDOWN; + goto free; + } + + /* + * Return an error if we lost the connection + */ + if (uvp->uv_sstate == UNI_FREE) { + *errp = ENETDOWN; + goto free; + } + + /* + * Pass the acceptance to the VC state machine + */ + *errp = unisig_vc_state(usp, uvp, UNI_VC_ACCEPT_CALL, + (struct unisig_msg *) 0); + if (*errp) + goto failed; + + return(CALL_PROCEEDING); + +failed: + /* + * On error, free the VCCB and return CALL_FAILED + */ + +free: + uvp->uv_sstate = UNI_FREE; + uvp->uv_ustate = VCCU_CLOSED; + DEQUEUE(uvp, struct unisig_vccb, uv_sigelem, usp->us_vccq); + unisig_free((struct vccb *)uvp); + + return(CALL_FAILED); +} + + +/* + * Reject a UNISIG Open from a remote host + * + * A user calls this routine (via the atm_reject_call function) + * after it is notified that an open request was received for it. + * + * Function will be called at splnet. + * + * Arguments: + * uvp pointer to user's VCCB + * errp pointer to an int for extended error information + * + * Returns: + * CALL_CLEARED call request rejected + * CALL_FAILED call rejection failed + * + */ +static int +unisig_reject(vcp, errp) + struct vccb *vcp; + int *errp; +{ + struct unisig_vccb *uvp = (struct unisig_vccb *)vcp; + struct atm_pif *pip = uvp->uv_pif; + struct unisig *usp = (struct unisig *)pip->pif_siginst; + + ATM_DEBUG1("unisig_reject: uvp=0x%x\n", uvp); + + /* + * Initialize the returned error code + */ + *errp = 0; + + + /* + * Return an error if we're detaching + */ + if (usp->us_state == UNISIG_DETACH) { + *errp = ENETDOWN; + goto failed; + } + + /* + * Call the VC state machine + */ + *errp = unisig_vc_state(usp, uvp, UNI_VC_REJECT_CALL, + (struct unisig_msg *) 0); + if (*errp) + goto failed; + + return(CALL_CLEARED); + +failed: + /* + * On error, free the VCCB and return CALL_FAILED + */ + uvp->uv_sstate = UNI_FREE; + uvp->uv_ustate = VCCU_CLOSED; + DEQUEUE(uvp, struct unisig_vccb, uv_sigelem, usp->us_vccq); + (void) unisig_free((struct vccb *)uvp); + return(CALL_FAILED); +} + + +/* + * Abort a UNISIG ATM Connection + * + * All (non-user) requests to abort a previously open VC connection (via + * the atm_abort_connection function), which is running over an + * interface attached to the UNISIG signalling manager, are handled here. + * The VCC owner will be notified of the request, in order to initiate + * termination of the connection. + * + * Function will be called at splnet. + * + * Arguments: + * vcp pointer to connection's VC control block + * + * Returns: + * 0 connection release was successful + * errno connection release failed - reason indicated + * + */ +static int +unisig_abort(vcp) + struct vccb *vcp; +{ + + ATM_DEBUG1("unisig_abort: vcp=0x%x\n", (int)vcp); + + /* + * Only abort once + */ + if (vcp->vc_ustate == VCCU_ABORT) { + return (EALREADY); + } + + /* + * Cancel any timer that might be running + */ + UNISIG_VC_CANCEL(vcp); + + /* + * Set immediate timer to schedule connection termination + */ + vcp->vc_ustate = VCCU_ABORT; + UNISIG_VC_TIMER(vcp, 0); + + return (0); +} + + +/* + * Free UNISIG ATM connection resources + * + * All service user requests to free the resources of a closed VCC + * connection (via the atm_free_connection function), which is running + * over an interface attached to the UNISIG signalling manager, are + *handled here. + * + * Function will be called at splnet. + * + * Arguments: + * vcp pointer to connection's VC control block + * + * Returns: + * 0 connection free was successful + * errno connection free failed - reason indicated + * + */ +int +unisig_free(vcp) + struct vccb *vcp; +{ + struct atm_pif *pip = vcp->vc_pif; + struct unisig *usp = (struct unisig *)pip->pif_siginst; + + ATM_DEBUG1("unisig_free: vcp = 0x%x\n", vcp); + + /* + * Make sure VCC has been closed + */ + if ((vcp->vc_ustate != VCCU_CLOSED && + vcp->vc_ustate != VCCU_ABORT) || + vcp->vc_sstate != UNI_FREE) { + ATM_DEBUG2("unisig_free: bad state, sstate=%d, ustate=%d\n", + vcp->vc_sstate, vcp->vc_ustate); + return(EEXIST); + } + + /* + * Remove VCCB from protocol queue + */ + DEQUEUE(vcp, struct vccb, vc_sigelem, usp->us_vccq); + + /* + * Free VCCB storage + */ + vcp->vc_ustate = VCCU_NULL; + vcp->vc_sstate = UNI_NULL; + atm_free((caddr_t)vcp); + + /* + * If we're detaching and this was the last VCC queued, + * get rid of the protocol instance + */ + if ((usp->us_state == UNISIG_DETACH) && + (Q_HEAD(usp->us_vccq, struct vccb) == NULL)) { + struct sigmgr *smp = pip->pif_sigmgr; + int s = splimp(); + + pip->pif_sigmgr = NULL; + pip->pif_siginst = NULL; + (void) splx(s); + + UNLINK((struct siginst *)usp, struct siginst, + smp->sm_prinst, si_next); + KM_FREE(usp, sizeof(struct unisig), M_DEVBUF); + } + + return (0); +} + + +/* + * UNISIG IOCTL support + * + * Function will be called at splnet. + * + * Arguments: + * code PF_ATM sub-operation code + * data pointer to code specific parameter data area + * arg1 pointer to code specific argument + * + * Returns: + * 0 request procesed + * errno error processing request - reason indicated + * + */ +static int +unisig_ioctl(code, data, arg1) + int code; + caddr_t data; + caddr_t arg1; +{ + struct atmdelreq *adp; + struct atminfreq *aip; + struct atmsetreq *asp; + struct unisig *usp; + struct unisig_vccb *uvp; + struct air_vcc_rsp rsp; + struct atm_pif *pip; + Atm_connection *cop; + u_int vpi, vci; + int err = 0, buf_len, i; + caddr_t buf_addr; + + ATM_DEBUG1("unisig_ioctl: code=%d\n", code); + + switch (code) { + + case AIOCS_DEL_PVC: + case AIOCS_DEL_SVC: + /* + * Delete a VCC + */ + adp = (struct atmdelreq *)data; + usp = (struct unisig *)arg1; + + /* + * Don't let a user close the UNISIG signalling VC + */ + vpi = adp->adr_pvc_vpi; + vci = adp->adr_pvc_vci; + if ((vpi == UNISIG_SIG_VPI && vci == UNISIG_SIG_VCI)) + return(EINVAL); + + /* + * Find requested VCC + */ + for (uvp = Q_HEAD(usp->us_vccq, struct unisig_vccb); uvp; + uvp = Q_NEXT(uvp, struct unisig_vccb, uv_sigelem)) { + if ((uvp->uv_vpi == vpi) && (uvp->uv_vci == vci)) + break; + } + if (uvp == NULL) + return (ENOENT); + + /* + * Check VCC type + */ + switch (code) { + case AIOCS_DEL_PVC: + if (!(uvp->uv_type & VCC_PVC)) { + return(EINVAL); + } + break; + case AIOCS_DEL_SVC: + if (!(uvp->uv_type & VCC_SVC)) { + return(EINVAL); + } + break; + } + + /* + * Schedule VCC termination + */ + unisig_set_cause_attr(&uvp->uv_connvc->cvc_attr, + T_ATM_CAUSE_UNSPECIFIED_NORMAL); + err = unisig_abort((struct vccb *)uvp); + break; + + case AIOCS_INF_VCC: + /* + * Return VCC information + */ + aip = (struct atminfreq *)data; + usp = (struct unisig *)arg1; + + buf_addr = aip->air_buf_addr; + buf_len = aip->air_buf_len; + + /* + * Loop through the VCC queue + */ + for (uvp = Q_HEAD(usp->us_vccq, struct unisig_vccb); uvp; + uvp = Q_NEXT(uvp, struct unisig_vccb, uv_sigelem)) { + /* + * Make sure there's room in the user's buffer + */ + if (buf_len < sizeof(rsp)) { + err = ENOSPC; + break; + } + + /* + * Fill out the response struct for the VCC + */ + (void) sprintf(rsp.avp_intf, "%s%d", + usp->us_pif->pif_name, + usp->us_pif->pif_unit); + rsp.avp_vpi = uvp->uv_vpi; + rsp.avp_vci = uvp->uv_vci; + rsp.avp_type = uvp->uv_type; + rsp.avp_aal = uvp->uv_connvc->cvc_attr.aal.type; + rsp.avp_sig_proto = uvp->uv_proto; + cop = uvp->uv_connvc->cvc_conn; + if (cop) + rsp.avp_encaps = cop->co_mpx; + else + rsp.avp_encaps = 0; + rsp.avp_state = uvp->uv_sstate; + if (uvp->uv_connvc->cvc_flags & CVCF_CALLER) { + rsp.avp_daddr = uvp->uv_connvc->cvc_attr.called.addr; + } else { + rsp.avp_daddr = uvp->uv_connvc->cvc_attr.calling.addr; + } + rsp.avp_dsubaddr.address_format = T_ATM_ABSENT; + rsp.avp_dsubaddr.address_length = 0; + rsp.avp_ipdus = uvp->uv_ipdus; + rsp.avp_opdus = uvp->uv_opdus; + rsp.avp_ibytes = uvp->uv_ibytes; + rsp.avp_obytes = uvp->uv_obytes; + rsp.avp_ierrors = uvp->uv_ierrors; + rsp.avp_oerrors = uvp->uv_oerrors; + rsp.avp_tstamp = uvp->uv_tstamp; + KM_ZERO(rsp.avp_owners, + sizeof(rsp.avp_owners)); + for (i = 0; cop && i < sizeof(rsp.avp_owners); + cop = cop->co_next, + i += T_ATM_APP_NAME_LEN+1) { + strncpy(&rsp.avp_owners[i], + cop->co_endpt->ep_getname(cop->co_toku), + T_ATM_APP_NAME_LEN); + } + + /* + * Copy the response into the user's buffer + */ + if (err = copyout((caddr_t)&rsp, buf_addr, + sizeof(rsp))) + break; + buf_addr += sizeof(rsp); + buf_len -= sizeof(rsp); + } + + /* + * Update the buffer pointer and length + */ + aip->air_buf_addr = buf_addr; + aip->air_buf_len = buf_len; + break; + + case AIOCS_INF_ARP: + case AIOCS_INF_ASV: + case AIOCS_SET_ASV: + /* + * Get ARP table information or get/set ARP server address + */ + err = uniarp_ioctl(code, data, arg1); + break; + + case AIOCS_SET_PRF: + /* + * Set NSAP prefix + */ + asp = (struct atmsetreq *)data; + usp = (struct unisig *)arg1; + pip = usp->us_pif; + if (usp->us_addr.address_format != T_ATM_ABSENT) { + if (KM_CMP(asp->asr_prf_pref, usp->us_addr.address, + sizeof(asp->asr_prf_pref)) != 0) + err = EALREADY; + break; + } + usp->us_addr.address_format = T_ATM_ENDSYS_ADDR; + usp->us_addr.address_length = sizeof(Atm_addr_nsap); + KM_COPY(&pip->pif_macaddr, + ((Atm_addr_nsap *)usp->us_addr.address)->aan_esi, + sizeof(pip->pif_macaddr)); + KM_COPY((caddr_t) asp->asr_prf_pref, + &((Atm_addr_nsap *)usp->us_addr.address)->aan_afi, + sizeof(asp->asr_prf_pref)); + log(LOG_INFO, "uni: set address %s on interface %s\n", + unisig_addr_print(&usp->us_addr), + asp->asr_prf_intf); + + /* + * Pass event to signalling manager state machine + */ + err = unisig_sigmgr_state(usp, UNISIG_SIGMGR_ADDR_SET, + (KBuffer *) NULL); + + /* + * Clean up if there was an error + */ + if (err) { + usp->us_addr.address_format = T_ATM_ABSENT; + usp->us_addr.address_length = 0; + break; + } + + /* + * Inform ARP code of new address + */ + uniarp_ifaddr((struct siginst *)usp); + break; + + default: + err = EOPNOTSUPP; + } + + return (err); +} diff --git a/sys/netatm/uni/unisig_mbuf.c b/sys/netatm/uni/unisig_mbuf.c new file mode 100644 index 0000000..84c78fe --- /dev/null +++ b/sys/netatm/uni/unisig_mbuf.c @@ -0,0 +1,485 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_mbuf.c,v 1.6 1998/08/26 23:29:22 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * Message buffer handling routines + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: unisig_mbuf.c,v 1.6 1998/08/26 23:29:22 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/unisig_mbuf.h> +#include <netatm/uni/unisig_msg.h> + + +/* + * Initialize a unisig formatting structure + * + * Arguments: + * usf pointer to a unisig formatting structure + * usp pointer to a unisig protocol instance + * buf pointer to a buffer chain (decode only) + * op operation code (encode or decode) + * headroom headroom to leave in first buffer + * + * Returns: + * 0 success + * errno error encountered + * + */ +int +usf_init(usf, usp, buf, op, headroom) + struct usfmt *usf; + struct unisig *usp; + KBuffer *buf; + int op; + int headroom; +{ + KBuffer *m; + + ATM_DEBUG3("usf_init: usf=0x%x, buf=0x%x, op=%d\n", + (int) usf, (int) buf, op); + + /* + * Check parameters + */ + if (!usf) + return(EINVAL); + + switch(op) { + + case USF_ENCODE: + /* + * Get a buffer + */ + KB_ALLOCPKT(m, USF_MIN_ALLOC, KB_F_NOWAIT, KB_T_DATA); + if (m == NULL) + return(ENOMEM); + KB_LEN(m) = 0; + if (headroom < KB_BFRLEN(m)) { + KB_HEADSET(m, headroom); + } + break; + + case USF_DECODE: + /* + * Verify buffer address + */ + if (!buf) + return(EINVAL); + m = buf; + break; + + default: + return(EINVAL); + } + + /* + * Save parameters in formatting structure + */ + usf->usf_m_addr = m; + usf->usf_m_base = m; + usf->usf_loc = 0; + usf->usf_op = op; + usf->usf_sig = usp; + + return(0); +} + + +/* + * Get or put the next byte of a signalling message + * + * Arguments: + * usf pointer to a unisig formatting structure + * c pointer to the byte to send from or receive into + * + * Returns: + * 0 success + * errno error encountered + * + */ +int +usf_byte(usf, c) + struct usfmt *usf; + u_char *c; +{ + u_char *mp; + KBuffer *m = usf->usf_m_addr, *m1; + int space; + + switch (usf->usf_op) { + + case USF_DECODE: + /* + * Make sure we're not past the end of the buffer + * (allowing for zero-length buffers) + */ + while (usf->usf_loc >= KB_LEN(m)) { + if (KB_NEXT(usf->usf_m_addr)) { + usf->usf_m_addr = m = KB_NEXT(usf->usf_m_addr); + usf->usf_loc = 0; + } else { + return(EMSGSIZE); + } + } + + /* + * Get the data from the buffer + */ + KB_DATASTART(m, mp, u_char *); + *c = mp[usf->usf_loc]; + usf->usf_loc++; + break; + + case USF_ENCODE: + /* + * If the current buffer is full, get another + */ + KB_TAILROOM(m, space); + if (space == 0) { + KB_ALLOC(m1, USF_MIN_ALLOC, KB_F_NOWAIT, KB_T_DATA); + if (m1 == NULL) + return(ENOMEM); + KB_LEN(m1) = 0; + KB_LINK(m1, m); + usf->usf_m_addr = m = m1; + usf->usf_loc = 0; + } + + /* + * Put the data into the buffer + */ + KB_DATASTART(m, mp, u_char *); + mp[usf->usf_loc] = *c; + KB_TAILADJ(m, 1); + usf->usf_loc++; + break; + + default: + /* + * Invalid operation code + */ + return(EINVAL); + } + + return(0); + +} + +/* + * Get or put a short integer + * + * Arguments: + * usf pointer to a unisig formatting structure + * s pointer to a short to send from or receive into + * + * Returns: + * 0 success + * errno error encountered + * + */ +int +usf_short(usf, s) + struct usfmt *usf; + u_short *s; + +{ + int rc; + union { + u_short value; + u_char b[sizeof(u_short)]; + } tval; + + tval.value = 0; + if (usf->usf_op == USF_ENCODE) + tval.value = htons(*s); + + if (rc = usf_byte(usf, &tval.b[0])) + return(rc); + if (rc = usf_byte(usf, &tval.b[1])) + return(rc); + + if (usf->usf_op == USF_DECODE) + *s = ntohs(tval.value); + + return(0); +} + + +/* + * Get or put a 3-byte integer + * + * Arguments: + * usf pointer to a unisig formatting structure + * i pointer to an integer to send from or receive into + * + * Returns: + * 0 success + * errno error encountered + * + */ +int +usf_int3(usf, i) + struct usfmt *usf; + u_int *i; + +{ + int j, rc; + union { + u_int value; + u_char b[sizeof(u_int)]; + } tval; + + tval.value = 0; + + if (usf->usf_op == USF_ENCODE) + tval.value = htonl(*i); + + for (j=0; j<3; j++) { + rc = usf_byte(usf, &tval.b[j+sizeof(u_int)-3]); + if (rc) + return(rc); + } + + if (usf->usf_op == USF_DECODE) + *i = ntohl(tval.value); + + return(rc); +} + + +/* + * Get or put an integer + * + * Arguments: + * usf pointer to a unisig formatting structure + * i pointer to an integer to send from or receive into + * + * Returns: + * 0 success + * errno error encountered + * + */ +int +usf_int(usf, i) + struct usfmt *usf; + u_int *i; + +{ + int j, rc; + union { + u_int value; + u_char b[sizeof(u_int)]; + } tval; + + if (usf->usf_op == USF_ENCODE) + tval.value = htonl(*i); + + for (j=0; j<4; j++) { + rc = usf_byte(usf, &tval.b[j+sizeof(u_int)-4]); + if (rc) + return(rc); + } + + if (usf->usf_op == USF_DECODE) + *i = ntohl(tval.value); + + return(rc); +} + + +/* + * Get or put an extented field + * + * An extented field consists of a string of bytes. All but the last + * byte of the field has the high-order bit set to zero. When decoding, + * this routine will read bytes until either the input is exhausted or + * a byte with a high-order one is found. Whe encoding, it will take an + * unsigned integer and write until the highest-order one bit has been + * written. + * + * Arguments: + * usf pointer to a unisig formatting structure + * i pointer to an integer to send from or receive into + * + * Returns: + * 0 success + * errno error encountered + * + */ +int +usf_ext(usf, i) + struct usfmt *usf; + u_int *i; + +{ + int j, rc; + u_char c, buff[sizeof(u_int)+1]; + u_int val; + union { + u_int value; + u_char b[sizeof(u_int)]; + } tval; + + switch(usf->usf_op) { + + case USF_ENCODE: + val = *i; + j = 0; + while (val) { + tval.value = htonl(val); + buff[j] = tval.b[sizeof(u_int)-1] & UNI_IE_EXT_MASK; + val >>= 7; + j++; + } + j--; + buff[0] |= UNI_IE_EXT_BIT; + for (; j>=0; j--) { + rc = usf_byte(usf, &buff[j]); + if (rc) + return(rc); + } + break; + + case USF_DECODE: + c = 0; + val = 0; + while (!(c & UNI_IE_EXT_BIT)) { + rc = usf_byte(usf, &c); + if (rc) + return(rc); + val = (val << 7) + (c & UNI_IE_EXT_MASK); + } + *i = val; + break; + + default: + return(EINVAL); + } + + return(0); +} + + +/* + * Count the bytes remaining to be decoded + * + * Arguments: + * usf pointer to a unisig formatting structure + * + * Returns: + * int the number of bytes in the buffer chain remaining to + * be decoded + * + */ +int +usf_count(usf) + struct usfmt *usf; +{ + int count; + KBuffer *m = usf->usf_m_addr; + + /* + * Return zero if we're not decoding + */ + if (usf->usf_op != USF_DECODE) + return (0); + + /* + * Calculate the length of data remaining in the current buffer + */ + count = KB_LEN(m) - usf->usf_loc; + + /* + * Loop through any remaining buffers, adding in their lengths + */ + while (KB_NEXT(m)) { + m = KB_NEXT(m); + count += KB_LEN(m); + } + + return(count); + +} + + +/* + * Get or put the next byte of a signalling message and return + * the byte's buffer address + * + * Arguments: + * usf pointer to a unisig formatting structure + * c pointer to the byte to send from or receive into + * bp address to store the byte's buffer address + * + * Returns: + * 0 success + * errno error encountered + * + */ +int +usf_byte_mark(usf, c, bp) + struct usfmt *usf; + u_char *c; + u_char **bp; +{ + u_char *mp; + int rc; + + /* + * First, get/put the data byte + */ + rc = usf_byte(usf, c); + if (rc) { + + /* + * Error encountered + */ + *bp = NULL; + return (rc); + } + + /* + * Now return the buffer address of that byte + */ + KB_DATASTART(usf->usf_m_addr, mp, u_char *); + *bp = &mp[usf->usf_loc - 1]; + + return (0); +} + diff --git a/sys/netatm/uni/unisig_mbuf.h b/sys/netatm/uni/unisig_mbuf.h new file mode 100644 index 0000000..f394047 --- /dev/null +++ b/sys/netatm/uni/unisig_mbuf.h @@ -0,0 +1,58 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_mbuf.h,v 1.5 1998/08/26 23:29:22 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * Message buffer formats + * + */ + +#ifndef _UNI_SIG_MBUF_H +#define _UNI_SIG_MBUF_H + + +/* + * Structure for message encoding/decoding information. + */ +struct usfmt { + KBuffer *usf_m_addr; /* Current buffer */ + KBuffer *usf_m_base; /* First buffer in chain */ + int usf_loc; /* Offset in current buffer */ + int usf_op; /* Operation (see below) */ + struct unisig *usf_sig; /* UNI signalling instance */ +}; + +#define USF_ENCODE 1 +#define USF_DECODE 2 + +#define USF_MIN_ALLOC MHLEN /* Minimum encoding buffer size */ + +#endif /* _UNI_SIG_MBUF_H */ diff --git a/sys/netatm/uni/unisig_msg.c b/sys/netatm/uni/unisig_msg.c new file mode 100644 index 0000000..22bf469 --- /dev/null +++ b/sys/netatm/uni/unisig_msg.c @@ -0,0 +1,1002 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_msg.c,v 1.10 1998/08/26 23:29:22 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * Message handling module + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: unisig_msg.c,v 1.10 1998/08/26 23:29:22 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/unisig.h> +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/unisig_msg.h> +#include <netatm/uni/unisig_mbuf.h> +#include <netatm/uni/unisig_print.h> + + +/* + * Local functions + */ +static void unisig_rcv_restart __P((struct unisig *, struct unisig_msg *)); +static void unisig_rcv_setup __P((struct unisig *, struct unisig_msg *)); + + +/* + * Local variables + */ +#ifdef DIAGNOSTIC +static int unisig_print_msg = 0; +#endif + + +/* + * Set a Cause IE based on information in an ATM attribute block + * + * Arguments: + * iep pointer to a cause IE + * msg pointer to message + * cause cause code for the error + * + * Returns: + * 0 message sent OK + * errno error encountered + * + */ +void +unisig_cause_from_attr(iep, aap) + struct ie_generic *iep; + Atm_attributes *aap; +{ + /* + * Copy cause info from attribute block to IE + */ + iep->ie_ident = UNI_IE_CAUS; + iep->ie_coding = aap->cause.v.coding_standard; + iep->ie_caus_loc = aap->cause.v.location; + iep->ie_caus_cause = aap->cause.v.cause_value; +} + + +/* + * Set a Cause IE based on information in a UNI signalling message + * + * Arguments: + * iep pointer to a cause IE + * msg pointer to message + * cause cause code for the error + * + * Returns: + * 0 message sent OK + * errno error encountered + * + */ +void +unisig_cause_from_msg(iep, msg, cause) + struct ie_generic *iep; + struct unisig_msg *msg; + int cause; +{ + struct ie_generic *ie1; + int i; + + /* + * Fill out the cause IE fixed fields + */ + iep->ie_ident = UNI_IE_CAUS; + iep->ie_caus_loc = UNI_IE_CAUS_LOC_USER; + iep->ie_caus_cause = cause; + + /* + * Set diagnostics if indicated + */ + switch(cause) { + case UNI_IE_CAUS_IECONTENT: + iep->ie_caus_diag_len = 0; + for (i = 0, ie1 = msg->msg_ie_err; + ie1 && i < UNI_IE_CAUS_MAX_ID; + ie1 = ie1->ie_next) { + if (ie1->ie_err_cause == UNI_IE_CAUS_IECONTENT) { + iep->ie_caus_diagnostic[i] = + ie1->ie_ident; + iep->ie_caus_diag_len++; + i++; + } + } + break; + case UNI_IE_CAUS_REJECT: + iep->ie_caus_diag_len = 2; + iep->ie_caus_diagnostic[0] = UNI_IE_EXT_BIT + + (UNI_IE_CAUS_RR_USER << UNI_IE_CAUS_RR_SHIFT) + + UNI_IE_CAUS_RC_TRANS; + iep->ie_caus_diagnostic[1] = 0; + break; + case UNI_IE_CAUS_MISSING: + iep->ie_caus_diag_len = 0; + for (i = 0, ie1 = msg->msg_ie_err; + ie1 && i < UNI_IE_CAUS_MAX_ID; + ie1 = ie1->ie_next) { + if (ie1->ie_err_cause == UNI_IE_CAUS_MISSING) { + iep->ie_caus_diagnostic[i] = + ie1->ie_ident; + iep->ie_caus_diag_len++; + i++; + } + } + } +} + + +/* + * Send a UNISIG signalling message + * + * Called to send a Q.2931 message. This routine encodes the message + * and hands it to SSCF for transmission. + * + * Arguments: + * usp pointer to UNISIG protocol instance block + * msg pointer to message + * + * Returns: + * 0 message sent OK + * errno error encountered + * + */ +int +unisig_send_msg(usp, msg) + struct unisig *usp; + struct unisig_msg *msg; +{ + int err = 0; + struct usfmt usf; + + ATM_DEBUG2("unisig_send_msg: msg=0x%x, type=%d\n", msg, + msg->msg_type); + + /* + * Make sure the network is up + */ + if (usp->us_state != UNISIG_ACTIVE) + return(ENETDOWN); + +#ifdef DIAGNOSTIC + /* + * Print the message we're sending. + */ + if (unisig_print_msg) + usp_print_msg(msg, UNISIG_MSG_OUT); +#endif + + /* + * Convert message to network order + */ + err = usf_init(&usf, usp, (KBuffer *) 0, USF_ENCODE, + usp->us_headout); + if (err) + return(err); + + err = usf_enc_msg(&usf, msg); + if (err) { + ATM_DEBUG1("unisig_send_msg: encode failed with %d\n", + err); + KB_FREEALL(usf.usf_m_base); + return(EIO); + } + +#ifdef DIAGNOSTIC + /* + * Print the converted message + */ + if (unisig_print_msg > 1) + unisig_print_mbuf(usf.usf_m_base); +#endif + + /* + * Send the message + */ + err = atm_cm_saal_data(usp->us_conn, usf.usf_m_base); + if (err) + KB_FREEALL(usf.usf_m_base); + + return(err); +} + + +/* + * Send a SETUP request + * + * Build and send a Q.2931 SETUP message. + * + * Arguments: + * usp pointer to UNISIG protocol instance block + * uvp pointer to VCCB for which the request is being sent + * + * Returns: + * none + * + */ +int +unisig_send_setup(usp, uvp) + struct unisig *usp; + struct unisig_vccb *uvp; +{ + int err = 0; + struct unisig_msg *setup; + Atm_attributes *ap = &uvp->uv_connvc->cvc_attr; + + ATM_DEBUG1("unisig_send_setup: uvp=0x%x\n", (int) uvp); + + /* + * Make sure required connection attriutes are set + */ + if (ap->aal.tag != T_ATM_PRESENT || + ap->traffic.tag != T_ATM_PRESENT || + ap->bearer.tag != T_ATM_PRESENT || + ap->called.tag != T_ATM_PRESENT || + ap->qos.tag != T_ATM_PRESENT) { + err = EINVAL; + setup = NULL; + goto done; + } + + /* + * Get memory for a SETUP message + */ + setup = (struct unisig_msg *)atm_allocate(&unisig_msgpool); + if (setup == NULL) { + err = ENOMEM; + goto done; + } + + /* + * Fill in the SETUP message + */ + if (!uvp->uv_call_ref) + uvp->uv_call_ref = unisig_alloc_call_ref(usp); + setup->msg_call_ref = uvp->uv_call_ref; + setup->msg_type = UNI_MSG_SETU; + + /* + * Set IEs from connection attributes + */ + err = unisig_set_attrs(usp, setup, ap); + if (err) + goto done; + + /* + * Attach a Calling Party Number IE if the user didn't + * specify one in the attribute block + */ + if (ap->calling.tag != T_ATM_PRESENT) { + setup->msg_ie_cgad = (struct ie_generic *) + atm_allocate(&unisig_iepool); + if (setup->msg_ie_cgad == NULL) { + err = ENOMEM; + goto done; + } + setup->msg_ie_cgad->ie_ident = UNI_IE_CGAD; + ATM_ADDR_COPY(&usp->us_addr, + &setup->msg_ie_cgad->ie_cgad_addr); + ATM_ADDR_SEL_COPY(&usp->us_addr, + uvp->uv_nif ? uvp->uv_nif->nif_sel : 0, + &setup->msg_ie_cgad->ie_cgad_addr); + } + + /* + * Send the SETUP message + */ + err = unisig_send_msg(usp, setup); + +done: + if (setup) + unisig_free_msg(setup); + + return(err); +} + + +/* + * Send a RELEASE message + * + * Arguments: + * usp pointer to UNISIG protocol instance block + * uvp pointer to VCCB for which the RELEASE is being sent + * msg pointer to UNI signalling message that the RELEASE + * responds to (may be NULL) + * cause the reason for the RELEASE; a value of + * T_ATM_ABSENT indicates that the cause code is + * in the VCC's ATM attributes block + * + * Returns: + * none + * + */ +int +unisig_send_release(usp, uvp, msg, cause) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; + int cause; +{ + int err = 0; + struct unisig_msg *rls_msg; + struct ie_generic *cause_ie; + + ATM_DEBUG2("unisig_send_release: usp=0x%x, uvp=0x%x\n", + (int) usp, (int) uvp); + + /* + * Get memory for a RELEASE message + */ + rls_msg = (struct unisig_msg *) atm_allocate(&unisig_msgpool); + if (rls_msg == NULL) { + return(ENOMEM); + } + cause_ie = (struct ie_generic *) atm_allocate(&unisig_iepool); + if (cause_ie == NULL) { + atm_free(rls_msg); + return(ENOMEM); + } + + /* + * Fill in the RELEASE message + */ + rls_msg->msg_call_ref = uvp->uv_call_ref; + rls_msg->msg_type = UNI_MSG_RLSE; + rls_msg->msg_type_flag = 0; + rls_msg->msg_type_action = 0; + rls_msg->msg_ie_caus = cause_ie; + + /* + * Fill out the cause IE + */ + cause_ie->ie_ident = UNI_IE_CAUS; + if (cause == T_ATM_ABSENT) { + unisig_cause_from_attr(cause_ie, + &uvp->uv_connvc->cvc_attr); + } else { + cause_ie->ie_caus_loc = UNI_IE_CAUS_LOC_USER; + unisig_cause_from_msg(cause_ie, msg, cause); + } + + /* + * Send the RELEASE + */ + err = unisig_send_msg(usp, rls_msg); + unisig_free_msg(rls_msg); + + return(err); +} + + +/* + * Send a RELEASE COMPLETE message + * + * Arguments: + * usp pointer to UNISIG protocol instance block + * uvp pointer to VCCB for which the RELEASE is being sent. + * NULL indicates that a VCCB wasn't found for a call + * reference value. + * msg pointer to the message which triggered the send + * cause the cause code for the message; a value of + * T_ATM_ABSENT indicates that the cause code is + * in the VCC's ATM attributes block + * + * Returns: + * 0 success + * errno error encountered + * + */ +int +unisig_send_release_complete(usp, uvp, msg, cause) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; + int cause; +{ + int err = 0; + struct unisig_msg *rls_cmp; + struct ie_generic *cause_ie; + + ATM_DEBUG4("unisig_send_release_complete usp=0x%x, uvp=0x%x, msg=0x%x, cause=%d\n", + (int) usp, (int) uvp, (int) msg, cause); + + /* + * Get memory for a RELEASE COMPLETE message + */ + rls_cmp = (struct unisig_msg *) atm_allocate(&unisig_msgpool); + if (rls_cmp == NULL) { + return(ENOMEM); + } + cause_ie = (struct ie_generic *) atm_allocate(&unisig_iepool); + if (cause_ie == NULL) { + atm_free(rls_cmp); + return(ENOMEM); + } + + /* + * Fill in the RELEASE COMPLETE message + */ + if (uvp) { + rls_cmp->msg_call_ref = uvp->uv_call_ref; + } else if (msg) { + rls_cmp->msg_call_ref = EXTRACT_CREF(msg->msg_call_ref); + } else { + rls_cmp->msg_call_ref = UNI_MSG_CALL_REF_GLOBAL; + } + rls_cmp->msg_type = UNI_MSG_RLSC; + rls_cmp->msg_type_flag = 0; + rls_cmp->msg_type_action = 0; + rls_cmp->msg_ie_caus = cause_ie; + + /* + * Fill out the cause IE + */ + cause_ie->ie_ident = UNI_IE_CAUS; + if (cause == T_ATM_ABSENT) { + unisig_cause_from_attr(cause_ie, + &uvp->uv_connvc->cvc_attr); + } else { + cause_ie->ie_caus_loc = UNI_IE_CAUS_LOC_USER; + unisig_cause_from_msg(cause_ie, msg, cause); + } + + /* + * Send the RELEASE COMPLETE + */ + err = unisig_send_msg(usp, rls_cmp); + unisig_free_msg(rls_cmp); + + return(err); +} + + +/* + * Send a STATUS message + * + * Arguments: + * usp pointer to UNISIG protocol instance block + * uvp pointer to VCCB for which the STATUS is being sent. + * NULL indicates that a VCCB wasn't found for a call + * reference value. + * msg pointer to the message which triggered the send + * cause the cause code to include in the message + * + * Returns: + * none + * + */ +int +unisig_send_status(usp, uvp, msg, cause) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; + int cause; +{ + int err = 0, i; + struct unisig_msg *stat_msg; + struct ie_generic *cause_ie, *clst_ie, *iep; + + ATM_DEBUG4("unisig_send_status: usp=0x%x, uvp=0x%x, msg=0x%x, cause=%d\n", + (int) usp, (int) uvp, (int) msg, cause); + + /* + * Get memory for a STATUS message + */ + stat_msg = (struct unisig_msg *) atm_allocate(&unisig_msgpool); + if (stat_msg == NULL) { + return(ENOMEM); + } + cause_ie = (struct ie_generic *) atm_allocate(&unisig_iepool); + if (cause_ie == NULL) { + atm_free(stat_msg); + return(ENOMEM); + } + clst_ie = (struct ie_generic *) atm_allocate(&unisig_iepool); + if (clst_ie == NULL) { + atm_free(stat_msg); + atm_free(cause_ie); + return(ENOMEM); + } + + /* + * Fill in the STATUS message + */ + if (uvp) { + stat_msg->msg_call_ref = uvp->uv_call_ref; + } else if (msg) { + stat_msg->msg_call_ref = + EXTRACT_CREF(msg->msg_call_ref); + } else { + stat_msg->msg_call_ref = UNI_MSG_CALL_REF_GLOBAL; + } + stat_msg->msg_type = UNI_MSG_STAT; + stat_msg->msg_type_flag = 0; + stat_msg->msg_type_action = 0; + stat_msg->msg_ie_clst = clst_ie; + stat_msg->msg_ie_caus = cause_ie; + + /* + * Fill out the call state IE + */ + clst_ie->ie_ident = UNI_IE_CLST; + clst_ie->ie_coding = 0; + clst_ie->ie_flag = 0; + clst_ie->ie_action = 0; + if (uvp) { + clst_ie->ie_clst_state = uvp->uv_sstate; + } else { + clst_ie->ie_clst_state = UNI_NULL; + } + + /* + * Fill out the cause IE + */ + cause_ie->ie_ident = UNI_IE_CAUS; + cause_ie->ie_coding = 0; + cause_ie->ie_flag = 0; + cause_ie->ie_action = 0; + cause_ie->ie_caus_loc = UNI_IE_CAUS_LOC_USER; + cause_ie->ie_caus_cause = cause; + switch (cause) { + case UNI_IE_CAUS_MTEXIST: + case UNI_IE_CAUS_STATE: + if (msg) { + cause_ie->ie_caus_diagnostic[0] = msg->msg_type; + } + break; + case UNI_IE_CAUS_MISSING: + case UNI_IE_CAUS_IECONTENT: + case UNI_IE_CAUS_IEEXIST: + for (i=0, iep=msg->msg_ie_err; + iep && i<UNI_MSG_IE_CNT; + i++, iep = iep->ie_next) { + if (iep->ie_err_cause == cause) { + cause_ie->ie_caus_diagnostic[i] = + iep->ie_ident; + } + } + } + + /* + * Send the STATUS message + */ + err = unisig_send_msg(usp, stat_msg); + unisig_free_msg(stat_msg); + + return(err); +} + + +/* + * Process a RESTART message + * + * Arguments: + * usp pointer to UNISIG protocol instance block + * msg pointer to the RESTART message + * + * Returns: + * none + * + */ +static void +unisig_rcv_restart(usp, msg) + struct unisig *usp; + struct unisig_msg *msg; +{ + struct unisig_vccb *uvp, *uvnext; + struct unisig_msg *rsta_msg; + int s; + + ATM_DEBUG2("unisig_rcv_restart: usp=0x%x, msg=0x%x\n", + usp, msg); + + /* + * Check what class of VCCs we're supposed to restart + */ + if (msg->msg_ie_rsti->ie_rsti_class == UNI_IE_RSTI_IND_VC) { + /* + * Just restart the indicated VCC + */ + if (msg->msg_ie_cnid) { + uvp = unisig_find_vpvc(usp, + msg->msg_ie_cnid->ie_cnid_vpci, + msg->msg_ie_cnid->ie_cnid_vci, + 0); + if (uvp && uvp->uv_type & VCC_SVC) { + (void) unisig_clear_vcc(usp, uvp, + T_ATM_CAUSE_NORMAL_CALL_CLEARING); + } + } + } else { + /* + * Restart all VCCs + */ + s = splnet(); + for (uvp=Q_HEAD(usp->us_vccq, struct unisig_vccb); uvp; + uvp=uvnext) { + uvnext = Q_NEXT(uvp, struct unisig_vccb, + uv_sigelem); + if (uvp->uv_type & VCC_SVC) { + (void) unisig_clear_vcc(usp, uvp, + T_ATM_CAUSE_NORMAL_CALL_CLEARING); + } + } + (void) splx(s); + } + + /* + * Get memory for a RESTART ACKNOWLEDGE message + */ + rsta_msg = (struct unisig_msg *) atm_allocate(&unisig_msgpool); + if (rsta_msg == NULL) { + return; + } + + /* + * Fill out the message + */ + rsta_msg->msg_call_ref = EXTRACT_CREF(msg->msg_call_ref); + rsta_msg->msg_type = UNI_MSG_RSTA; + rsta_msg->msg_type_flag = 0; + rsta_msg->msg_type_action = 0; + rsta_msg->msg_ie_rsti = msg->msg_ie_rsti; + if (msg->msg_ie_cnid) { + rsta_msg->msg_ie_cnid = msg->msg_ie_cnid; + } + + /* + * Send the message + */ + (void) unisig_send_msg(usp, rsta_msg); + rsta_msg->msg_ie_rsti = NULL; + rsta_msg->msg_ie_cnid = NULL; + unisig_free_msg(rsta_msg); + + return; +} + + +/* + * Process a SETUP message + * + * Arguments: + * usp pointer to UNISIG protocol instance block + * msg pointer to the SETUP message + * + * Returns: + * none + * + */ +static void +unisig_rcv_setup(usp, msg) + struct unisig *usp; + struct unisig_msg *msg; +{ + struct unisig_vccb *uvp = NULL; + struct ie_generic *iep; + + ATM_DEBUG2("unisig_rcv_setup: usp=0x%x, msg=0x%x\n", usp, msg); + + /* + * If we already have a VCC with the call reference, + * ignore the SETUP message + */ + uvp = unisig_find_conn(usp, EXTRACT_CREF(msg->msg_call_ref)); + if (uvp) + return; + + /* + * If the call reference flag is incorrectly set, + * ignore the SETUP message + */ + if (msg->msg_call_ref & UNI_MSG_CALL_REF_RMT) + return; + + /* + * If there are missing mandatory IEs, send a + * RELEASE COMPLETE message and ignore the SETUP + */ + for (iep = msg->msg_ie_err; iep; iep = iep->ie_next) { + if (iep->ie_err_cause == UNI_IE_CAUS_MISSING) { + (void) unisig_send_release_complete(usp, + uvp, msg, UNI_IE_CAUS_MISSING); + return; + } + } + + /* + * If there are mandatory IEs with invalid content, send a + * RELEASE COMPLETE message and ignore the SETUP + */ + for (iep = msg->msg_ie_err; iep; iep = iep->ie_next) { + if (iep->ie_err_cause == UNI_IE_CAUS_IECONTENT) { + (void) unisig_send_release_complete(usp, + uvp, msg, + UNI_IE_CAUS_IECONTENT); + return; + } + } + + /* + * Get a new VCCB for the connection + */ + uvp = (struct unisig_vccb *)atm_allocate(&unisig_vcpool); + if (uvp == NULL) { + return; + } + + /* + * Put the VCCB on the UNISIG queue + */ + ENQUEUE(uvp, struct unisig_vccb, uv_sigelem, usp->us_vccq); + + /* + * Set the state and call reference value + */ + uvp->uv_sstate = UNI_NULL; + uvp->uv_call_ref = EXTRACT_CREF(msg->msg_call_ref); + + /* + * Pass the VCCB and message to the VC state machine + */ + (void) unisig_vc_state(usp, uvp, UNI_VC_SETUP_MSG, msg); + + /* + * If the VCCB state is NULL, the open failed and the + * VCCB should be released + */ + if (uvp->uv_sstate == UNI_NULL) { + DEQUEUE(uvp, struct unisig_vccb, uv_sigelem, + usp->us_vccq); + atm_free(uvp); + } + + return; +} + + +/* + * Process a UNISIG signalling message + * + * Called when a UNISIG message is received. The message is decoded + * and passed to the UNISIG state machine. Unrecognized and + * unexpected messages are logged. + * + * Arguments: + * usp pointer to UNISIG protocol instance block + * m pointer to a buffer chain containing the UNISIG message + * + * Returns: + * none + * + */ +int +unisig_rcv_msg(usp, m) + struct unisig *usp; + KBuffer *m; +{ + int err; + u_int cref; + struct usfmt usf; + struct unisig_msg *msg = 0; + struct unisig_vccb *uvp = 0; + struct ie_generic *iep; + + ATM_DEBUG2("unisig_rcv_msg: bfr=0x%x, len=%d\n", (int)m, KB_LEN(m)); + +#ifdef NOTDEF + unisig_print_mbuf(m); +#endif + + /* + * Get storage for the message + */ + msg = (struct unisig_msg *)atm_allocate(&unisig_msgpool); + if (msg == NULL) { + err = ENOMEM; + goto done; + } + + /* + * Convert the message from network order to internal format + */ + err = usf_init(&usf, usp, m, USF_DECODE, 0); + if (err) { + if (err == EINVAL) + panic("unisig_rcv_msg: invalid parameter\n"); + ATM_DEBUG1("unisig_rcv_msg: decode init failed with %d\n", + err); + goto done; + } + + err = usf_dec_msg(&usf, msg); + if (err) { + ATM_DEBUG1("unisig_rcv_msg: decode failed with %d\n", + err); + goto done; + } + +#ifdef DIAGNOSTIC + /* + * Debug--print some information about the message + */ + if (unisig_print_msg) + usp_print_msg(msg, UNISIG_MSG_IN); +#endif + + /* + * Get the call reference value + */ + cref = EXTRACT_CREF(msg->msg_call_ref); + + /* + * Any message with the global call reference value except + * RESTART, RESTART ACK, or STATUS is in error + */ + if (GLOBAL_CREF(cref) && + msg->msg_type != UNI_MSG_RSTR && + msg->msg_type != UNI_MSG_RSTA && + msg->msg_type != UNI_MSG_STAT) { + /* + * Send STATUS message indicating the error + */ + err = unisig_send_status(usp, (struct unisig_vccb *) 0, + msg, UNI_IE_CAUS_CREF); + goto done; + } + + /* + * Check for missing mandatory IEs. Checks for SETUP, + * RELEASE, and RELEASE COMPLETE are handled elsewhere. + */ + if (msg->msg_type != UNI_MSG_SETU && + msg->msg_type != UNI_MSG_RLSE && + msg->msg_type != UNI_MSG_RLSC) { + for (iep = msg->msg_ie_err; iep; iep = iep->ie_next) { + if (iep->ie_err_cause == UNI_IE_CAUS_MISSING) { + err = unisig_send_status(usp, + uvp, msg, + UNI_IE_CAUS_MISSING); + goto done; + } + } + } + + /* + * Find the VCCB associated with the message + */ + uvp = unisig_find_conn(usp, cref); + + /* + * Process the message based on its type + */ + switch(msg->msg_type) { + case UNI_MSG_CALP: + (void) unisig_vc_state(usp, uvp, + UNI_VC_CALLP_MSG, msg); + break; + case UNI_MSG_CONN: + (void) unisig_vc_state(usp, uvp, + UNI_VC_CONNECT_MSG, msg); + break; + case UNI_MSG_CACK: + (void) unisig_vc_state(usp, uvp, + UNI_VC_CNCTACK_MSG, msg); + break; + case UNI_MSG_SETU: + unisig_rcv_setup(usp, msg); + break; + case UNI_MSG_RLSE: + (void) unisig_vc_state(usp, uvp, + UNI_VC_RELEASE_MSG, msg); + break; + case UNI_MSG_RLSC: + /* + * Ignore a RELEASE COMPLETE with an unrecognized + * call reference value + */ + if (uvp) { + (void) unisig_vc_state(usp, uvp, + UNI_VC_RLSCMP_MSG, msg); + } + break; + case UNI_MSG_RSTR: + unisig_rcv_restart(usp, msg); + break; + case UNI_MSG_RSTA: + break; + case UNI_MSG_STAT: + (void) unisig_vc_state(usp, uvp, + UNI_VC_STATUS_MSG, msg); + break; + case UNI_MSG_SENQ: + (void) unisig_vc_state(usp, uvp, + UNI_VC_STATUSENQ_MSG, msg); + break; + case UNI_MSG_ADDP: + (void) unisig_vc_state(usp, uvp, + UNI_VC_ADDP_MSG, msg); + break; + case UNI_MSG_ADPA: + (void) unisig_vc_state(usp, uvp, + UNI_VC_ADDPACK_MSG, msg); + break; + case UNI_MSG_ADPR: + (void) unisig_vc_state(usp, uvp, + UNI_VC_ADDPREJ_MSG, msg); + break; + case UNI_MSG_DRPP: + (void) unisig_vc_state(usp, uvp, + UNI_VC_DROP_MSG, msg); + break; + case UNI_MSG_DRPA: + (void) unisig_vc_state(usp, uvp, + UNI_VC_DROPACK_MSG, msg); + break; + default: + /* + * Message size didn't match size received + */ + err = unisig_send_status(usp, uvp, msg, + UNI_IE_CAUS_MTEXIST); + } + +done: + /* + * Handle message errors that require a response + */ + switch(err) { + case EMSGSIZE: + /* + * Message size didn't match size received + */ + err = unisig_send_status(usp, uvp, msg, + UNI_IE_CAUS_LEN); + break; + } + + /* + * Free the incoming message (both buffer and internal format) + * if necessary. + */ + if (msg) + unisig_free_msg(msg); + if (m) + KB_FREEALL(m); + + return (err); +} diff --git a/sys/netatm/uni/unisig_msg.h b/sys/netatm/uni/unisig_msg.h new file mode 100644 index 0000000..4be0144 --- /dev/null +++ b/sys/netatm/uni/unisig_msg.h @@ -0,0 +1,953 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_msg.h,v 1.8 1998/08/26 23:29:23 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * Message formatting blocks + * + */ + +#ifndef _UNI_SIG_MSG_H +#define _UNI_SIG_MSG_H + +#define UNI_MSG_DISC_Q93B 0x09 +#define UNI_MSG_MIN_LEN 9 + +/* + * Values for Q.2931 message type. + */ +#define UNI_MSG_CALP 0x02 +#define UNI_MSG_CONN 0x07 +#define UNI_MSG_CACK 0x0F +#define UNI_MSG_SETU 0x05 +#define UNI_MSG_RLSE 0x4D +#define UNI_MSG_RLSC 0x5A +#define UNI_MSG_RSTR 0x46 +#define UNI_MSG_RSTA 0x4E +#define UNI_MSG_STAT 0x7D +#define UNI_MSG_SENQ 0x75 +#define UNI_MSG_ADDP 0x80 +#define UNI_MSG_ADPA 0x81 +#define UNI_MSG_ADPR 0x82 +#define UNI_MSG_DRPP 0x83 +#define UNI_MSG_DRPA 0x84 + + +/* + * Values for information element identifier. + */ +#define UNI_IE_CAUS 0x08 +#define UNI_IE_CLST 0x14 +#define UNI_IE_EPRF 0x54 +#define UNI_IE_EPST 0x55 +#define UNI_IE_AALP 0x58 +#define UNI_IE_CLRT 0x59 +#define UNI_IE_CNID 0x5A +#define UNI_IE_QOSP 0x5C +#define UNI_IE_BHLI 0x5D +#define UNI_IE_BBCP 0x5E +#define UNI_IE_BLLI 0x5F +#define UNI_IE_BLSH 0x60 +#define UNI_IE_BNSH 0x61 +#define UNI_IE_BSDC 0x62 +#define UNI_IE_BRPI 0x63 +#define UNI_IE_CGAD 0x6C +#define UNI_IE_CGSA 0x6D +#define UNI_IE_CDAD 0x70 +#define UNI_IE_CDSA 0x71 +#define UNI_IE_TRNT 0x78 +#define UNI_IE_RSTI 0x79 + +/* + * Masks for information element extension in bit 8 + */ +#define UNI_IE_EXT_BIT 0x80 +#define UNI_IE_EXT_MASK 0x7F + + +/* + * Signalling message in internal format. + */ +#define UNI_MSG_IE_CNT 22 + +struct unisig_msg { + u_int msg_call_ref; + u_char msg_type; + u_char msg_type_flag; + u_char msg_type_action; + int msg_length; + struct ie_generic *msg_ie_vec[UNI_MSG_IE_CNT]; +}; + +#define UNI_MSG_CALL_REF_RMT 0x800000 +#define UNI_MSG_CALL_REF_MASK 0x7FFFFF +#define UNI_MSG_CALL_REF_GLOBAL 0 +#define UNI_MSG_CALL_REF_DUMMY 0x7FFFFF + +#define EXTRACT_CREF(x) \ + ((x) & UNI_MSG_CALL_REF_RMT ? (x) & UNI_MSG_CALL_REF_MASK : (x) | UNI_MSG_CALL_REF_RMT) +#define GLOBAL_CREF(x) ((x) & UNI_MSG_CALL_REF_MASK == UNI_MSG_CALL_REF_GLOBAL) +#define DUMMY_CREF(x) ((x) & UNI_MSG_CALL_REF_MASK == UNI_MSG_CALL_REF_DUMMY) + +#define UNI_MSG_TYPE_FLAG_MASK 1 +#define UNI_MSG_TYPE_FLAG_SHIFT 4 + +#define UNI_MSG_TYPE_ACT_CLEAR 0 +#define UNI_MSG_TYPE_ACT_DISC 1 +#define UNI_MSG_TYPE_ACT_RPRT 2 +#define UNI_MSG_TYPE_ACT_RSVD 3 +#define UNI_MSG_TYPE_ACT_MASK 3 + +#define UNI_MSG_IE_AALP 0 +#define UNI_MSG_IE_CLRT 1 +#define UNI_MSG_IE_BBCP 2 +#define UNI_MSG_IE_BHLI 3 +#define UNI_MSG_IE_BLLI 4 +#define UNI_MSG_IE_CLST 5 +#define UNI_MSG_IE_CDAD 6 +#define UNI_MSG_IE_CDSA 7 +#define UNI_MSG_IE_CGAD 8 +#define UNI_MSG_IE_CGSA 9 +#define UNI_MSG_IE_CAUS 10 +#define UNI_MSG_IE_CNID 11 +#define UNI_MSG_IE_QOSP 12 +#define UNI_MSG_IE_BRPI 13 +#define UNI_MSG_IE_RSTI 14 +#define UNI_MSG_IE_BLSH 15 +#define UNI_MSG_IE_BNSH 16 +#define UNI_MSG_IE_BSDC 17 +#define UNI_MSG_IE_TRNT 18 +#define UNI_MSG_IE_EPRF 19 +#define UNI_MSG_IE_EPST 20 +#define UNI_MSG_IE_ERR 21 + +#define msg_ie_aalp msg_ie_vec[UNI_MSG_IE_AALP] +#define msg_ie_clrt msg_ie_vec[UNI_MSG_IE_CLRT] +#define msg_ie_bbcp msg_ie_vec[UNI_MSG_IE_BBCP] +#define msg_ie_bhli msg_ie_vec[UNI_MSG_IE_BHLI] +#define msg_ie_blli msg_ie_vec[UNI_MSG_IE_BLLI] +#define msg_ie_clst msg_ie_vec[UNI_MSG_IE_CLST] +#define msg_ie_cdad msg_ie_vec[UNI_MSG_IE_CDAD] +#define msg_ie_cdsa msg_ie_vec[UNI_MSG_IE_CDSA] +#define msg_ie_cgad msg_ie_vec[UNI_MSG_IE_CGAD] +#define msg_ie_cgsa msg_ie_vec[UNI_MSG_IE_CGSA] +#define msg_ie_caus msg_ie_vec[UNI_MSG_IE_CAUS] +#define msg_ie_cnid msg_ie_vec[UNI_MSG_IE_CNID] +#define msg_ie_qosp msg_ie_vec[UNI_MSG_IE_QOSP] +#define msg_ie_brpi msg_ie_vec[UNI_MSG_IE_BRPI] +#define msg_ie_rsti msg_ie_vec[UNI_MSG_IE_RSTI] +#define msg_ie_blsh msg_ie_vec[UNI_MSG_IE_BLSH] +#define msg_ie_bnsh msg_ie_vec[UNI_MSG_IE_BNSH] +#define msg_ie_bsdc msg_ie_vec[UNI_MSG_IE_BSDC] +#define msg_ie_trnt msg_ie_vec[UNI_MSG_IE_TRNT] +#define msg_ie_eprf msg_ie_vec[UNI_MSG_IE_EPRF] +#define msg_ie_epst msg_ie_vec[UNI_MSG_IE_EPST] +#define msg_ie_err msg_ie_vec[UNI_MSG_IE_ERR] + + +/* + * Information element header. + */ +struct ie_hdr { + u_char ie_hdr_ident; + u_char ie_hdr_coding; + u_char ie_hdr_flag; + u_char ie_hdr_action; + int ie_hdr_length; + int ie_hdr_err_cause; + struct ie_generic *ie_hdr_next; +}; + +#define UNI_IE_HDR_LEN 4 + +#define UNI_IE_CODE_CCITT 0 +#define UNI_IE_CODE_STD 3 +#define UNI_IE_CODE_MASK 3 +#define UNI_IE_CODE_SHIFT 5 + +#define UNI_IE_FLAG_MASK 1 +#define UNI_IE_FLAG_SHIFT 4 + +#define UNI_IE_ACT_CLEAR 0 +#define UNI_IE_ACT_DIS 1 +#define UNI_IE_ACT_RPRT 2 +#define UNI_IE_ACT_DMSGIGN 5 +#define UNI_IE_ACT_DMSGRPRT 6 +#define UNI_IE_ACT_MASK 7 + + +/* + * ATM AAL parameters information element in internal format. + */ +struct ie_aalp { + int8_t ie_aal_type; + union { + struct aal_type_1_parm { + u_char subtype; + u_char cbr_rate; + u_short multiplier; + u_char clock_recovery; + u_char error_correction; + u_char struct_data_tran; + u_char partial_cells; + } type_1; + struct aal_type_4_parm { + int32_t fwd_max_sdu; + int32_t bkwd_max_sdu; + int32_t mid_range; + u_char mode; + u_char sscs_type; + } type_4; + struct aal_type_5_parm { + int32_t fwd_max_sdu; + int32_t bkwd_max_sdu; + u_char mode; + u_char sscs_type; + } type_5; + struct user_aal_type { + u_char aal_info[4]; + } type_user; + } aal_u; +}; + +#define UNI_IE_AALP_AT_AAL1 1 +#define UNI_IE_AALP_AT_AAL3 3 +#define UNI_IE_AALP_AT_AAL5 5 +#define UNI_IE_AALP_AT_AALU 16 + +#define UNI_IE_AALP_A1_ST_NULL 0 +#define UNI_IE_AALP_A1_ST_VCE 1 +#define UNI_IE_AALP_A1_ST_SCE 2 +#define UNI_IE_AALP_A1_ST_ACE 3 +#define UNI_IE_AALP_A1_ST_HQA 4 +#define UNI_IE_AALP_A1_ST_VID 5 + +#define UNI_IE_AALP_A1_CB_64 1 +#define UNI_IE_AALP_A1_CB_DS1 4 +#define UNI_IE_AALP_A1_CB_DS2 5 +#define UNI_IE_AALP_A1_CB_32064 6 +#define UNI_IE_AALP_A1_CB_DS3 7 +#define UNI_IE_AALP_A1_CB_97728 8 +#define UNI_IE_AALP_A1_CB_E1 16 +#define UNI_IE_AALP_A1_CB_E2 17 +#define UNI_IE_AALP_A1_CB_E3 18 +#define UNI_IE_AALP_A1_CB_139264 19 +#define UNI_IE_AALP_A1_CB_N64 64 + +#define UNI_IE_AALP_A1_CR_NULL 0 +#define UNI_IE_AALP_A1_CR_SRTS 1 +#define UNI_IE_AALP_A1_CR_ACR 2 + +#define UNI_IE_AALP_A1_EC_NULL 0 +#define UNI_IE_AALP_A1_EC_FEC 1 + +#define UNI_IE_AALP_A1_SD_NULL 0 +#define UNI_IE_AALP_A1_SD_SDT 1 + +#define UNI_IE_AALP_A3_R_MASK 1023 +#define UNI_IE_AALP_A3_R_SHIFT 16 + +#define UNI_IE_AALP_A5_M_MSG 1 +#define UNI_IE_AALP_A5_M_STR 2 + +#define UNI_IE_AALP_A5_ST_NULL 0 +#define UNI_IE_AALP_A5_ST_AO 1 +#define UNI_IE_AALP_A5_ST_NAO 2 +#define UNI_IE_AALP_A5_ST_FR 4 + + +/* + * ATM user cell rate information element in internal format. + */ +struct ie_clrt { + int32_t ie_fwd_peak; + int32_t ie_bkwd_peak; + int32_t ie_fwd_peak_01; + int32_t ie_bkwd_peak_01; + int32_t ie_fwd_sust; + int32_t ie_bkwd_sust; + int32_t ie_fwd_sust_01; + int32_t ie_bkwd_sust_01; + int32_t ie_fwd_burst; + int32_t ie_bkwd_burst; + int32_t ie_fwd_burst_01; + int32_t ie_bkwd_burst_01; + int8_t ie_best_effort; + int8_t ie_tm_options; +}; + +#define UNI_IE_CLRT_FWD_PEAK_ID 130 +#define UNI_IE_CLRT_BKWD_PEAK_ID 131 +#define UNI_IE_CLRT_FWD_PEAK_01_ID 132 +#define UNI_IE_CLRT_BKWD_PEAK_01_ID 133 +#define UNI_IE_CLRT_FWD_SUST_ID 136 +#define UNI_IE_CLRT_BKWD_SUST_ID 137 +#define UNI_IE_CLRT_FWD_SUST_01_ID 144 +#define UNI_IE_CLRT_BKWD_SUST_01_ID 145 +#define UNI_IE_CLRT_FWD_BURST_ID 160 +#define UNI_IE_CLRT_BKWD_BURST_ID 161 +#define UNI_IE_CLRT_FWD_BURST_01_ID 176 +#define UNI_IE_CLRT_BKWD_BURST_01_ID 177 +#define UNI_IE_CLRT_BEST_EFFORT_ID 190 +#define UNI_IE_CLRT_TM_OPTIONS_ID 191 + +#define UNI_IE_CLRT_TM_FWD_TAG 0x01 +#define UNI_IE_CLRT_TM_BKWD_TAG 0x02 + + +/* + * Broadband bearer capability information element in internal format. + */ +struct ie_bbcp { + int8_t ie_bearer_class; + int8_t ie_traffic_type; + int8_t ie_timing_req; + int8_t ie_clipping; + int8_t ie_conn_config; +}; + + +#define UNI_IE_BBCP_BC_BCOB_A 1 +#define UNI_IE_BBCP_BC_BCOB_C 3 +#define UNI_IE_BBCP_BC_BCOB_X 16 +#define UNI_IE_BBCP_BC_MASK 0x1F + +#define UNI_IE_BBCP_TT_NIND 0 +#define UNI_IE_BBCP_TT_CBR 1 +#define UNI_IE_BBCP_TT_VBR 2 +#define UNI_IE_BBCP_TT_MASK 3 +#define UNI_IE_BBCP_TT_SHIFT 2 + +#define UNI_IE_BBCP_TR_NIND 0 +#define UNI_IE_BBCP_TR_EER 1 +#define UNI_IE_BBCP_TR_EENR 2 +#define UNI_IE_BBCP_TR_RSVD 3 +#define UNI_IE_BBCP_TR_MASK 3 + +#define UNI_IE_BBCP_SC_NSUS 0 +#define UNI_IE_BBCP_SC_SUS 1 +#define UNI_IE_BBCP_SC_MASK 3 +#define UNI_IE_BBCP_SC_SHIFT 5 + +#define UNI_IE_BBCP_CC_PP 0 +#define UNI_IE_BBCP_CC_PM 1 +#define UNI_IE_BBCP_CC_MASK 3 + + +/* + * Broadband high layer information information element in internal + * format. + */ +struct ie_bhli { + int8_t ie_type; + u_char ie_info[8]; +}; + +#define UNI_IE_BHLI_TYPE_ISO 0 +#define UNI_IE_BHLI_TYPE_USER 1 +#define UNI_IE_BHLI_TYPE_HLP 2 +#define UNI_IE_BHLI_TYPE_VSA 3 + +#define UNI_IE_BHLI_HLP_LEN 4 +#define UNI_IE_BHLI_VSA_LEN 7 + + +/* + * Broadband low-layer information information element in internal + * format. + */ +struct ie_blli { + int8_t ie_l1_id; + int8_t ie_l2_id; + int8_t ie_l2_mode; + int8_t ie_l2_q933_use; + int8_t ie_l2_window; + int8_t ie_l2_user_proto; + int8_t ie_l3_id; + int8_t ie_l3_mode; + int8_t ie_l3_packet_size; + int8_t ie_l3_window; + int8_t ie_l3_user_proto; + int16_t ie_l3_ipi; + int8_t ie_l3_snap_id; + u_char ie_l3_oui[3]; + u_char ie_l3_pid[2]; +}; + +#define UNI_IE_BLLI_L1_ID 1 +#define UNI_IE_BLLI_L2_ID 2 +#define UNI_IE_BLLI_L3_ID 3 +#define UNI_IE_BLLI_LID_MASK 3 +#define UNI_IE_BLLI_LID_SHIFT 5 +#define UNI_IE_BLLI_LP_MASK 31 + +#define UNI_IE_BLLI_L2P_ISO1745 1 +#define UNI_IE_BLLI_L2P_Q921 2 +#define UNI_IE_BLLI_L2P_X25L 6 +#define UNI_IE_BLLI_L2P_X25M 7 +#define UNI_IE_BLLI_L2P_LAPB 8 +#define UNI_IE_BLLI_L2P_HDLC1 9 +#define UNI_IE_BLLI_L2P_HDLC2 10 +#define UNI_IE_BLLI_L2P_HDLC3 11 +#define UNI_IE_BLLI_L2P_LLC 12 +#define UNI_IE_BLLI_L2P_X75 13 +#define UNI_IE_BLLI_L2P_Q922 14 +#define UNI_IE_BLLI_L2P_USER 16 +#define UNI_IE_BLLI_L2P_ISO7776 17 + +#define UNI_IE_BLLI_L2MODE_NORM 1 +#define UNI_IE_BLLI_L2MODE_EXT 2 +#define UNI_IE_BLLI_L2MODE_SHIFT 5 +#define UNI_IE_BLLI_L2MODE_MASK 3 + +#define UNI_IE_BLLI_Q933_ALT 0 + +#define UNI_IE_BLLI_L3P_X25 6 +#define UNI_IE_BLLI_L3P_ISO8208 7 +#define UNI_IE_BLLI_L3P_ISO8878 8 +#define UNI_IE_BLLI_L3P_ISO8473 9 +#define UNI_IE_BLLI_L3P_T70 10 +#define UNI_IE_BLLI_L3P_ISO9577 11 +#define UNI_IE_BLLI_L3P_USER 16 + +#define UNI_IE_BLLI_L3MODE_NORM 1 +#define UNI_IE_BLLI_L3MODE_EXT 2 +#define UNI_IE_BLLI_L3MODE_SHIFT 5 +#define UNI_IE_BLLI_L3MODE_MASK 3 + +#define UNI_IE_BLLI_L3PS_16 4 +#define UNI_IE_BLLI_L3PS_32 5 +#define UNI_IE_BLLI_L3PS_64 6 +#define UNI_IE_BLLI_L3PS_128 7 +#define UNI_IE_BLLI_L3PS_256 8 +#define UNI_IE_BLLI_L3PS_512 9 +#define UNI_IE_BLLI_L3PS_1024 10 +#define UNI_IE_BLLI_L3PS_2048 11 +#define UNI_IE_BLLI_L3PS_4096 12 +#define UNI_IE_BLLI_L3PS_MASK 15 + +#define UNI_IE_BLLI_L3IPI_SHIFT 6 +#define UNI_IE_BLLI_L3IPI_SNAP 0x80 + + +/* + * Call state information element in internal format. + */ +struct ie_clst { + int8_t ie_state; +}; + +#define UNI_IE_CLST_STATE_U0 0 +#define UNI_IE_CLST_STATE_U1 1 +#define UNI_IE_CLST_STATE_U3 3 +#define UNI_IE_CLST_STATE_U6 6 +#define UNI_IE_CLST_STATE_U8 8 +#define UNI_IE_CLST_STATE_U9 9 +#define UNI_IE_CLST_STATE_U10 10 +#define UNI_IE_CLST_STATE_U11 11 +#define UNI_IE_CLST_STATE_U12 12 + +#define UNI_IE_CLST_STATE_N0 0 +#define UNI_IE_CLST_STATE_N1 1 +#define UNI_IE_CLST_STATE_N3 3 +#define UNI_IE_CLST_STATE_N6 6 +#define UNI_IE_CLST_STATE_N8 8 +#define UNI_IE_CLST_STATE_N9 9 +#define UNI_IE_CLST_STATE_N10 10 +#define UNI_IE_CLST_STATE_N11 11 +#define UNI_IE_CLST_STATE_N12 12 + +#define UNI_IE_CLST_GLBL_REST0 0x00 +#define UNI_IE_CLST_GLBL_REST1 0x3d +#define UNI_IE_CLST_GLBL_REST2 0x3e + +#define UNI_IE_CLST_STATE_MASK 0x3f + + +/* + * Called party number information element in internal format. + */ +struct ie_cdad { + int8_t ie_type; + int8_t ie_plan; + Atm_addr ie_addr; +}; + +#define UNI_IE_CDAD_TYPE_UNK 0 +#define UNI_IE_CDAD_TYPE_INTL 1 +#define UNI_IE_CDAD_TYPE_MASK 7 +#define UNI_IE_CDAD_TYPE_SHIFT 4 + +#define UNI_IE_CDAD_PLAN_E164 1 +#define UNI_IE_CDAD_PLAN_NSAP 2 +#define UNI_IE_CDAD_PLAN_MASK 15 + + +/* + * Called party subaddress information element in internal format. + */ +struct ie_cdsa { + Atm_addr ie_addr; +}; + +#define UNI_IE_CDSA_TYPE_NSAP 0 +#define UNI_IE_CDSA_TYPE_AESA 1 +#define UNI_IE_CDSA_TYPE_MASK 7 +#define UNI_IE_CDSA_TYPE_SHIFT 4 + + +/* + * Calling party number information element in internal format. + */ +struct ie_cgad { + int8_t ie_type; + int8_t ie_plan; + int8_t ie_pres_ind; + int8_t ie_screen_ind; + Atm_addr ie_addr; +}; + +#define UNI_IE_CGAD_TYPE_UNK 0 +#define UNI_IE_CGAD_TYPE_INTL 1 +#define UNI_IE_CGAD_TYPE_MASK 7 +#define UNI_IE_CGAD_TYPE_SHIFT 4 + +#define UNI_IE_CGAD_PLAN_E164 1 +#define UNI_IE_CGAD_PLAN_NSAP 2 +#define UNI_IE_CGAD_PLAN_MASK 15 + +#define UNI_IE_CGAD_PRES_ALLOW 0 +#define UNI_IE_CGAD_PRES_RSTR 1 +#define UNI_IE_CGAD_PRES_NNA 2 +#define UNI_IE_CGAD_PRES_RSVD 3 +#define UNI_IE_CGAD_PRES_MASK 3 +#define UNI_IE_CGAD_PRES_SHIFT 5 + +#define UNI_IE_CGAD_SCR_UNS 0 +#define UNI_IE_CGAD_SCR_UVP 1 +#define UNI_IE_CGAD_SCR_UVF 2 +#define UNI_IE_CGAD_SCR_NET 3 +#define UNI_IE_CGAD_SCR_MASK 3 + + +/* + * Calling party subaddress information element in internal format. + */ +struct ie_cgsa { + Atm_addr ie_addr; +}; + +#define UNI_IE_CGSA_TYPE_NSAP 0 +#define UNI_IE_CGSA_TYPE_AESA 1 +#define UNI_IE_CGSA_TYPE_MASK 7 +#define UNI_IE_CGSA_TYPE_SHIFT 4 + + +/* + * Cause information element in internal format. + */ +#define UNI_IE_CAUS_MAX_ID 24 +#define UNI_IE_CAUS_MAX_QOS_SUB 24 +struct ie_caus { + int8_t ie_loc; + int8_t ie_cause; + int8_t ie_diag_len; + u_int8_t ie_diagnostic[24]; +}; + +#define UNI_IE_CAUS_LOC_USER 0 +#define UNI_IE_CAUS_LOC_PRI_LCL 1 +#define UNI_IE_CAUS_LOC_PUB_LCL 2 +#define UNI_IE_CAUS_LOC_TRANSIT 3 +#define UNI_IE_CAUS_LOC_PUB_RMT 4 +#define UNI_IE_CAUS_LOC_PRI_RMT 5 +#define UNI_IE_CAUS_LOC_INTL 7 +#define UNI_IE_CAUS_LOC_BEYOND 10 +#define UNI_IE_CAUS_LOC_MASK 15 + +#define UNI_IE_CAUS_UN_NS_SHIFT 3 +#define UNI_IE_CAUS_UN_NS_MASK 1 + +#define UNI_IE_CAUS_UN_NA_SHIFT 2 +#define UNI_IE_CAUS_UN_NA_MASK 1 + +#define UNI_IE_CAUS_UN_CAU_MASK 3 + +#define UNI_IE_CAUS_RR_USER 0 +#define UNI_IE_CAUS_RR_IE 1 +#define UNI_IE_CAUS_RR_INSUFF 2 +#define UNI_IE_CAUS_RR_SHIFT 2 +#define UNI_IE_CAUS_RR_MASK 31 + +#define UNI_IE_CAUS_RC_UNK 0 +#define UNI_IE_CAUS_RC_PERM 1 +#define UNI_IE_CAUS_RC_TRANS 2 +#define UNI_IE_CAUS_RC_MASK 3 + +/* + * Cause codes from UNI 3.0, section 5.4.5.15 + */ +#define UNI_IE_CAUS_UNO 1 /* Unallocated number */ +#define UNI_IE_CAUS_NOTROUTE 2 /* No route to transit net */ +#define UNI_IE_CAUS_NODROUTE 3 /* No route to destination */ +#define UNI_IE_CAUS_BAD_VCC 10 /* VPI/VCI unacceptable */ +#define UNI_IE_CAUS_NORM 16 /* Normal call clearing */ +#define UNI_IE_CAUS_BUSY 17 /* User busy */ +#define UNI_IE_CAUS_NORSP 18 /* No user responding */ +#define UNI_IE_CAUS_REJECT 21 /* Call rejected */ +#define UNI_IE_CAUS_CHANGED 22 /* Number changed */ +#define UNI_IE_CAUS_CLIR 23 /* User rejects CLIR */ +#define UNI_IE_CAUS_DORDER 27 /* Dest out of order */ +#define UNI_IE_CAUS_INVNO 28 /* Invalid number format */ +#define UNI_IE_CAUS_SENQ 30 /* Rsp to Status Enquiry */ +#define UNI_IE_CAUS_NORM_UNSP 31 /* Normal, unspecified */ +#define UNI_IE_CAUS_NA_VCC 35 /* VCC not available */ +#define UNI_IE_CAUS_ASSIGN_VCC 36 /* VPCI/VCI assignment failure */ +#define UNI_IE_CAUS_NORDER 38 /* Network out of order */ +#define UNI_IE_CAUS_TEMP 41 /* Temporary failure */ +#define UNI_IE_CAUS_DISCARD 43 /* Access info discarded */ +#define UNI_IE_CAUS_NO_VCC 45 /* No VPI/VCI available */ +#define UNI_IE_CAUS_UNAVAIL 47 /* Resource unavailable */ +#define UNI_IE_CAUS_NO_QOS 49 /* QoS unavailable */ +#define UNI_IE_CAUS_NO_CR 51 /* User cell rate not avail */ +#define UNI_IE_CAUS_NO_BC 57 /* Bearer capability not auth */ +#define UNI_IE_CAUS_NA_BC 58 /* Bearer capability n/a */ +#define UNI_IE_CAUS_SERVICE 63 /* Service or opt not avail */ +#define UNI_IE_CAUS_NI_BC 65 /* Bearer cap not implemented */ +#define UNI_IE_CAUS_COMB 73 /* Unsupported combination */ +#define UNI_IE_CAUS_CREF 81 /* Invalid call reference */ +#define UNI_IE_CAUS_CEXIST 82 /* Channel does not exist */ +#define UNI_IE_CAUS_IDEST 88 /* Incompatible destination */ +#define UNI_IE_CAUS_ENDPT 89 /* Invalid endpoint reference */ +#define UNI_IE_CAUS_TRNET 91 /* Invalid transit net */ +#define UNI_IE_CAUS_APPEND 92 /* Too many pending add party */ +#define UNI_IE_CAUS_UAAL 93 /* AAL parms can't be supp */ +#define UNI_IE_CAUS_MISSING 96 /* Mandatory IE missing */ +#define UNI_IE_CAUS_MTEXIST 97 /* Message type nonexistent */ +#define UNI_IE_CAUS_IEEXIST 99 /* IE type nonexistent */ +#define UNI_IE_CAUS_IECONTENT 100 /* IE content invalid */ +#define UNI_IE_CAUS_STATE 101 /* Message incomp with state */ +#define UNI_IE_CAUS_TIMER 102 /* Recovery on timer expire */ +#define UNI_IE_CAUS_LEN 104 /* Incorrect message length */ +#define UNI_IE_CAUS_PROTO 111 /* Protocol error */ + + +/* + * Connection identifier information element in internal format. + */ +struct ie_cnid { + int8_t ie_vp_sig; + int8_t ie_pref_excl; + u_short ie_vpci; + u_short ie_vci; +}; + +#define UNI_IE_CNID_VPSIG_MASK 3 +#define UNI_IE_CNID_VPSIG_SHIFT 3 +#define UNI_IE_CNID_PREX_MASK 7 + +#define UNI_IE_CNID_MIN_VCI 32 + + +/* + * Quality of service parameter information element in internal format. + */ +struct ie_qosp { + int8_t ie_fwd_class; + int8_t ie_bkwd_class; +}; + +#define UNI_IE_QOSP_FWD_CLASS_0 0 +#define UNI_IE_QOSP_FWD_CLASS_1 1 +#define UNI_IE_QOSP_FWD_CLASS_2 2 +#define UNI_IE_QOSP_FWD_CLASS_3 3 +#define UNI_IE_QOSP_FWD_CLASS_4 4 + +#define UNI_IE_QOSP_BKWD_CLASS_0 0 +#define UNI_IE_QOSP_BKWD_CLASS_1 1 +#define UNI_IE_QOSP_BKWD_CLASS_2 2 +#define UNI_IE_QOSP_BKWD_CLASS_3 3 +#define UNI_IE_QOSP_BKWD_CLASS_4 4 + + +/* + * Broadband repeat indicator information element in internal format. + */ +struct ie_brpi { + int8_t ie_ind; +}; + +#define UNI_IE_BRPI_PRI_LIST 2 +#define UNI_IE_BRPI_IND_MASK 15 + + +/* + * Restart indicator information element in internal format. + */ +struct ie_rsti { + int8_t ie_class; +}; + +#define UNI_IE_RSTI_IND_VC 0 +#define UNI_IE_RSTI_ALL_VC 2 +#define UNI_IE_RSTI_CLASS_MASK 3 + + +/* + * Broadband locking shift information element in internal format. + */ +struct ie_blsh { + int8_t ie_dummy; +}; + + +/* + * Broadband non-locking shift information element in internal format. + */ +struct ie_bnsh { + int8_t ie_dummy; +}; + + +/* + * Broadband sending complete information element in internal format. + */ +struct ie_bsdc { + int8_t ie_ind; +}; + +#define UNI_IE_BSDC_IND 0x21 + + +/* + * Transit net selection information element in internal format. + */ +struct ie_trnt { + int8_t ie_id_type; + int8_t ie_id_plan; + u_char ie_id_len; + u_char ie_id[4]; +}; + +#define UNI_IE_TRNT_IDT_MASK 7 +#define UNI_IE_TRNT_IDT_SHIFT 4 +#define UNI_IE_TRNT_IDP_MASK 15 + +#define UNI_IE_TRNT_IDT_NATL 2 +#define UNI_IE_TRNT_IDP_CIC 1 + + +/* + * Endpoint reference information element in internal format. + */ +struct ie_eprf { + int8_t ie_type; + int16_t ie_id; +}; + +#define UNI_IE_EPRF_LDI 0 + + +/* + * Endpoint state information element in internal format. + */ +struct ie_epst { + int8_t ie_state; +}; + +#define UNI_IE_EPST_NULL 0 +#define UNI_IE_EPST_API 1 +#define UNI_IE_EPST_APR 6 +#define UNI_IE_EPST_DPI 11 +#define UNI_IE_EPST_DPR 12 +#define UNI_IE_EPST_ACTIVE 10 +#define UNI_IE_EPST_STATE_MASK 0x3F + + +/* + * Generic information element + */ +struct ie_generic { + struct ie_hdr ie_hdr; + union { + struct ie_aalp ie_aalp; + struct ie_clrt ie_clrt; + struct ie_bbcp ie_bbcp; + struct ie_bhli ie_bhli; + struct ie_blli ie_blli; + struct ie_clst ie_clst; + struct ie_cdad ie_cdad; + struct ie_cdsa ie_cdsa; + struct ie_cgad ie_cgad; + struct ie_cgsa ie_cgsa; + struct ie_caus ie_caus; + struct ie_cnid ie_cnid; + struct ie_qosp ie_qosp; + struct ie_brpi ie_brpi; + struct ie_rsti ie_rsti; + struct ie_blsh ie_blsh; + struct ie_bnsh ie_bnsh; + struct ie_bsdc ie_bsdc; + struct ie_trnt ie_trnt; + struct ie_eprf ie_eprf; + struct ie_epst ie_epst; + } ie_u; +}; + +#define ie_ident ie_hdr.ie_hdr_ident +#define ie_coding ie_hdr.ie_hdr_coding +#define ie_flag ie_hdr.ie_hdr_flag +#define ie_action ie_hdr.ie_hdr_action +#define ie_length ie_hdr.ie_hdr_length +#define ie_err_cause ie_hdr.ie_hdr_err_cause +#define ie_next ie_hdr.ie_hdr_next + +#define ie_aalp_aal_type ie_u.ie_aalp.ie_aal_type +#define ie_aalp_1_subtype ie_u.ie_aalp.aal_u.type_1.subtype +#define ie_aalp_1_cbr_rate ie_u.ie_aalp.aal_u.type_1.cbr_rate +#define ie_aalp_1_multiplier ie_u.ie_aalp.aal_u.type_1.multiplier +#define ie_aalp_1_clock_recovery ie_u.ie_aalp.aal_u.type_1.clock_recovery +#define ie_aalp_1_error_correction ie_u.ie_aalp.aal_u.type_1.error_correction +#define ie_aalp_1_struct_data_tran ie_u.ie_aalp.aal_u.type_1.struct_data_tran +#define ie_aalp_1_partial_cells ie_u.ie_aalp.aal_u.type_1.partial_cells + +#define ie_aalp_4_fwd_max_sdu ie_u.ie_aalp.aal_u.type_4.fwd_max_sdu +#define ie_aalp_4_bkwd_max_sdu ie_u.ie_aalp.aal_u.type_4.bkwd_max_sdu +#define ie_aalp_4_mid_range ie_u.ie_aalp.aal_u.type_4.mid_range +#define ie_aalp_4_mode ie_u.ie_aalp.aal_u.type_4.mode +#define ie_aalp_4_sscs_type ie_u.ie_aalp.aal_u.type_4.sscs_type + +#define ie_aalp_5_fwd_max_sdu ie_u.ie_aalp.aal_u.type_5.fwd_max_sdu +#define ie_aalp_5_bkwd_max_sdu ie_u.ie_aalp.aal_u.type_5.bkwd_max_sdu +#define ie_aalp_5_mode ie_u.ie_aalp.aal_u.type_5.mode +#define ie_aalp_5_sscs_type ie_u.ie_aalp.aal_u.type_5.sscs_type +#define ie_aalp_user_info ie_u.ie_aalp.aal_u.type_user.aal_info + +#define ie_clrt_fwd_peak ie_u.ie_clrt.ie_fwd_peak +#define ie_clrt_bkwd_peak ie_u.ie_clrt.ie_bkwd_peak +#define ie_clrt_fwd_peak_01 ie_u.ie_clrt.ie_fwd_peak_01 +#define ie_clrt_bkwd_peak_01 ie_u.ie_clrt.ie_bkwd_peak_01 +#define ie_clrt_fwd_sust ie_u.ie_clrt.ie_fwd_sust +#define ie_clrt_bkwd_sust ie_u.ie_clrt.ie_bkwd_sust +#define ie_clrt_fwd_sust_01 ie_u.ie_clrt.ie_fwd_sust_01 +#define ie_clrt_bkwd_sust_01 ie_u.ie_clrt.ie_bkwd_sust_01 +#define ie_clrt_fwd_burst ie_u.ie_clrt.ie_fwd_burst +#define ie_clrt_bkwd_burst ie_u.ie_clrt.ie_bkwd_burst +#define ie_clrt_fwd_burst_01 ie_u.ie_clrt.ie_fwd_burst_01 +#define ie_clrt_bkwd_burst_01 ie_u.ie_clrt.ie_bkwd_burst_01 +#define ie_clrt_best_effort ie_u.ie_clrt.ie_best_effort +#define ie_clrt_tm_options ie_u.ie_clrt.ie_tm_options + +#define ie_bbcp_bearer_class ie_u.ie_bbcp.ie_bearer_class +#define ie_bbcp_traffic_type ie_u.ie_bbcp.ie_traffic_type +#define ie_bbcp_timing_req ie_u.ie_bbcp.ie_timing_req +#define ie_bbcp_clipping ie_u.ie_bbcp.ie_clipping +#define ie_bbcp_conn_config ie_u.ie_bbcp.ie_conn_config + +#define ie_bhli_type ie_u.ie_bhli.ie_type +#define ie_bhli_info ie_u.ie_bhli.ie_info + +#define ie_blli_l1_id ie_u.ie_blli.ie_l1_id +#define ie_blli_l2_id ie_u.ie_blli.ie_l2_id +#define ie_blli_l2_mode ie_u.ie_blli.ie_l2_mode +#define ie_blli_l2_q933_use ie_u.ie_blli.ie_l2_q933_use +#define ie_blli_l2_window ie_u.ie_blli.ie_l2_window +#define ie_blli_l2_user_proto ie_u.ie_blli.ie_l2_user_proto +#define ie_blli_l3_id ie_u.ie_blli.ie_l3_id +#define ie_blli_l3_mode ie_u.ie_blli.ie_l3_mode +#define ie_blli_l3_packet_size ie_u.ie_blli.ie_l3_packet_size +#define ie_blli_l3_window ie_u.ie_blli.ie_l3_window +#define ie_blli_l3_user_proto ie_u.ie_blli.ie_l3_user_proto +#define ie_blli_l3_ipi ie_u.ie_blli.ie_l3_ipi +#define ie_blli_l3_snap_id ie_u.ie_blli.ie_l3_snap_id +#define ie_blli_l3_oui ie_u.ie_blli.ie_l3_oui +#define ie_blli_l3_pid ie_u.ie_blli.ie_l3_pid + +#define ie_clst_state ie_u.ie_clst.ie_state + +#define ie_cdad_type ie_u.ie_cdad.ie_type +#define ie_cdad_plan ie_u.ie_cdad.ie_plan +#define ie_cdad_addr ie_u.ie_cdad.ie_addr + +#define ie_cdsa_addr ie_u.ie_cdsa.ie_addr + +#define ie_cgad_type ie_u.ie_cgad.ie_type +#define ie_cgad_plan ie_u.ie_cgad.ie_plan +#define ie_cgad_pres_ind ie_u.ie_cgad.ie_pres_ind +#define ie_cgad_screen_ind ie_u.ie_cgad.ie_screen_ind +#define ie_cgad_addr ie_u.ie_cgad.ie_addr + +#define ie_cgsa_addr ie_u.ie_cgsa.ie_addr + +#define ie_caus_loc ie_u.ie_caus.ie_loc +#define ie_caus_cause ie_u.ie_caus.ie_cause +#define ie_caus_diag_len ie_u.ie_caus.ie_diag_len +#define ie_caus_diagnostic ie_u.ie_caus.ie_diagnostic + +#define ie_cnid_vp_sig ie_u.ie_cnid.ie_vp_sig +#define ie_cnid_pref_excl ie_u.ie_cnid.ie_pref_excl +#define ie_cnid_vpci ie_u.ie_cnid.ie_vpci +#define ie_cnid_vci ie_u.ie_cnid.ie_vci + +#define ie_qosp_fwd_class ie_u.ie_qosp.ie_fwd_class +#define ie_qosp_bkwd_class ie_u.ie_qosp.ie_bkwd_class + +#define ie_brpi_ind ie_u.ie_brpi.ie_ind + +#define ie_rsti_class ie_u.ie_rsti.ie_class + +#define ie_bsdc_ind ie_u.ie_bsdc.ie_ind + +#define ie_trnt_id_type ie_u.ie_trnt.ie_id_type +#define ie_trnt_id_plan ie_u.ie_trnt.ie_id_plan +#define ie_trnt_id_len ie_u.ie_trnt.ie_id_len +#define ie_trnt_id ie_u.ie_trnt.ie_id + +#define ie_eprf_type ie_u.ie_eprf.ie_type +#define ie_eprf_id ie_u.ie_eprf.ie_id + +#define ie_epst_state ie_u.ie_epst.ie_state + +/* + * Macro to add an IE to the end of a list of IEs + */ +#define MSG_IE_ADD(m, i, ind) \ + if (m->msg_ie_vec[ind]) { \ + struct ie_generic *_iep = msg->msg_ie_vec[ind]; \ + while (_iep->ie_next) { \ + _iep = _iep->ie_next; \ + } \ + _iep->ie_next = i; \ + } else { \ + m->msg_ie_vec[ind] = i; \ + } + +#endif /* _UNI_SIG_MSG_H */ diff --git a/sys/netatm/uni/unisig_print.c b/sys/netatm/uni/unisig_print.c new file mode 100644 index 0000000..f335ce4 --- /dev/null +++ b/sys/netatm/uni/unisig_print.c @@ -0,0 +1,877 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_print.c,v 1.9 1998/08/26 23:29:23 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * Print Q.2931 messages + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: unisig_print.c,v 1.9 1998/08/26 23:29:23 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/unisig.h> +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/unisig_msg.h> +#include <netatm/uni/unisig_print.h> + + +/* + * Local declarations + */ +struct type_name { + char *name; + u_char type; +}; + + +/* + * Local functions + */ +static char * find_type __P((struct type_name *, u_char)); +static void usp_print_atm_addr __P((Atm_addr *)); +static void usp_print_ie __P((struct ie_generic *)); +static void usp_print_ie_aalp __P((struct ie_generic *)); +static void usp_print_ie_clrt __P((struct ie_generic *)); +static void usp_print_ie_bbcp __P((struct ie_generic *)); +static void usp_print_ie_bhli __P((struct ie_generic *)); +static void usp_print_ie_blli __P((struct ie_generic *)); +static void usp_print_ie_clst __P((struct ie_generic *)); +static void usp_print_ie_cdad __P((struct ie_generic *)); +static void usp_print_ie_cdsa __P((struct ie_generic *)); +static void usp_print_ie_cgad __P((struct ie_generic *)); +static void usp_print_ie_cgsa __P((struct ie_generic *)); +static void usp_print_ie_caus __P((struct ie_generic *)); +static void usp_print_ie_cnid __P((struct ie_generic *)); +static void usp_print_ie_qosp __P((struct ie_generic *)); +static void usp_print_ie_brpi __P((struct ie_generic *)); +static void usp_print_ie_rsti __P((struct ie_generic *)); +static void usp_print_ie_blsh __P((struct ie_generic *)); +static void usp_print_ie_bnsh __P((struct ie_generic *)); +static void usp_print_ie_bsdc __P((struct ie_generic *)); +static void usp_print_ie_trnt __P((struct ie_generic *)); +static void usp_print_ie_eprf __P((struct ie_generic *)); +static void usp_print_ie_epst __P((struct ie_generic *)); + + +/* + * Values for Q.2931 message type. + */ +static struct type_name msg_types[] = { + { "Call proceeding", 0x02 }, + { "Connect", 0x07 }, + { "Connect ACK", 0x0F }, + { "Setup", 0x05 }, + { "Release", 0x4D }, + { "Release complete", 0x5A }, + { "Restart", 0x46 }, + { "Restart ACK", 0x4E }, + { "Status", 0x7D }, + { "Status enquiry", 0x75 }, + { "Add party", 0x80 }, + { "Add party ACK", 0x81 }, + { "Add party reject", 0x82 }, + { "Drop party", 0x83 }, + { "Drop party ACK", 0x84 }, + {0, 0} +}; + + +/* + * Values for information element identifier. + */ +static struct type_name ie_types[] = { + { "Cause", 0x08 }, + { "Call state", 0x14 }, + { "Endpoint reference", 0x54 }, + { "Endpoint state", 0x55 }, + { "ATM AAL parameters", 0x58 }, + { "ATM user cell rate", 0x59 }, + { "Connection ID", 0x5A }, + { "QoS parameter", 0x5C }, + { "Broadband high layer info", 0x5D }, + { "Broadband bearer capability", 0x5E }, + { "Broadband low layer info", 0x5F }, + { "Broadband locking shift", 0x60 }, + { "Broadband non-locking shift", 0x61 }, + { "Broadband sending complete", 0x62 }, + { "Broadband repeat indicator", 0x63 }, + { "Calling party number", 0x6C }, + { "Calling party subaddress", 0x6D }, + { "Called party number", 0x70 }, + { "Called party subaddress", 0x71 }, + { "Transit net selection", 0x78 }, + { "Restart indicator", 0x79 }, + { 0, 0 } +}; + + +/* + * Search a name - type translation table + * + * Arguments: + * tbl a pointer to the table to search + * type the type to look for + * + * Returns: + * name a pointer to a character string with the name + * + */ +static char * +find_type(tbl, type) + struct type_name *tbl; + u_char type; +{ + while (type != tbl->type && tbl->name) + tbl++; + + if (tbl->name) + return(tbl->name); + else + return("-"); +} + + +/* + * Print an ATM address + * + * Arguments: + * p pointer to a Atm_address + * + * Returns: + * none + * + */ +static void +usp_print_atm_addr(p) + Atm_addr *p; +{ + char *cp; + + cp = unisig_addr_print(p); + printf("%s", cp); +} + + +/* + * Print a Q.2931 message structure + * + * Arguments: + * msg pointer to the message to print + * + * Returns: + * None + * + */ +void +usp_print_msg(msg, dir) + struct unisig_msg *msg; + int dir; +{ + char *name; + int i; + struct ie_generic *ie, *inxt; + + name = find_type(msg_types, msg->msg_type); + switch (dir) { + case UNISIG_MSG_IN: + printf("Received "); + break; + case UNISIG_MSG_OUT: + printf("Sent "); + break; + } + printf("message: %s (%x)\n", name, msg->msg_type); + printf(" Call reference: 0x%x\n", msg->msg_call_ref); +#ifdef LONG_PRINT + printf(" Message type flag: 0x%x\n", msg->msg_type_flag); + printf(" Message type action: 0x%x\n", msg->msg_type_action); + printf(" Message length: %d\n", msg->msg_length); + for (i=0; i<UNI_MSG_IE_CNT; i++) { + ie = msg->msg_ie_vec[i]; + while (ie) { + inxt = ie->ie_next; + usp_print_ie(ie); + ie = inxt; + } + } +#else + for (i=0; i<UNI_MSG_IE_CNT; i++) + { + ie = msg->msg_ie_vec[i]; + while (ie) { + inxt = ie->ie_next; + name = find_type(ie_types, ie->ie_ident); + if (ie->ie_ident == UNI_IE_CAUS || + ie->ie_ident == UNI_IE_RSTI || + ie->ie_ident == UNI_IE_CLST) { + usp_print_ie(ie); + } else { + printf(" Information element: %s (0x%x)\n", + name, ie->ie_ident); + } + ie = inxt; + } + } +#endif +} + + +/* + * Print a Q.2931 information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie(ie) + struct ie_generic *ie; +{ + char *name; + + while (ie) { + name = find_type(ie_types, ie->ie_ident); + printf(" Information element: %s (0x%x)\n", + name, ie->ie_ident); +#ifdef LONG_PRINT + printf(" Coding: 0x%x\n", + ie->ie_coding); + printf(" Flag: 0x%x\n", ie->ie_flag); + printf(" Action: 0x%x\n", + ie->ie_action); + printf(" Length: %d\n", ie->ie_length); +#endif + + switch (ie->ie_ident) { + case UNI_IE_AALP: + usp_print_ie_aalp(ie); + break; + case UNI_IE_CLRT: + usp_print_ie_clrt(ie); + break; + case UNI_IE_BBCP: + usp_print_ie_bbcp(ie); + break; + case UNI_IE_BHLI: + usp_print_ie_bhli(ie); + break; + case UNI_IE_BLLI: + usp_print_ie_blli(ie); + break; + case UNI_IE_CLST: + usp_print_ie_clst(ie); + break; + case UNI_IE_CDAD: + usp_print_ie_cdad(ie); + break; + case UNI_IE_CDSA: + usp_print_ie_cdsa(ie); + break; + case UNI_IE_CGAD: + usp_print_ie_cgad(ie); + break; + case UNI_IE_CGSA: + usp_print_ie_cgsa(ie); + break; + case UNI_IE_CAUS: + usp_print_ie_caus(ie); + break; + case UNI_IE_CNID: + usp_print_ie_cnid(ie); + break; + case UNI_IE_QOSP: + usp_print_ie_qosp(ie); + break; + case UNI_IE_BRPI: + usp_print_ie_brpi(ie); + break; + case UNI_IE_RSTI: + usp_print_ie_rsti(ie); + break; + case UNI_IE_BLSH: + usp_print_ie_blsh(ie); + break; + case UNI_IE_BNSH: + usp_print_ie_bnsh(ie); + break; + case UNI_IE_BSDC: + usp_print_ie_bsdc(ie); + break; + case UNI_IE_TRNT: + usp_print_ie_trnt(ie); + break; + case UNI_IE_EPRF: + usp_print_ie_eprf(ie); + break; + case UNI_IE_EPST: + usp_print_ie_epst(ie); + break; + } + ie = ie->ie_next; + } +} + + +/* + * Print an AAL parameters information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_aalp(ie) + struct ie_generic *ie; +{ + printf(" AAL type: %d\n", ie->ie_aalp_aal_type); + switch(ie->ie_aalp_aal_type) { + case UNI_IE_AALP_AT_AAL1: + printf(" Subtype: 0x%x\n", + ie->ie_aalp_1_subtype); + printf(" CBR rate: 0x%x\n", + ie->ie_aalp_1_cbr_rate); + printf(" Multiplier: 0x%x\n", + ie->ie_aalp_1_multiplier); + printf(" Clock rcvry: 0x%x\n", + ie->ie_aalp_1_clock_recovery); + printf(" Err corr: 0x%x\n", + ie->ie_aalp_1_error_correction); + printf(" Struct data: 0x%x\n", + ie->ie_aalp_1_struct_data_tran); + printf(" Partial cells: 0x%x\n", + ie->ie_aalp_1_partial_cells); + break; + case UNI_IE_AALP_AT_AAL3: + printf(" Fwd max SDU: %d\n", + ie->ie_aalp_4_fwd_max_sdu); + printf(" Bkwd max SDU: %d\n", + ie->ie_aalp_4_bkwd_max_sdu); + printf(" MID range: %d\n", + ie->ie_aalp_4_mid_range); + printf(" Mode: 0x%x\n", + ie->ie_aalp_4_mode); + printf(" SSCS type: 0x%x\n", + ie->ie_aalp_4_sscs_type); + break; + case UNI_IE_AALP_AT_AAL5: + printf(" Fwd max SDU: %d\n", + ie->ie_aalp_5_fwd_max_sdu); + printf(" Bkwd max SDU: %d\n", + ie->ie_aalp_5_bkwd_max_sdu); + printf(" Mode: 0x%x\n", + ie->ie_aalp_5_mode); + printf(" SSCS type: 0x%x\n", + ie->ie_aalp_5_sscs_type); + break; + case UNI_IE_AALP_AT_AALU: + printf(" User info: 0x%x %x %x %x\n", + ie->ie_aalp_user_info[0], + ie->ie_aalp_user_info[1], + ie->ie_aalp_user_info[2], + ie->ie_aalp_user_info[3]); + break; + } +} + + +/* + * Print a user cell rate information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_clrt(ie) + struct ie_generic *ie; +{ + printf(" Forward peak: %d\n", ie->ie_clrt_fwd_peak); + printf(" Backward peak: %d\n", ie->ie_clrt_bkwd_peak); + printf(" Fwd peak 01: %d\n", ie->ie_clrt_fwd_peak_01); + printf(" Bkwd peak 01: %d\n", ie->ie_clrt_bkwd_peak_01); + printf(" Fwd sust: %d\n", ie->ie_clrt_fwd_sust); + printf(" Bkwd sust: %d\n", ie->ie_clrt_bkwd_sust); + printf(" Fwd sust 01: %d\n", ie->ie_clrt_fwd_sust_01); + printf(" Bkwd sust 01: %d\n", ie->ie_clrt_bkwd_sust_01); + printf(" Fwd burst: %d\n", ie->ie_clrt_fwd_burst); + printf(" Bkwd burst: %d\n", ie->ie_clrt_bkwd_burst); + printf(" Fwd burst 01: %d\n", ie->ie_clrt_fwd_burst_01); + printf(" Bkwd burst 01: %d\n", + ie->ie_clrt_bkwd_burst_01); + printf(" Best effort: %d\n", ie->ie_clrt_best_effort); + printf(" TM optons: 0x%x\n", + ie->ie_clrt_tm_options); +} + + +/* + * Print a broadband bearer capability information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_bbcp(ie) + struct ie_generic *ie; +{ + printf(" Bearer class: 0x%x\n", + ie->ie_bbcp_bearer_class); + printf(" Traffic type: 0x%x\n", + ie->ie_bbcp_traffic_type); + printf(" Timing req: 0x%x\n", + ie->ie_bbcp_timing_req); + printf(" Clipping: 0x%x\n", ie->ie_bbcp_clipping); + printf(" Conn config: 0x%x\n", + ie->ie_bbcp_conn_config); +} + + +/* + * Print a broadband high layer information information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_bhli(ie) + struct ie_generic *ie; +{ + int i; + + printf(" Type: 0x%x\n", ie->ie_bhli_type); + printf(" HL info: 0x"); + for (i=0; i<ie->ie_length-1; i++) { + printf("%x ", ie->ie_bhli_info[i]); + } + printf("\n"); +} + + +/* + * Print a broadband low-layer information information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_blli(ie) + struct ie_generic *ie; +{ + printf(" Layer 1 ID: 0x%x\n", ie->ie_blli_l1_id); + printf(" Layer 2 ID: 0x%x\n", ie->ie_blli_l2_id); + printf(" Layer 2 mode: 0x%x\n", ie->ie_blli_l2_mode); + printf(" Layer 2 Q.933: 0x%x\n", + ie->ie_blli_l2_q933_use); + printf(" Layer 2 win: 0x%x\n", + ie->ie_blli_l2_window); + printf(" Layer 2 user: 0x%x\n", + ie->ie_blli_l2_user_proto); + printf(" Layer 3 ID: 0x%x\n", ie->ie_blli_l3_id); + printf(" Layer 3 mode: 0x%x\n", ie->ie_blli_l3_mode); + printf(" Layer 3 pkt: 0x%x\n", + ie->ie_blli_l3_packet_size); + printf(" Layer 3 win: 0x%x\n", + ie->ie_blli_l3_window); + printf(" Layer 3 user: 0x%x\n", + ie->ie_blli_l3_user_proto); + printf(" Layer 3 IPI: 0x%x\n", ie->ie_blli_l3_ipi); + printf(" Layer 3 SNAP: 0x%x\n", + ie->ie_blli_l3_snap_id); + printf(" Layer 3 OUI: 0x%x %x %x\n", + ie->ie_blli_l3_oui[0], + ie->ie_blli_l3_oui[1], + ie->ie_blli_l3_oui[2]); + printf(" Layer 3 PID: 0x%x %x\n", + ie->ie_blli_l3_pid[0], + ie->ie_blli_l3_pid[1]); +} + + +/* + * Print a call state information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_clst(ie) + struct ie_generic *ie; +{ + printf(" Call state: %d\n", + ie->ie_clst_state); +} + + +/* + * Print a called party number information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_cdad(ie) + struct ie_generic *ie; +{ + printf(" ATM addr: "); + usp_print_atm_addr(&ie->ie_cdad_addr); + printf("\n"); +} + + +/* + * Print a called party subaddress information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_cdsa(ie) + struct ie_generic *ie; +{ + printf(" ATM subaddr: "); + usp_print_atm_addr(&ie->ie_cdsa_addr); + printf("\n"); +} + + +/* + * Print a calling party number information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_cgad(ie) + struct ie_generic *ie; +{ + printf(" ATM addr: "); + usp_print_atm_addr(&ie->ie_cgad_addr); + printf("\n"); +} + + +/* + * Print a calling party subaddress information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_cgsa(ie) + struct ie_generic *ie; +{ + printf(" ATM subaddr: "); + usp_print_atm_addr(&ie->ie_cgsa_addr); + printf("\n"); +} + + +/* + * Print a cause information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_caus(ie) + struct ie_generic *ie; +{ + int i; + + printf(" Location: %d\n", ie->ie_caus_loc); + printf(" Cause: %d\n", ie->ie_caus_cause); + switch(ie->ie_caus_cause) { + case UNI_IE_CAUS_IECONTENT: + printf(" Flagged IEs: "); + for (i=0; ie->ie_caus_diagnostic[i]; i++) { + printf("0x%x ", ie->ie_caus_diagnostic[i]); + } + printf("\n"); + break; + case UNI_IE_CAUS_TIMER: + printf(" Timer ID: %c%c%c\n", + ie->ie_caus_diagnostic[0], + ie->ie_caus_diagnostic[1], + ie->ie_caus_diagnostic[2]); + break; + default: + printf(" Diag length: %d\n", + ie->ie_caus_diag_len); + printf(" Diagnostic: "); + for (i=0; i<ie->ie_caus_diag_len; i++) { + printf("0x%x ", ie->ie_caus_diagnostic[i]); + } + printf("\n"); + } +} + + +/* + * Print a connection identifier information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_cnid(ie) + struct ie_generic *ie; +{ + printf(" VP assoc sig: 0x%x\n", ie->ie_cnid_vp_sig); + printf(" Pref/excl: 0x%x\n", + ie->ie_cnid_pref_excl); + printf(" VPCI: %d\n", ie->ie_cnid_vpci); + printf(" VCI: %d\n", ie->ie_cnid_vci); +} + + +/* + * Print a quality of service parameter information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_qosp(ie) + struct ie_generic *ie; +{ + printf(" QoS fwd: 0x%x\n", + ie->ie_qosp_fwd_class); + printf(" QoS bkwd: 0x%x\n", + ie->ie_qosp_bkwd_class); +} + + +/* + * Print a broadband repeat indicator information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_brpi(ie) + struct ie_generic *ie; +{ + printf(" Indicator: 0x%x\n", ie->ie_brpi_ind); +} + + +/* + * Print a restart indicator information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_rsti(ie) + struct ie_generic *ie; +{ + printf(" Class: 0x%x\n", ie->ie_rsti_class); +} + + +/* + * Print a broadband locking shift information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_blsh(ie) + struct ie_generic *ie; +{ +} + + +/* + * Print a broadband non-locking shift information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_bnsh(ie) + struct ie_generic *ie; +{ +} + + +/* + * Print a broadband sending complete information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_bsdc(ie) + struct ie_generic *ie; +{ + printf(" Indication: 0x%x\n", ie->ie_bsdc_ind); +} + + +/* + * Print a transit net selection information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_trnt(ie) + struct ie_generic *ie; +{ +#ifdef NOTDEF + struct ie_generic ie_trnt_hdr; + u_char ie_trnt_id_type; + u_char ie_trnt_id_plan; + Atm_addr ie_trnt_id; +#endif +} + + +/* + * Print an endpoint reference information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_eprf(ie) + struct ie_generic *ie; +{ + printf(" Ref type: 0x%x\n", + ie->ie_eprf_type); + printf(" Endpt ref: 0x%x\n", + ie->ie_eprf_id); +} + + +/* + * Print an endpoint state information element + * + * Arguments: + * ie pointer to the IE to print + * + * Returns: + * None + * + */ +static void +usp_print_ie_epst(ie) + struct ie_generic *ie; +{ + printf(" Endpt state: %d\n", + ie->ie_epst_state); +} diff --git a/sys/netatm/uni/unisig_print.h b/sys/netatm/uni/unisig_print.h new file mode 100644 index 0000000..5e906c8 --- /dev/null +++ b/sys/netatm/uni/unisig_print.h @@ -0,0 +1,47 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_print.h,v 1.2 1997/05/06 22:22:27 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * Protocol control blocks + * + */ + +#ifndef _UNISIG_PRINT_H +#define _UNISIG_PRINT_H + +/* + * Message direction for print routine + */ +#define UNISIG_MSG_IN 1 +#define UNISIG_MSG_OUT 2 + +#endif /* _UNISIG_PRINT_H */ diff --git a/sys/netatm/uni/unisig_proto.c b/sys/netatm/uni/unisig_proto.c new file mode 100644 index 0000000..914e76d --- /dev/null +++ b/sys/netatm/uni/unisig_proto.c @@ -0,0 +1,324 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_proto.c,v 1.9 1998/08/26 23:29:23 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * Protocol processing module. + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: unisig_proto.c,v 1.9 1998/08/26 23:29:23 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/unisig.h> +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/unisig_msg.h> +#include <netatm/uni/unisig_mbuf.h> + + +/* + * Process a UNISIG timeout + * + * Called when a previously scheduled protocol instance control block + * timer expires. This routine passes a timeout event to the UNISIG + * signalling manager state machine. + * + * Called at splnet. + * + * Arguments: + * tip pointer to UNISIG timer control block + * + * Returns: + * none + * + */ +void +unisig_timer(tip) + struct atm_time *tip; +{ + struct unisig *usp; + + /* + * Back-off to UNISIG control block + */ + usp = (struct unisig *) + ((caddr_t)tip - (int)(&((struct unisig *)0)->us_time)); + + ATM_DEBUG2("unisig_timer: usp=0x%x,state=%d\n", + (int)usp, usp->us_state); + + /* + * Pass the timeout to the signalling manager state machine + */ + (void) unisig_sigmgr_state(usp, + UNISIG_SIGMGR_TIMEOUT, + (KBuffer *) 0); +} + + +/* + * Process a UNISIG VCC timeout + * + * Called when a previously scheduled UNISIG VCCB timer expires. + * Processing will based on the current VCC state. + * + * Called at splnet. + * + * Arguments: + * tip pointer to vccb timer control block + * + * Returns: + * none + * + */ +void +unisig_vctimer(tip) + struct atm_time *tip; +{ + struct unisig *usp; + struct unisig_vccb *uvp; + + /* + * Get VCCB and UNISIG control block addresses + */ + uvp = (struct unisig_vccb *) ((caddr_t)tip - + (int)(&((struct vccb *)0)->vc_time)); + usp = (struct unisig *)uvp->uv_pif->pif_siginst; + + ATM_DEBUG3("unisig_vctimer: uvp=0x%x, sstate=%d, ustate=%d\n", + (int)uvp, uvp->uv_sstate, uvp->uv_ustate); + + /* + * Hand the timeout to the VC finite state machine + */ + if (uvp->uv_ustate == VCCU_ABORT) { + /* + * If we're aborting, this is an ABORT call + */ + (void) unisig_vc_state(usp, uvp, UNI_VC_ABORT_CALL, + (struct unisig_msg *) 0); + } else { + /* + * If we're not aborting, it's a timeout + */ + (void) unisig_vc_state(usp, uvp, UNI_VC_TIMEOUT, + (struct unisig_msg *) 0); + } +} + + +/* + * UNISIG SAAL Control Handler + * + * This is the module which receives data on the UNISIG signalling + * channel. Processing is based on the indication received from the + * SSCF and the protocol state. + * + * Arguments: + * cmd command code + * tok session token (pointer to UNISIG protocol control block) + * a1 argument 1 + * + * Returns: + * none + * + */ +void +unisig_saal_ctl(cmd, tok, a1) + int cmd; + void *tok; + void *a1; +{ + struct unisig *usp = tok; + + ATM_DEBUG4("unisig_upper: usp=0x%x,state=%d,cmd=%d,a1=0x%x,\n", + (u_long)usp, usp->us_state, cmd, (u_long)a1); + + /* + * Process command + */ + switch (cmd) { + + case SSCF_UNI_ESTABLISH_IND: + (void) unisig_sigmgr_state(usp, + UNISIG_SIGMGR_SSCF_EST_IND, + (KBuffer *) 0); + break; + + case SSCF_UNI_ESTABLISH_CNF: + (void) unisig_sigmgr_state(usp, + UNISIG_SIGMGR_SSCF_EST_CNF, + (KBuffer *) 0); + break; + + case SSCF_UNI_RELEASE_IND: + (void) unisig_sigmgr_state(usp, + UNISIG_SIGMGR_SSCF_RLS_IND, + (KBuffer *) 0); + break; + + case SSCF_UNI_RELEASE_CNF: + (void) unisig_sigmgr_state(usp, + UNISIG_SIGMGR_SSCF_RLS_CNF, + (KBuffer *) 0); + break; + + default: + log(LOG_ERR, + "unisig: unknown SAAL cmd: usp=0x%x, state=%d, cmd=%d\n", + (int)usp, usp->us_state, cmd); + } +} + + +/* + * UNISIG SAAL Data Handler + * + * This is the module which receives data on the UNISIG signalling + * channel. Processing is based on the protocol state. + * + * Arguments: + * tok session token (pointer to UNISIG protocol control block) + * m pointer to data + * + * Returns: + * none + * + */ +void +unisig_saal_data(tok, m) + void *tok; + KBuffer *m; +{ + struct unisig *usp = tok; + + ATM_DEBUG3("unisig_saal_data: usp=0x%x,state=%d,m=0x%x,\n", + (int)usp, usp->us_state, m); + + /* + * Pass data to signalling manager state machine + */ + (void) unisig_sigmgr_state(usp, + UNISIG_SIGMGR_SSCF_DATA_IND, + m); +} + + +/* + * Get Connection's Application/Owner Name + * + * Arguments: + * tok UNI signalling connection token (pointer to protocol instance) + * + * Returns: + * addr pointer to string containing our name + * + */ +caddr_t +unisig_getname(tok) + void *tok; +{ + struct unisig *usp = tok; + + if (usp->us_proto == ATM_SIG_UNI30) + return ("UNI3.0"); + else if (usp->us_proto == ATM_SIG_UNI31) + return ("UNI3.1"); + else if (usp->us_proto == ATM_SIG_UNI40) + return ("UNI4.0"); + else + return ("UNI"); +} + + +/* + * Process a VCC connection notification + * + * Should never be called. + * + * Arguments: + * tok user's connection token (unisig protocol block) + * + * Returns: + * none + * + */ +void +unisig_connected(tok) + void *tok; +{ + struct unisig *usp = tok; + + ATM_DEBUG2("unisig_connected: usp=0x%x,state=%d\n", + (u_long)usp, usp->us_state); + + /* + * Connected routine shouldn't ever get called for a PVC + */ + log(LOG_ERR, "unisig: connected notification, usp=0x%x\n", + (u_long)usp); +} + + +/* + * Process a VCC closed notification + * + * Called when UNISIG signalling channel is closed. + * + * Arguments: + * tok user's connection token (unisig protocol block) + * cp pointer to cause structure + * + * Returns: + * none + * + */ +void +unisig_cleared(tok, cp) + void *tok; + struct t_atm_cause *cp; +{ + struct unisig *usp = tok; + + ATM_DEBUG3("unisig_cleared: usp=0x%x, state=%d, cause=%d\n", + (u_long)usp, usp->us_state, cp->cause_value); + + /* + * VCC has been closed. Notify the signalling + * manager state machine. + */ + (void) unisig_sigmgr_state(usp, + UNISIG_SIGMGR_CALL_CLEARED, + (KBuffer *) 0); +} diff --git a/sys/netatm/uni/unisig_sigmgr_state.c b/sys/netatm/uni/unisig_sigmgr_state.c new file mode 100644 index 0000000..2fbbfca --- /dev/null +++ b/sys/netatm/uni/unisig_sigmgr_state.c @@ -0,0 +1,860 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_sigmgr_state.c,v 1.10 1998/08/26 23:29:24 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * Signalling manager finite state machine + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: unisig_sigmgr_state.c,v 1.10 1998/08/26 23:29:24 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/uni.h> +#include <netatm/uni/unisig.h> +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/unisig_msg.h> +#include <netatm/uni/unisig_mbuf.h> +#include <netatm/uni/unisig_decode.h> + +#include <netatm/uni/sscf_uni.h> + + +/* + * Local functions + */ +static int unisig_sigmgr_invalid __P((struct unisig *, KBuffer *)); +static int unisig_sigmgr_act01 __P((struct unisig *, KBuffer *)); +static int unisig_sigmgr_act02 __P((struct unisig *, KBuffer *)); +static int unisig_sigmgr_act03 __P((struct unisig *, KBuffer *)); +static int unisig_sigmgr_act04 __P((struct unisig *, KBuffer *)); +static int unisig_sigmgr_act05 __P((struct unisig *, KBuffer *)); +static int unisig_sigmgr_act06 __P((struct unisig *, KBuffer *)); +static int unisig_sigmgr_act07 __P((struct unisig *, KBuffer *)); +static int unisig_sigmgr_act08 __P((struct unisig *, KBuffer *)); +static int unisig_sigmgr_act09 __P((struct unisig *, KBuffer *)); +static int unisig_sigmgr_act10 __P((struct unisig *, KBuffer *)); +static int unisig_sigmgr_act11 __P((struct unisig *, KBuffer *)); +static int unisig_sigmgr_act12 __P((struct unisig *, KBuffer *)); +static int unisig_sigmgr_act13 __P((struct unisig *, KBuffer *)); +static int unisig_sigmgr_act14 __P((struct unisig *, KBuffer *)); + + +/* + * State table. + */ +static int sigmgr_state_table[10][7] = { + /* 0 1 2 3 4 5 */ + { 1, 0, 0, 0, 0 }, /* 0 - Time out */ + { 0, 0, 3, 5, 0 }, /* 1 - SSCF estab ind */ + { 0, 0, 3, 5, 0 }, /* 2 - SSCF estab cnf */ + { 0, 0, 4, 6, 0 }, /* 3 - SSCF release ind */ + { 0, 0, 0, 6, 0 }, /* 4 - SSCF release cnf */ + { 0, 0, 0, 7, 0 }, /* 5 - SSCF data ind */ + { 0, 0, 2, 2, 0 }, /* 6 - SSCF unit data ind */ + { 0, 0, 8, 8, 8 }, /* 7 - Call cleared */ + { 14, 14, 14, 14, 0 }, /* 8 - Detach */ + { 13, 13, 0, 0, 0 } /* 9 - Address set */ +}; + +/* + * Action vector + */ +#define MAX_ACTION 15 +static int (*unisig_sigmgr_act_vec[MAX_ACTION]) + __P((struct unisig *, KBuffer *)) = { + unisig_sigmgr_invalid, + unisig_sigmgr_act01, + unisig_sigmgr_act02, + unisig_sigmgr_act03, + unisig_sigmgr_act04, + unisig_sigmgr_act05, + unisig_sigmgr_act06, + unisig_sigmgr_act07, + unisig_sigmgr_act08, + unisig_sigmgr_act09, + unisig_sigmgr_act10, + unisig_sigmgr_act11, + unisig_sigmgr_act12, + unisig_sigmgr_act13, + unisig_sigmgr_act14 +}; + + +/* + * ATM endpoint for UNI signalling channel + */ +static Atm_endpoint unisig_endpt = { + NULL, /* ep_next */ + ENDPT_UNI_SIG, /* ep_id */ + NULL, /* ep_ioctl */ + unisig_getname, /* ep_getname */ + unisig_connected, /* ep_connected */ + unisig_cleared, /* ep_cleared */ + NULL, /* ep_incoming */ + NULL, /* ep_addparty */ + NULL, /* ep_dropparty */ + NULL, /* ep_cpcs_ctl */ + NULL, /* ep_cpcs_data */ + unisig_saal_ctl, /* ep_saal_ctl */ + unisig_saal_data, /* ep_saal_data */ + NULL, /* ep_sscop_ctl */ + NULL /* ep_sscop_data */ +}; + + +/* + * ATM connection attributes for UNI signalling channel + */ +static Atm_attributes unisig_attr = { + NULL, /* nif */ + CMAPI_SAAL, /* api */ + UNI_VERS_3_0, /* api_init */ + 0, /* headin */ + 0, /* headout */ + { /* aal */ + T_ATM_PRESENT, /* aal.tag */ + ATM_AAL5 /* aal.aal_type */ + }, + { /* traffic */ + T_ATM_PRESENT, /* traffic.tag */ + { /* traffic.v */ + { /* traffic.v.forward */ + T_ATM_ABSENT, /* PCR_high */ + 0, /* PCR_all */ + T_ATM_ABSENT, /* SCR_high */ + T_ATM_ABSENT, /* SCR_all */ + T_ATM_ABSENT, /* MBS_high */ + T_ATM_ABSENT, /* MBS_all */ + T_NO, /* tagging */ + }, + { /* traffic.v.backward */ + T_ATM_ABSENT, /* PCR_high */ + 0, /* PCR_all */ + T_ATM_ABSENT, /* SCR_high */ + T_ATM_ABSENT, /* SCR_all */ + T_ATM_ABSENT, /* MBS_high */ + T_ATM_ABSENT, /* MBS_all */ + T_NO, /* tagging */ + }, + T_YES, /* best_effort */ + } + }, + { /* bearer */ + T_ATM_PRESENT, /* bearer.tag */ + { /* bearer.v */ + T_ATM_CLASS_X, /* class */ + T_ATM_NULL, /* traffic_type */ + T_ATM_NO_END_TO_END, /* timing_req */ + T_NO, /* clipping */ + T_ATM_1_TO_1, /* conn_conf */ + } + }, + { /* bhli */ + T_ATM_ABSENT, /* bhli.tag */ + }, + { /* blli */ + T_ATM_ABSENT, /* blli.tag_l2 */ + T_ATM_ABSENT, /* blli.tag_l3 */ + }, + { /* llc */ + T_ATM_ABSENT, /* llc.tag */ + }, + { /* called */ + T_ATM_PRESENT, /* called.tag */ + }, + { /* calling */ + T_ATM_ABSENT, /* calling.tag */ + }, + { /* qos */ + T_ATM_PRESENT, /* qos.tag */ + { /* qos.v */ + T_ATM_NETWORK_CODING, /* coding_standard */ + { /* qos.v.forward */ + T_ATM_QOS_CLASS_0, /* class */ + }, + { /* qos.v.backward */ + T_ATM_QOS_CLASS_0, /* class */ + } + } + }, + { /* transit */ + T_ATM_ABSENT, /* transit.tag */ + }, + { /* cause */ + T_ATM_ABSENT, /* cause.tag */ + } +}; + + +/* + * Finite state machine for the UNISIG signalling manager + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * event indication of the event to be processed + * m pointer to a buffer with a message (optional) + * + * Returns: + * 0 success + * errno error encountered + * + */ +int +unisig_sigmgr_state(usp, event, m) + struct unisig *usp; + int event; + KBuffer *m; +{ + int action, err = 0; + + /* + * Cancel any signalling manager timer + */ + UNISIG_CANCEL(usp); + + /* + * Select an action based on the incoming event and + * the signalling manager's state + */ + action = sigmgr_state_table[event][usp->us_state]; + ATM_DEBUG4("unisig_sigmgr_state: usp=0x%x, state=%d, event=%d, action=%d\n", + (u_int) usp, usp->us_state, event, action); + if (action >= MAX_ACTION || action < 0) { + panic("unisig_sigmgr_state: invalid action\n"); + } + + /* + * Perform the requested action + */ + err = unisig_sigmgr_act_vec[action](usp, m); + + return(err); +} + + +/* + * Signalling manager state machine action 0 + * + * Invalid action + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * m buffer pointer (may be NULL) + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_sigmgr_invalid(usp, m) + struct unisig *usp; + KBuffer *m; +{ + log(LOG_ERR, "unisig_sigmgr_state: unexpected action\n"); + if (m) + KB_FREEALL(m); + return(0); +} + + +/* + * Signalling manager state machine action 1 + * + * The kickoff timer has expired at attach time; go to + * UNISIG_ADDR_WAIT state. + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * m buffer pointer (may be NULL) + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_sigmgr_act01(usp, m) + struct unisig *usp; + KBuffer *m; +{ + /* + * Set the new state + */ + usp->us_state = UNISIG_ADDR_WAIT; + + return(0); +} + + +/* + * Signalling manager state machine action 2 + * + * Ignore the event + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * m buffer pointer (may be NULL) + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_sigmgr_act02(usp, m) + struct unisig *usp; + KBuffer *m; +{ + /* + * Ignore event, discard message if present + */ + if (m) + KB_FREEALL(m); + + return(0); +} + + +/* + * Signalling manager state machine action 3 + * + * SSCF session on signalling channel has come up + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * m buffer pointer (may be NULL) + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_sigmgr_act03(usp, m) + struct unisig *usp; + KBuffer *m; +{ + struct unisig_vccb *uvp, *vnext; + + /* + * Log the activation + */ + log(LOG_INFO, "unisig: signalling channel active\n"); + + /* + * Go to ACTIVE state + */ + usp->us_state = UNISIG_ACTIVE; + + /* + * Notify the VC state machine that the channel is up + */ + for (uvp = Q_HEAD(usp->us_vccq, struct unisig_vccb); + uvp; uvp = vnext) { + vnext = Q_NEXT(uvp, struct unisig_vccb, uv_sigelem); + (void) unisig_vc_state(usp, uvp, UNI_VC_SAAL_ESTAB, + (struct unisig_msg *) 0); + } + + return(0); +} + + +/* + * Signalling manager state machine action 4 + * + * A SSCF release indication was received. Try to establish an + * SSCF session on the signalling PVC. + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * m buffer pointer (may be NULL) + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_sigmgr_act04(usp, m) + struct unisig *usp; + KBuffer *m; +{ + int err; + + /* + * Try to establish an SSCF session. + */ + err = atm_cm_saal_ctl(SSCF_UNI_ESTABLISH_REQ, + usp->us_conn, + (void *)0); + if (err) + panic("unisig_sigmgr_act04: SSCF_UNI_ESTABLISH_REQ"); + + return(0); +} + + +/* + * Signalling manager state machine action 5 + * + * SSCF session on signalling channel has been reset + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * m buffer pointer (may be NULL) + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_sigmgr_act05(usp, m) + struct unisig *usp; + KBuffer *m; +{ + struct unisig_vccb *uvp, *vnext; + + /* + * Log the reset + */ + log(LOG_INFO, "unisig: signalling channel reset\n"); + + /* + * Notify the VC state machine of the reset + */ + for (uvp = Q_HEAD(usp->us_vccq, struct unisig_vccb); + uvp; uvp = vnext) { + vnext = Q_NEXT(uvp, struct unisig_vccb, uv_sigelem); + (void) unisig_vc_state(usp, uvp, UNI_VC_SAAL_ESTAB, + (struct unisig_msg *) 0); + } + + return(0); +} + + +/* + * Signalling manager state machine action 6 + * + * SSCF session on signalling channel has been lost + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * m buffer pointer (may be NULL) + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_sigmgr_act06(usp, m) + struct unisig *usp; + KBuffer *m; +{ + struct unisig_vccb *uvp, *vnext; + + /* + * Log the fact that the session has been lost + */ + log(LOG_INFO, "unisig: signalling channel SSCF session lost\n"); + + /* + * Notify the VC state machine of the loss + */ + for (uvp = Q_HEAD(usp->us_vccq, struct unisig_vccb); + uvp; uvp = vnext) { + vnext = Q_NEXT(uvp, struct unisig_vccb, uv_sigelem); + (void) unisig_vc_state(usp, uvp, UNI_VC_SAAL_FAIL, + (struct unisig_msg *) 0); + } + + /* + * Try to restart the SSCF session + */ + (void) unisig_sigmgr_act04(usp, (KBuffer *) 0); + + /* + * Go to INIT state + */ + usp->us_state = UNISIG_INIT; + + return(0); +} + + +/* + * Signalling manager state machine action 7 + * + * A Q.2931 signalling message has been received + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * m buffer pointer (may be NULL) + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_sigmgr_act07(usp, m) + struct unisig *usp; + KBuffer *m; +{ + int err; + + /* + * Pass the Q.2931 signalling message on + * to the VC state machine + */ + err = unisig_rcv_msg(usp, m); + + return(err); +} + + +/* + * Signalling manager state machine action 8 + * + * Process a CALL_CLOSED event for the signalling PVC + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * m buffer pointer (may be NULL) + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_sigmgr_act08(usp, m) + struct unisig *usp; + KBuffer *m; +{ + + /* + * Signalling manager is now incommunicado + */ + if (usp->us_state != UNISIG_DETACH) { + /* + * Log an error and set the state to NULL if + * we're not detaching + */ + log(LOG_ERR, "unisig: signalling channel closed\n"); + usp->us_state = UNISIG_NULL; + } + usp->us_conn = 0; + + return(0); +} + + +/* + * Signalling manager state machine action 9 + * + * Not used + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * m buffer pointer (may be NULL) + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_sigmgr_act09(usp, m) + struct unisig *usp; + KBuffer *m; +{ + log(LOG_ERR, "unisig_sigmgr_act09: unexpected action\n"); + if (m) + KB_FREEALL(m); + return (0); +} + + +/* + * Signalling manager state machine action 10 + * + * Not used + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * m buffer pointer (may be NULL) + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_sigmgr_act10(usp, m) + struct unisig *usp; + KBuffer *m; +{ + return(0); +} + + +/* + * Signalling manager state machine action 11 + * + * Not used + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * m buffer pointer (may be NULL) + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_sigmgr_act11(usp, m) + struct unisig *usp; + KBuffer *m; +{ + log(LOG_ERR, "unisig_sigmgr_act11: unexpected action\n"); + if (m) + KB_FREEALL(m); + return(0); +} + + +/* + * Signalling manager state machine action 12 + * + * Not used + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * m buffer pointer (may be NULL) + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_sigmgr_act12(usp, m) + struct unisig *usp; + KBuffer *m; +{ + log(LOG_ERR, "unisig_sigmgr_act11: unexpected action\n"); + if (m) + KB_FREEALL(m); + return(0); +} + + +/* + * Signalling manager state machine action 13 + * + * NSAP prefix has been set + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * m buffer pointer (may be NULL) + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_sigmgr_act13(usp, m) + struct unisig *usp; + KBuffer *m; +{ + int err; + Atm_addr_pvc *pvcp; + + /* + * Set UNI signalling channel connection attributes + */ + if (usp->us_proto == ATM_SIG_UNI30) + unisig_attr.api_init = UNI_VERS_3_0; + else + unisig_attr.api_init = UNI_VERS_3_1; + + unisig_attr.nif = usp->us_pif->pif_nif; + + unisig_attr.aal.v.aal5.forward_max_SDU_size = ATM_NIF_MTU; + unisig_attr.aal.v.aal5.backward_max_SDU_size = ATM_NIF_MTU; + unisig_attr.aal.v.aal5.SSCS_type = T_ATM_SSCS_SSCOP_REL; + + unisig_attr.called.tag = T_ATM_PRESENT; + unisig_attr.called.addr.address_format = T_ATM_PVC_ADDR; + unisig_attr.called.addr.address_length = sizeof(Atm_addr_pvc); + pvcp = (Atm_addr_pvc *)unisig_attr.called.addr.address; + ATM_PVC_SET_VPI(pvcp, UNISIG_SIG_VPI); + ATM_PVC_SET_VCI(pvcp, UNISIG_SIG_VCI); + unisig_attr.called.subaddr.address_format = T_ATM_ABSENT; + unisig_attr.called.subaddr.address_length = 0; + + unisig_attr.traffic.v.forward.PCR_all_traffic = + usp->us_pif->pif_pcr; + unisig_attr.traffic.v.backward.PCR_all_traffic = + usp->us_pif->pif_pcr; + + /* + * Create UNISIG signalling channel + */ + err = atm_cm_connect(&unisig_endpt, usp, &unisig_attr, + &usp->us_conn); + if (err) { + return(err); + } + + /* + * Establish the SSCF session + */ + err = atm_cm_saal_ctl(SSCF_UNI_ESTABLISH_REQ, + usp->us_conn, + (void *)0); + if (err) + panic("unisig_sigmgr_act13: SSCF_UNI_ESTABLISH_REQ"); + + /* + * Set the new state + */ + usp->us_state = UNISIG_INIT; + + return(0); +} + + +/* + * Signalling manager state machine action 14 + * + * Process a detach event + * + * Arguments: + * usp pointer to the UNISIG protocol control block + * m buffer pointer (may be NULL) + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_sigmgr_act14(usp, m) + struct unisig *usp; + KBuffer *m; +{ + int err; + struct unisig_vccb *sig_vccb, *uvp, *vnext; + struct atm_pif *pip; + struct t_atm_cause cause; + + /* + * Locate the signalling channel's VCCB + */ + sig_vccb = (struct unisig_vccb *)0; + if (usp->us_conn && usp->us_conn->co_connvc) + sig_vccb = (struct unisig_vccb *) + usp->us_conn->co_connvc->cvc_vcc; + + /* + * Terminate all of our VCCs + */ + for (uvp = Q_HEAD(usp->us_vccq, struct unisig_vccb); + uvp; uvp = vnext) { + vnext = Q_NEXT(uvp, struct unisig_vccb, uv_sigelem); + + /* + * Don't close the signalling VCC yet + */ + if (uvp == sig_vccb) + continue; + + /* + * Close VCC and notify owner + */ + err = unisig_clear_vcc(usp, uvp, + T_ATM_CAUSE_NORMAL_CALL_CLEARING); + } + + /* + * Set the signalling manager state + */ + usp->us_state = UNISIG_DETACH; + + /* + * Close the signalling channel + */ + if (usp->us_conn) { + cause.coding_standard = T_ATM_ITU_CODING; + cause.coding_standard = T_ATM_LOC_USER; + cause.coding_standard = T_ATM_CAUSE_UNSPECIFIED_NORMAL; + err = atm_cm_release(usp->us_conn, &cause); + if (err) + panic("unisig_sigmgr_act14: close failed\n"); + } + + /* + * Get rid of protocol instance if there are no VCCs queued + */ + pip = usp->us_pif; + if (Q_HEAD(usp->us_vccq, struct vccb) == NULL && + pip->pif_sigmgr) { + struct sigmgr *smp = pip->pif_sigmgr; + int s = splimp(); + + pip->pif_sigmgr = NULL; + pip->pif_siginst = NULL; + (void) splx(s); + + UNLINK((struct siginst *)usp, struct siginst, + smp->sm_prinst, si_next); + KM_FREE(usp, sizeof(struct unisig), M_DEVBUF); + } + + /* + * Otherwise, wait for protocol instance to be freed + * during unisig_free processing for the last queued VCC + */ + + return (0); +} diff --git a/sys/netatm/uni/unisig_subr.c b/sys/netatm/uni/unisig_subr.c new file mode 100644 index 0000000..f8dc067 --- /dev/null +++ b/sys/netatm/uni/unisig_subr.c @@ -0,0 +1,1276 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_subr.c,v 1.12 1998/08/26 23:29:24 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * Subroutines + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: unisig_subr.c,v 1.12 1998/08/26 23:29:24 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/unisig.h> +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/unisig_msg.h> + + +/* + * External variables + */ +extern struct ie_aalp ie_aalp_absent; +extern struct ie_clrt ie_clrt_absent; +extern struct ie_bbcp ie_bbcp_absent; +extern struct ie_bhli ie_bhli_absent; +extern struct ie_blli ie_blli_absent; +extern struct ie_clst ie_clst_absent; +extern struct ie_cdad ie_cdad_absent; +extern struct ie_cdsa ie_cdsa_absent; +extern struct ie_cgad ie_cgad_absent; +extern struct ie_cgsa ie_cgsa_absent; +extern struct ie_caus ie_caus_absent; +extern struct ie_cnid ie_cnid_absent; +extern struct ie_qosp ie_qosp_absent; +extern struct ie_brpi ie_brpi_absent; +extern struct ie_rsti ie_rsti_absent; +extern struct ie_blsh ie_blsh_absent; +extern struct ie_bnsh ie_bnsh_absent; +extern struct ie_bsdc ie_bsdc_absent; +extern struct ie_trnt ie_trnt_absent; +extern struct ie_eprf ie_eprf_absent; +extern struct ie_epst ie_epst_absent; + + +/* + * Set a cause code in an ATM attribute block + * + * Arguments: + * aap pointer to attribute block + * cause cause code + * + * Returns: + * none + * + */ +void +unisig_set_cause_attr(aap, cause) + Atm_attributes *aap; + int cause; +{ + /* + * Set the fields in the attribute block + */ + aap->cause.tag = T_ATM_PRESENT; + aap->cause.v.coding_standard = T_ATM_ITU_CODING; + aap->cause.v.location = T_ATM_LOC_USER; + aap->cause.v.cause_value = cause; + KM_ZERO(aap->cause.v.diagnostics, + sizeof(aap->cause.v.diagnostics)); +} + + +/* + * Open a UNI VCC + * + * Called when a user wants to open a VC. This function will construct + * a VCCB and, if we are opening an SVC, call the Q.2931 VC state + * machine. The user will have to wait for a notify event to be sure + * the SVC is fully open. + * + * Must be called at splnet. + * + * Arguments: + * usp pointer to UNISIG protocol instance + * cvp pointer to connection parameters for the VCC + * + * Returns: + * 0 VCC creation successful + * errno VCC setup failed - reason indicated + * + */ +int +unisig_open_vcc(usp, cvp) + struct unisig *usp; + Atm_connvc *cvp; +{ + struct atm_pif *pip = usp->us_pif; + struct unisig_vccb *uvp; + Atm_addr_pvc *pvp; + int err, pvc; + + ATM_DEBUG2("unisig_open_vcc: usp=0x%x, cvp=0x%x\n", usp, cvp); + + /* + * Validate user parameters. AAL and encapsulation are + * checked by the connection manager + */ + + /* + * Check called party address(es) + */ + if(cvp->cvc_attr.called.tag != T_ATM_PRESENT || + cvp->cvc_attr.called.addr.address_format == + T_ATM_ABSENT) { + return(EINVAL); + } + switch (cvp->cvc_attr.called.addr.address_format) { + case T_ATM_PVC_ADDR: + /* + * Make sure VPI/VCI is valid + */ + pvc = 1; + pvp = (Atm_addr_pvc *)cvp->cvc_attr.called.addr.address; + if ((ATM_PVC_GET_VPI(pvp) > pip->pif_maxvpi) || + (ATM_PVC_GET_VCI(pvp) == 0) || + (ATM_PVC_GET_VCI(pvp) > pip->pif_maxvci)) { + return(ERANGE); + } + + /* + * Make sure VPI/VCI is not already in use + */ + if (unisig_find_vpvc(usp, + ATM_PVC_GET_VPI(pvp), + ATM_PVC_GET_VCI(pvp), 0)) { + return(EEXIST); + } + ATM_DEBUG2("unisig_open_vcc: VPI.VCI=%d.%d\n", + ATM_PVC_GET_VPI(pvp), + ATM_PVC_GET_VCI(pvp)); + break; + + case T_ATM_ENDSYS_ADDR: + /* + * Check signalling state + */ + pvc = 0; + pvp = NULL; + if (usp->us_state != UNISIG_ACTIVE) { + return(ENETDOWN); + } + + /* + * Make sure there's no subaddress + */ + if (cvp->cvc_attr.called.subaddr.address_format != + T_ATM_ABSENT) { + return(EINVAL); + } + break; + + case T_ATM_E164_ADDR: + /* + * Check signalling state + */ + pvc = 0; + pvp = NULL; + if (usp->us_state != UNISIG_ACTIVE) { + return(ENETDOWN); + } + + /* + * Check destination address format + */ + if (cvp->cvc_attr.called.subaddr.address_format != + T_ATM_ENDSYS_ADDR && + cvp->cvc_attr.called.subaddr.address_format != + T_ATM_ABSENT) { + return(EINVAL); + } + break; + + default: + return(EPROTONOSUPPORT); + } + + /* + * Check that this is for the same interface UNISIG uses + */ + if (!cvp->cvc_attr.nif || + cvp->cvc_attr.nif->nif_pif != usp->us_pif) { + return(EINVAL); + } + + /* + * Allocate control block for VCC + */ + uvp = (struct unisig_vccb *)atm_allocate(&unisig_vcpool); + if (uvp == NULL) { + return(ENOMEM); + } + + /* + * Fill in VCCB + */ + if (pvc) { + uvp->uv_type = VCC_PVC | VCC_IN | VCC_OUT; + uvp->uv_vpi = ATM_PVC_GET_VPI(pvp); + uvp->uv_vci = ATM_PVC_GET_VCI(pvp); + uvp->uv_sstate = (usp->us_state == UNISIG_ACTIVE ? + UNI_PVC_ACTIVE : UNI_PVC_ACT_DOWN); + uvp->uv_ustate = VCCU_OPEN; + } else { + uvp->uv_type = VCC_SVC | VCC_IN | VCC_OUT; + uvp->uv_sstate = UNI_NULL; + uvp->uv_ustate = VCCU_POPEN; + } + uvp->uv_proto = usp->us_pif->pif_sigmgr->sm_proto; + uvp->uv_pif = usp->us_pif; + uvp->uv_nif = cvp->cvc_attr.nif; + uvp->uv_connvc = cvp; + uvp->uv_tstamp = time_second; + + /* + * Put VCCB on UNISIG queue + */ + ENQUEUE(uvp, struct unisig_vccb, uv_sigelem, usp->us_vccq); + + /* + * Call the VC state machine if this is an SVC + */ + if (!pvc) { + err = unisig_vc_state(usp, uvp, UNI_VC_SETUP_CALL, + (struct unisig_msg *) 0); + if (err) { + /* + * On error, delete the VCCB + */ + DEQUEUE(uvp, struct unisig_vccb, uv_sigelem, + usp->us_vccq); + atm_free((caddr_t)uvp); + return(err); + } + } + + /* + * Link VCCB to VCC connection block + */ + cvp->cvc_vcc = (struct vccb *) uvp; + + return(0); +} + + +/* + * Close a UNISIG VCC + * + * Called when a user wants to close a VCC. This function will clean + * up the VCCB and, for an SVC, send a close request. + * + * Must be called at splnet. + * + * Arguments: + * usp pointer to UNISIG protocol instance + * uvp pointer to VCCB for the VCC to be closed + * + * Returns: + * 0 VCC is now closed + * errno error encountered + */ +int +unisig_close_vcc(usp, uvp) + struct unisig *usp; + struct unisig_vccb *uvp; +{ + int err = 0; + + ATM_DEBUG2("unisig_close_vcc: uvp=0x%x, state=%d\n", uvp, + uvp->uv_sstate); + + /* + * Check that this is for the same interface UNISIG uses + */ + if (uvp->uv_pif != usp->us_pif) { + return (EINVAL); + } + + /* + * Mark the close time. + */ + uvp->uv_tstamp = time_second; + + /* + * Process based on the connection type + */ + if (uvp->uv_type & VCC_PVC) { + uvp->uv_sstate = UNI_FREE; + uvp->uv_ustate = VCCU_CLOSED; + } else if (uvp->uv_type & VCC_SVC) { + /* + * Call the VC state machine + */ + uvp->uv_ustate = VCCU_CLOSED; + err = unisig_vc_state(usp, uvp, UNI_VC_RELEASE_CALL, + (struct unisig_msg *) 0); + } + + /* + * Wait for user to free resources + */ + return(err); +} + + +/* + * Clear a UNISIG VCC + * + * Called to internally clear a VCC. No external protocol is + * initiated, the VCC is just closed and the owner is notified. + * + * Must be called at splnet. + * + * Arguments: + * usp pointer to UNISIG protocol instance + * uvp pointer to VCCB for the VCC to be closed + * cause cause code giving the reason for the close + * + * Returns: + * 0 VCC is closed + * errno error encountered + */ +int +unisig_clear_vcc(usp, uvp, cause) + struct unisig *usp; + struct unisig_vccb *uvp; + int cause; +{ + u_char outstate; + + ATM_DEBUG3("unisig_clear_vcc: uvp=0x%x, state=%d, cause=%d\n", + (int)uvp, uvp->uv_sstate, cause); + + /* + * Check that this is for the same interface UNISIG uses + */ + if (uvp->uv_pif != usp->us_pif) { + return (EINVAL); + } + + /* + * Kill any possible timer + */ + UNISIG_VC_CANCEL((struct vccb *) uvp); + + /* + * Mark the close time. + */ + uvp->uv_tstamp = time_second; + + /* + * Close the VCC and notify the user + */ + outstate = uvp->uv_sstate; + uvp->uv_sstate = UNI_FREE; + uvp->uv_ustate = VCCU_CLOSED; + if (outstate == UNI_ACTIVE || + outstate == UNI_CALL_INITIATED || + outstate == UNI_CALL_OUT_PROC || + outstate == UNI_CONNECT_REQUEST || + outstate == UNI_RELEASE_REQUEST || + outstate == UNI_RELEASE_IND || + outstate == UNI_SSCF_RECOV || + outstate == UNI_PVC_ACT_DOWN || + outstate == UNI_PVC_ACTIVE) { + unisig_set_cause_attr(&uvp->uv_connvc->cvc_attr, cause); + atm_cm_cleared(uvp->uv_connvc); + } + + /* + * Wait for user to free resources + */ + return(0); +} + + +#ifdef NOTDEF +/* + * Reset the switch state + * + * Arguments: + * usp pointer to UNISIG protocol instance + * + * Returns: + * none + * + */ +void +unisig_switch_reset(usp, cause) + struct unisig *usp; + int cause; +{ + int s; + struct unisig_vccb *uvp, *vnext; + + ATM_DEBUG2("unisig_switch_reset: usp=0x%x, cause=%d\n", + usp, cause); + + /* + * Terminate all of our VCCs + */ + s = splnet(); + for (uvp = Q_HEAD(usp->us_vccq, struct unisig_vccb); uvp; + uvp = vnext) { + vnext = Q_NEXT(uvp, struct unisig_vccb, uv_sigelem); + + if (uvp->uv_type & VCC_SVC) { + /* + * Close the SVC and notify the owner + */ + (void)unisig_clear_vcc(usp, uvp, + T_ATM_CAUSE_NORMAL_CALL_CLEARING); + } else if (uvp->uv_type & VCC_PVC) { + /* + * Notify PVC owner of the state change + */ + switch(cause) { + case UNI_DOWN: + uvp->uv_sstate = UNI_PVC_ACT_DOWN; + break; + case UNI_UP: + uvp->uv_sstate = UNI_PVC_ACTIVE; + break; + } + atm_cm_cleared(uvp->uv_connvc, cause); + } else { + log(LOG_ERR, "unisig: invalid VCC type: vccb=0x%x, type=%d\n", + uvp, uvp->uv_type); + } + } + (void) splx(s); +} +#endif + + +/* + * Copy connection parameters from UNI 3.0 message IEs into + * an attribute block + * + * Arguments: + * usp pointer to UNISIG protocol instance + * msg pointer to the SETUP message + * ap pointer to the attribute block + * + * Returns: + * none + * + */ +void +unisig_save_attrs(usp, msg, ap) + struct unisig *usp; + struct unisig_msg *msg; + Atm_attributes *ap; +{ + /* + * Sanity check + */ + if (!msg || !ap) + return; + + /* + * Save the AAL parameters (AAL 3/4 and AAL 5 only) + */ + if (msg->msg_ie_aalp) { + struct ie_generic *aalp = msg->msg_ie_aalp; + + switch(msg->msg_ie_aalp->ie_aalp_aal_type) { + case UNI_IE_AALP_AT_AAL3: + ap->aal.tag = T_ATM_PRESENT; + ap->aal.type = + msg->msg_ie_aalp->ie_aalp_aal_type; + ap->aal.v.aal4.forward_max_SDU_size = + msg->msg_ie_aalp->ie_aalp_4_fwd_max_sdu; + ap->aal.v.aal4.backward_max_SDU_size = + msg->msg_ie_aalp->ie_aalp_4_bkwd_max_sdu; + ap->aal.v.aal4.SSCS_type = + msg->msg_ie_aalp->ie_aalp_4_sscs_type; + if (aalp->ie_aalp_4_mid_range == T_ATM_ABSENT) { + ap->aal.v.aal4.mid_low = T_ATM_ABSENT; + ap->aal.v.aal4.mid_high = T_ATM_ABSENT; + } else { + if (usp->us_proto == ATM_SIG_UNI30) { + ap->aal.v.aal4.mid_low = 0; + ap->aal.v.aal4.mid_high = + aalp->ie_aalp_4_mid_range + & UNI_IE_AALP_A3_R_MASK; + } else { + ap->aal.v.aal4.mid_low = + (aalp->ie_aalp_4_mid_range >> + UNI_IE_AALP_A3_R_SHIFT) + & UNI_IE_AALP_A3_R_MASK; + ap->aal.v.aal4.mid_high = + aalp->ie_aalp_4_mid_range + & UNI_IE_AALP_A3_R_MASK; + } + } + break; + case UNI_IE_AALP_AT_AAL5: + ap->aal.tag = T_ATM_PRESENT; + ap->aal.type = + msg->msg_ie_aalp->ie_aalp_aal_type; + ap->aal.v.aal5.forward_max_SDU_size = + msg->msg_ie_aalp->ie_aalp_5_fwd_max_sdu; + ap->aal.v.aal5.backward_max_SDU_size = + msg->msg_ie_aalp->ie_aalp_5_bkwd_max_sdu; + ap->aal.v.aal5.SSCS_type = + msg->msg_ie_aalp->ie_aalp_5_sscs_type; + break; + } + } + + /* + * Save traffic descriptor attributes + */ + if (msg->msg_ie_clrt) { + ap->traffic.tag = T_ATM_PRESENT; + ap->traffic.v.forward.PCR_high_priority = + msg->msg_ie_clrt->ie_clrt_fwd_peak; + ap->traffic.v.forward.PCR_all_traffic = + msg->msg_ie_clrt->ie_clrt_fwd_peak_01; + ap->traffic.v.forward.SCR_high_priority = + msg->msg_ie_clrt->ie_clrt_fwd_sust; + ap->traffic.v.forward.SCR_all_traffic = + msg->msg_ie_clrt->ie_clrt_fwd_sust_01; + ap->traffic.v.forward.MBS_high_priority = + msg->msg_ie_clrt->ie_clrt_fwd_burst; + ap->traffic.v.forward.MBS_all_traffic = + msg->msg_ie_clrt->ie_clrt_fwd_burst_01; + ap->traffic.v.backward.PCR_high_priority = + msg->msg_ie_clrt->ie_clrt_bkwd_peak; + ap->traffic.v.backward.PCR_all_traffic = + msg->msg_ie_clrt->ie_clrt_bkwd_peak_01; + ap->traffic.v.backward.SCR_high_priority = + msg->msg_ie_clrt->ie_clrt_bkwd_sust; + ap->traffic.v.backward.SCR_all_traffic = + msg->msg_ie_clrt->ie_clrt_bkwd_sust_01; + ap->traffic.v.backward.MBS_high_priority = + msg->msg_ie_clrt->ie_clrt_bkwd_burst; + ap->traffic.v.backward.MBS_all_traffic = + msg->msg_ie_clrt->ie_clrt_bkwd_burst_01; + ap->traffic.v.best_effort = + msg->msg_ie_clrt->ie_clrt_best_effort; + if (msg->msg_ie_clrt->ie_clrt_tm_options == + T_ATM_ABSENT) { + ap->traffic.v.forward.tagging = T_NO; + ap->traffic.v.backward.tagging = T_NO; + } else { + ap->traffic.v.forward.tagging = + (msg->msg_ie_clrt->ie_clrt_tm_options & + UNI_IE_CLRT_TM_FWD_TAG) != 0; + ap->traffic.v.backward.tagging = + (msg->msg_ie_clrt->ie_clrt_tm_options & + UNI_IE_CLRT_TM_BKWD_TAG) != 0; + } + } + + /* + * Save broadband bearer attributes + */ + if (msg->msg_ie_bbcp) { + ap->bearer.tag = T_ATM_PRESENT; + ap->bearer.v.bearer_class = + msg->msg_ie_bbcp->ie_bbcp_bearer_class; + ap->bearer.v.traffic_type = + msg->msg_ie_bbcp->ie_bbcp_traffic_type; + ap->bearer.v.timing_requirements = + msg->msg_ie_bbcp->ie_bbcp_timing_req; + ap->bearer.v.clipping_susceptibility = + msg->msg_ie_bbcp->ie_bbcp_clipping; + ap->bearer.v.connection_configuration = + msg->msg_ie_bbcp->ie_bbcp_conn_config; + } + + /* + * Save broadband high layer attributes + */ + if (msg->msg_ie_bhli) { + ap->bhli.tag = T_ATM_PRESENT; + ap->bhli.v.ID_type = msg->msg_ie_bhli->ie_bhli_type; + switch(ap->bhli.v.ID_type) { + case T_ATM_ISO_APP_ID: + KM_COPY(msg->msg_ie_bhli->ie_bhli_info, + ap->bhli.v.ID.ISO_ID, + sizeof(ap->bhli.v.ID.ISO_ID)); + break; + case T_ATM_USER_APP_ID: + KM_COPY(msg->msg_ie_bhli->ie_bhli_info, + ap->bhli.v.ID.user_defined_ID, + sizeof(ap->bhli.v.ID.user_defined_ID)); + break; + case T_ATM_VENDOR_APP_ID: + KM_COPY(msg->msg_ie_bhli->ie_bhli_info, + ap->bhli.v.ID.vendor_ID.OUI, + sizeof(ap->bhli.v.ID.vendor_ID.OUI)); + KM_COPY(&msg->msg_ie_bhli->ie_bhli_info[sizeof(ap->bhli.v.ID.vendor_ID.OUI)-1], + ap->bhli.v.ID.vendor_ID.app_ID, + sizeof(ap->bhli.v.ID.vendor_ID.app_ID)); + break; + } + } + + /* + * Save Broadband low layer, user layer 2 and 3 attributes + */ + if (msg->msg_ie_blli) { + /* + * Layer 2 parameters + */ + switch(msg->msg_ie_blli->ie_blli_l2_id) { + case UNI_IE_BLLI_L2P_ISO1745: + case UNI_IE_BLLI_L2P_Q921: + case UNI_IE_BLLI_L2P_X25L: + case UNI_IE_BLLI_L2P_X25M: + case UNI_IE_BLLI_L2P_LAPB: + case UNI_IE_BLLI_L2P_HDLC1: + case UNI_IE_BLLI_L2P_HDLC2: + case UNI_IE_BLLI_L2P_HDLC3: + case UNI_IE_BLLI_L2P_LLC: + case UNI_IE_BLLI_L2P_X75: + case UNI_IE_BLLI_L2P_Q922: + case UNI_IE_BLLI_L2P_ISO7776: + ap->blli.tag_l2 = T_ATM_PRESENT; + ap->blli.v.layer_2_protocol.ID_type = + T_ATM_SIMPLE_ID; + ap->blli.v.layer_2_protocol.ID.simple_ID = + msg->msg_ie_blli->ie_blli_l2_id; + break; + case UNI_IE_BLLI_L2P_USER: + ap->blli.tag_l2 = T_ATM_PRESENT; + ap->blli.v.layer_2_protocol.ID_type = + T_ATM_USER_ID; + ap->blli.v.layer_2_protocol.ID.user_defined_ID = + msg->msg_ie_blli->ie_blli_l2_user_proto; + break; + default: + ap->blli.tag_l2 = T_ATM_ABSENT; + } + if (ap->blli.tag_l2 == T_ATM_PRESENT) { + ap->blli.v.layer_2_protocol.mode = + msg->msg_ie_blli->ie_blli_l2_mode; + ap->blli.v.layer_2_protocol.window_size = + msg->msg_ie_blli->ie_blli_l2_window; + } + + /* + * Layer 3 parameters + */ + switch(msg->msg_ie_blli->ie_blli_l3_id) { + case UNI_IE_BLLI_L3P_X25: + case UNI_IE_BLLI_L3P_ISO8208: + case UNI_IE_BLLI_L3P_ISO8878: + case UNI_IE_BLLI_L3P_ISO8473: + case UNI_IE_BLLI_L3P_T70: + ap->blli.tag_l3 = T_ATM_PRESENT; + ap->blli.v.layer_3_protocol.ID_type = + T_ATM_SIMPLE_ID; + ap->blli.v.layer_3_protocol.ID.simple_ID = + msg->msg_ie_blli->ie_blli_l3_id; + break; + case UNI_IE_BLLI_L3P_ISO9577: + ap->blli.tag_l3 = T_ATM_PRESENT; + ap->blli.v.layer_3_protocol.ID_type = + T_ATM_SIMPLE_ID; + ap->blli.v.layer_3_protocol.ID.simple_ID = + msg->msg_ie_blli->ie_blli_l3_id; + if (msg->msg_ie_blli->ie_blli_l3_ipi == + UNI_IE_BLLI_L3IPI_SNAP) { + KM_COPY(msg->msg_ie_blli->ie_blli_l3_oui, + ap->blli.v.layer_3_protocol.ID.SNAP_ID.OUI, + sizeof(ap->blli.v.layer_3_protocol.ID.SNAP_ID.OUI)); + KM_COPY(msg->msg_ie_blli->ie_blli_l3_pid, + ap->blli.v.layer_3_protocol.ID.SNAP_ID.PID, + sizeof(ap->blli.v.layer_3_protocol.ID.SNAP_ID.PID)); + } else { + ap->blli.v.layer_3_protocol.ID.IPI_ID = + msg->msg_ie_blli->ie_blli_l3_ipi; + } + break; + case UNI_IE_BLLI_L3P_USER: + ap->blli.tag_l3 = T_ATM_PRESENT; + ap->blli.v.layer_3_protocol.ID_type = + T_ATM_USER_ID; + ap->blli.v.layer_3_protocol.ID.user_defined_ID = + msg->msg_ie_blli->ie_blli_l3_user_proto; + break; + default: + ap->blli.tag_l3 = T_ATM_ABSENT; + } + if (ap->blli.tag_l3 == T_ATM_PRESENT) { + ap->blli.v.layer_3_protocol.mode = + msg->msg_ie_blli->ie_blli_l3_mode; + ap->blli.v.layer_3_protocol.packet_size = + msg->msg_ie_blli->ie_blli_l3_packet_size; + ap->blli.v.layer_3_protocol.window_size = + msg->msg_ie_blli->ie_blli_l3_window; + } + } + + /* + * Save the called party address and subaddress + */ + if (msg->msg_ie_cdad) { + ap->called.tag = T_ATM_PRESENT; + ATM_ADDR_COPY(&msg->msg_ie_cdad->ie_cdad_addr, + &ap->called.addr); + ap->called.subaddr.address_format = T_ATM_ABSENT; + ap->called.subaddr.address_length = 0; + } + if (msg->msg_ie_cdsa) { + ATM_ADDR_COPY(&msg->msg_ie_cdsa->ie_cdsa_addr, + &ap->called.subaddr); + } + + /* + * Save the calling party address and subaddress + */ + if (msg->msg_ie_cgad) { + ap->calling.tag = T_ATM_PRESENT; + ATM_ADDR_COPY(&msg->msg_ie_cgad->ie_cgad_addr, + &ap->calling.addr); + ap->calling.subaddr.address_format = T_ATM_ABSENT; + ap->calling.subaddr.address_length = 0; + } + + if (msg->msg_ie_cgsa) { + ATM_ADDR_COPY(&msg->msg_ie_cgsa->ie_cgsa_addr, + &ap->calling.subaddr); + } + + /* + * Save quality of service attributes + */ + if (msg->msg_ie_qosp) { + ap->qos.tag = T_ATM_PRESENT; + ap->qos.v.coding_standard = msg->msg_ie_qosp->ie_coding; + ap->qos.v.forward.qos_class = msg->msg_ie_qosp->ie_qosp_fwd_class; + ap->qos.v.forward.qos_class = + msg->msg_ie_qosp->ie_qosp_bkwd_class; + } + + /* + * Save transit network attributes + */ + if (msg->msg_ie_trnt) { + ap->transit.tag = T_ATM_PRESENT; + ap->transit.v.length = + MIN(msg->msg_ie_trnt->ie_trnt_id_len, + sizeof(ap->transit.v.network_id)); + KM_COPY(msg->msg_ie_trnt->ie_trnt_id, + ap->transit.v.network_id, + ap->transit.v.length); + } + + /* + * Save cause code + */ + if (msg->msg_ie_caus) { + ap->cause.tag = T_ATM_PRESENT; + ap->cause.v.coding_standard = + msg->msg_ie_caus->ie_coding; + ap->cause.v.location = + msg->msg_ie_caus->ie_caus_loc; + ap->cause.v.cause_value = + msg->msg_ie_caus->ie_caus_cause; + KM_ZERO(ap->cause.v.diagnostics, + sizeof(ap->cause.v.diagnostics)); +#ifdef NOTDEF + KM_COPY(msg->msg_ie_caus->ie_caus_diagnostic, + ap->transit.v.diagnostics, + MIN(sizeof(ap->transit.v.diagnostics), + msg->msg_ie_caus->ie_caus_diag_len)); +#endif + } +} + + +/* + * Copy connection parameters from an attribute block into + * UNI 3.0 message IEs + * + * Arguments: + * usp pointer to UNISIG protocol instance + * msg pointer to the SETUP message + * ap pointer to the attribute block + * + * Returns: + * 0 everything OK + * else error encountered + * + */ +int +unisig_set_attrs(usp, msg, ap) + struct unisig *usp; + struct unisig_msg *msg; + Atm_attributes *ap; +{ + int err = 0; + + /* + * Sanity check + */ + if (!msg || !ap) + return(EINVAL); + + /* + * Set the AAL parameters (AAL 3/4 and AAL 5 only) + */ + if (ap->aal.tag == T_ATM_PRESENT) { + if (!msg->msg_ie_aalp) { + msg->msg_ie_aalp = (struct ie_generic *) + atm_allocate(&unisig_iepool); + if (msg->msg_ie_aalp == NULL) { + err = ENOMEM; + goto done; + } + } + KM_COPY(&ie_aalp_absent, + &msg->msg_ie_aalp->ie_u.ie_aalp, + sizeof(ie_aalp_absent)); + msg->msg_ie_aalp->ie_ident = UNI_IE_AALP; + msg->msg_ie_aalp->ie_aalp_aal_type = ap->aal.type; + switch(ap->aal.type) { + case ATM_AAL3_4: + msg->msg_ie_aalp->ie_aalp_4_fwd_max_sdu = + ap->aal.v.aal4.forward_max_SDU_size; + msg->msg_ie_aalp->ie_aalp_4_bkwd_max_sdu = + ap->aal.v.aal4.backward_max_SDU_size; + msg->msg_ie_aalp->ie_aalp_4_mode = UNI_IE_AALP_A5_M_MSG; + msg->msg_ie_aalp->ie_aalp_4_sscs_type = + ap->aal.v.aal4.SSCS_type; + if (ap->aal.v.aal4.mid_low == T_ATM_ABSENT) { + msg->msg_ie_aalp->ie_aalp_4_mid_range = + T_ATM_ABSENT; + } else { + if (usp->us_proto == ATM_SIG_UNI30) { + msg->msg_ie_aalp->ie_aalp_4_mid_range = + ap->aal.v.aal4.mid_high & + UNI_IE_AALP_A3_R_MASK; + } else { + msg->msg_ie_aalp->ie_aalp_4_mid_range = + ((ap->aal.v.aal4.mid_low & + UNI_IE_AALP_A3_R_MASK) + << UNI_IE_AALP_A3_R_SHIFT) + | + (ap->aal.v.aal4.mid_high & + UNI_IE_AALP_A3_R_MASK); + } + } + break; + case ATM_AAL5: + msg->msg_ie_aalp->ie_aalp_5_fwd_max_sdu = + ap->aal.v.aal5.forward_max_SDU_size; + msg->msg_ie_aalp->ie_aalp_5_bkwd_max_sdu = + ap->aal.v.aal5.backward_max_SDU_size; + msg->msg_ie_aalp->ie_aalp_5_mode = + UNI_IE_AALP_A5_M_MSG; + msg->msg_ie_aalp->ie_aalp_5_sscs_type = + ap->aal.v.aal5.SSCS_type; + break; + } + } + + /* + * Set traffic descriptor attributes + */ + if (ap->traffic.tag == T_ATM_PRESENT) { + if (!msg->msg_ie_clrt) { + msg->msg_ie_clrt = (struct ie_generic *) + atm_allocate(&unisig_iepool); + if (msg->msg_ie_clrt == NULL) { + err = ENOMEM; + goto done; + } + } + KM_COPY(&ie_clrt_absent, + &msg->msg_ie_clrt->ie_u.ie_clrt, + sizeof(ie_clrt_absent)); + msg->msg_ie_clrt->ie_ident = UNI_IE_CLRT; + msg->msg_ie_clrt->ie_clrt_fwd_peak = + ap->traffic.v.forward.PCR_high_priority; + msg->msg_ie_clrt->ie_clrt_fwd_peak_01 = + ap->traffic.v.forward.PCR_all_traffic; + msg->msg_ie_clrt->ie_clrt_fwd_sust = + ap->traffic.v.forward.SCR_high_priority; + msg->msg_ie_clrt->ie_clrt_fwd_sust_01 = + ap->traffic.v.forward.SCR_all_traffic; + msg->msg_ie_clrt->ie_clrt_fwd_burst = + ap->traffic.v.forward.MBS_high_priority; + msg->msg_ie_clrt->ie_clrt_fwd_burst_01 = + ap->traffic.v.forward.MBS_all_traffic; + msg->msg_ie_clrt->ie_clrt_bkwd_peak = + ap->traffic.v.backward.PCR_high_priority; + msg->msg_ie_clrt->ie_clrt_bkwd_peak_01 = + ap->traffic.v.backward.PCR_all_traffic; + msg->msg_ie_clrt->ie_clrt_bkwd_sust = + ap->traffic.v.backward.SCR_high_priority; + msg->msg_ie_clrt->ie_clrt_bkwd_sust_01 = + ap->traffic.v.backward.SCR_all_traffic; + msg->msg_ie_clrt->ie_clrt_bkwd_burst = + ap->traffic.v.backward.MBS_high_priority; + msg->msg_ie_clrt->ie_clrt_bkwd_burst_01 = + ap->traffic.v.backward.MBS_all_traffic; + msg->msg_ie_clrt->ie_clrt_best_effort = + ap->traffic.v.best_effort; + msg->msg_ie_clrt->ie_clrt_tm_options = 0; + if (ap->traffic.v.forward.tagging) { + msg->msg_ie_clrt->ie_clrt_tm_options |= + UNI_IE_CLRT_TM_FWD_TAG; + } + if (ap->traffic.v.backward.tagging) { + msg->msg_ie_clrt->ie_clrt_tm_options |= + UNI_IE_CLRT_TM_BKWD_TAG; + } + if (msg->msg_ie_clrt->ie_clrt_tm_options == 0) { + msg->msg_ie_clrt->ie_clrt_tm_options = + T_ATM_ABSENT; + } + } + + /* + * Set broadband bearer attributes + */ + if (ap->bearer.tag == T_ATM_PRESENT) { + if (!msg->msg_ie_bbcp) { + msg->msg_ie_bbcp = (struct ie_generic *) + atm_allocate(&unisig_iepool); + if (msg->msg_ie_bbcp == NULL) { + err = ENOMEM; + goto done; + } + } + KM_COPY(&ie_bbcp_absent, + &msg->msg_ie_bbcp->ie_u.ie_bbcp, + sizeof(ie_bbcp_absent)); + msg->msg_ie_bbcp->ie_ident = UNI_IE_BBCP; + msg->msg_ie_bbcp->ie_bbcp_bearer_class = + ap->bearer.v.bearer_class; + msg->msg_ie_bbcp->ie_bbcp_traffic_type = + ap->bearer.v.traffic_type; + msg->msg_ie_bbcp->ie_bbcp_timing_req = + ap->bearer.v.timing_requirements; + msg->msg_ie_bbcp->ie_bbcp_clipping = + ap->bearer.v.clipping_susceptibility; + msg->msg_ie_bbcp->ie_bbcp_conn_config = + ap->bearer.v.connection_configuration; + } + + /* + * Set broadband high layer attributes + */ + if (ap->bhli.tag == T_ATM_PRESENT) { + if (!msg->msg_ie_bhli) { + msg->msg_ie_bhli = (struct ie_generic *) + atm_allocate(&unisig_iepool); + if (msg->msg_ie_bhli == NULL) { + err = ENOMEM; + goto done; + } + } + KM_COPY(&ie_bhli_absent, + &msg->msg_ie_bhli->ie_u.ie_bhli, + sizeof(ie_bhli_absent)); + msg->msg_ie_bhli->ie_ident = UNI_IE_BHLI; + msg->msg_ie_bhli->ie_bhli_type = ap->bhli.v.ID_type; + switch (ap->bhli.v.ID_type) { + case T_ATM_ISO_APP_ID: + KM_COPY(ap->bhli.v.ID.ISO_ID, + msg->msg_ie_bhli->ie_bhli_info, + sizeof(ap->bhli.v.ID.ISO_ID)); + break; + case T_ATM_USER_APP_ID: + KM_COPY(ap->bhli.v.ID.user_defined_ID, + msg->msg_ie_bhli->ie_bhli_info, + sizeof(ap->bhli.v.ID.user_defined_ID)); + break; + case T_ATM_VENDOR_APP_ID: + KM_COPY(ap->bhli.v.ID.vendor_ID.OUI, + msg->msg_ie_bhli->ie_bhli_info, + sizeof(ap->bhli.v.ID.vendor_ID.OUI)); + KM_COPY(ap->bhli.v.ID.vendor_ID.app_ID, + &msg->msg_ie_bhli->ie_bhli_info[sizeof(ap->bhli.v.ID.vendor_ID.OUI)-1], + sizeof(ap->bhli.v.ID.vendor_ID.app_ID)); + break; + } + } + + /* + * Set Broadband low layer, user layer 2 and 3 attributes + */ + if (ap->blli.tag_l2 == T_ATM_PRESENT || + ap->blli.tag_l3 == T_ATM_PRESENT) { + if (!msg->msg_ie_blli) { + msg->msg_ie_blli = (struct ie_generic *) + atm_allocate(&unisig_iepool); + if (msg->msg_ie_blli == NULL) { + err = ENOMEM; + goto done; + } + } + KM_COPY(&ie_blli_absent, + &msg->msg_ie_blli->ie_u.ie_blli, + sizeof(ie_blli_absent)); + msg->msg_ie_blli->ie_ident = UNI_IE_BLLI; + + if (ap->blli.tag_l2 == T_ATM_PRESENT) { + switch(ap->blli.v.layer_2_protocol.ID_type) { + case T_ATM_SIMPLE_ID: + msg->msg_ie_blli->ie_blli_l2_id = + ap->blli.v.layer_2_protocol.ID.simple_ID; + break; + case T_ATM_USER_ID: + msg->msg_ie_blli->ie_blli_l2_user_proto = + ap->blli.v.layer_2_protocol.ID.user_defined_ID; + break; + } + if (ap->blli.v.layer_2_protocol.ID_type != + T_ATM_ABSENT) { + msg->msg_ie_blli->ie_blli_l2_mode = + ap->blli.v.layer_2_protocol.mode; + msg->msg_ie_blli->ie_blli_l2_window = + ap->blli.v.layer_2_protocol.window_size; + } + } + + if (ap->blli.tag_l3 == T_ATM_PRESENT) { + switch (ap->blli.v.layer_3_protocol.ID_type) { + case T_ATM_SIMPLE_ID: + msg->msg_ie_blli->ie_blli_l3_id = + ap->blli.v.layer_3_protocol.ID.simple_ID; + break; + + case T_ATM_IPI_ID: + msg->msg_ie_blli->ie_blli_l3_id = + UNI_IE_BLLI_L3P_ISO9577; + msg->msg_ie_blli->ie_blli_l3_ipi = + ap->blli.v.layer_3_protocol.ID.IPI_ID; + break; + + case T_ATM_SNAP_ID: + msg->msg_ie_blli->ie_blli_l3_id = + UNI_IE_BLLI_L3P_ISO9577; + msg->msg_ie_blli->ie_blli_l3_ipi = + UNI_IE_BLLI_L3IPI_SNAP; + KM_COPY(ap->blli.v.layer_3_protocol.ID.SNAP_ID.OUI, + msg->msg_ie_blli->ie_blli_l3_oui, + sizeof(msg->msg_ie_blli->ie_blli_l3_oui)); + KM_COPY(ap->blli.v.layer_3_protocol.ID.SNAP_ID.PID, + msg->msg_ie_blli->ie_blli_l3_pid, + sizeof(msg->msg_ie_blli->ie_blli_l3_pid)); + break; + + case T_ATM_USER_ID: + msg->msg_ie_blli->ie_blli_l3_id = + UNI_IE_BLLI_L3P_USER; + msg->msg_ie_blli->ie_blli_l3_user_proto = + ap->blli.v.layer_3_protocol.ID.user_defined_ID; + break; + } + if (ap->blli.v.layer_3_protocol.ID_type + != T_ATM_ABSENT) { + msg->msg_ie_blli->ie_blli_l3_mode = + ap->blli.v.layer_3_protocol.mode; + msg->msg_ie_blli->ie_blli_l3_packet_size = + ap->blli.v.layer_3_protocol.packet_size; + msg->msg_ie_blli->ie_blli_l3_window = + ap->blli.v.layer_3_protocol.window_size; + } + } + } + + /* + * Set the called party address and subaddress + */ + if (ap->called.tag == T_ATM_PRESENT) { + if (!msg->msg_ie_cdad) { + msg->msg_ie_cdad = (struct ie_generic *) + atm_allocate(&unisig_iepool); + if (msg->msg_ie_cdad == NULL) { + err = ENOMEM; + goto done; + } + } + KM_COPY(&ie_cdad_absent, + &msg->msg_ie_cdad->ie_u.ie_cdad, + sizeof(ie_cdad_absent)); + msg->msg_ie_cdad->ie_ident = UNI_IE_CDAD; + ATM_ADDR_COPY(&ap->called.addr, + &msg->msg_ie_cdad->ie_cdad_addr); + + if (ap->called.subaddr.address_format != T_ATM_ABSENT) { + if (!msg->msg_ie_cdsa) { + msg->msg_ie_cdsa = (struct ie_generic *) + atm_allocate(&unisig_iepool); + if (msg->msg_ie_cdsa == NULL) { + err = ENOMEM; + goto done; + } + } + KM_COPY(&ie_cdsa_absent, + &msg->msg_ie_cdsa->ie_u.ie_cdsa, + sizeof(ie_cdsa_absent)); + msg->msg_ie_cdsa->ie_ident = UNI_IE_CDSA; + ATM_ADDR_COPY(&ap->called.subaddr, + &msg->msg_ie_cdsa->ie_cdsa_addr); + } + } + + /* + * Set the calling party address and subaddress + */ + + if (ap->calling.tag == T_ATM_PRESENT) { + if (!msg->msg_ie_cgad) { + msg->msg_ie_cgad = (struct ie_generic *) + atm_allocate(&unisig_iepool); + if (msg->msg_ie_cgad == NULL) { + err = ENOMEM; + goto done; + } + } + KM_COPY(&ie_cgad_absent, + &msg->msg_ie_cgad->ie_u.ie_cgad, + sizeof(ie_cgad_absent)); + msg->msg_ie_cgsa->ie_ident = UNI_IE_CGSA; + ATM_ADDR_COPY(&ap->calling.addr, + &msg->msg_ie_cgad->ie_cgad_addr); + + if (ap->calling.subaddr.address_format != + T_ATM_ABSENT) { + if (!msg->msg_ie_cgsa) { + msg->msg_ie_cgsa = (struct ie_generic *) + atm_allocate(&unisig_iepool); + if (msg->msg_ie_cgsa == NULL) { + err = ENOMEM; + goto done; + } + } + KM_COPY(&ie_cgsa_absent, + &msg->msg_ie_cgsa->ie_u.ie_cgsa, + sizeof(ie_cgsa_absent)); + msg->msg_ie_cgsa->ie_ident = UNI_IE_CGSA; + ATM_ADDR_COPY(&ap->calling.subaddr, + &msg->msg_ie_cgsa->ie_cgsa_addr); + } + } + + /* + * Set quality of service attributes + */ + if (ap->qos.tag == T_ATM_PRESENT) { + if (!msg->msg_ie_qosp) { + msg->msg_ie_qosp = (struct ie_generic *) + atm_allocate(&unisig_iepool); + if (msg->msg_ie_qosp == NULL) { + err = ENOMEM; + goto done; + } + } + KM_COPY(&ie_qosp_absent, + &msg->msg_ie_qosp->ie_u.ie_qosp, + sizeof(ie_qosp_absent)); + msg->msg_ie_qosp->ie_ident = UNI_IE_QOSP; + if (usp->us_proto == ATM_SIG_UNI30) + msg->msg_ie_qosp->ie_coding = UNI_IE_CODE_STD; + else if ((ap->qos.v.forward.qos_class == + T_ATM_QOS_CLASS_0) || + (ap->qos.v.backward.qos_class == + T_ATM_QOS_CLASS_0)) + msg->msg_ie_qosp->ie_coding = UNI_IE_CODE_CCITT; + else + msg->msg_ie_qosp->ie_coding = ap->qos.v.coding_standard; + msg->msg_ie_qosp->ie_qosp_fwd_class = + ap->qos.v.forward.qos_class; + msg->msg_ie_qosp->ie_qosp_bkwd_class = + ap->qos.v.backward.qos_class; + } + + /* + * Set transit network attributes + */ + if (ap->transit.tag == T_ATM_PRESENT && + ap->transit.v.length != 0) { + if (!msg->msg_ie_trnt) { + msg->msg_ie_trnt = (struct ie_generic *) + atm_allocate(&unisig_iepool); + if (msg->msg_ie_trnt == NULL) { + err = ENOMEM; + goto done; + } + } + KM_COPY(&ie_trnt_absent, + &msg->msg_ie_trnt->ie_u.ie_trnt, + sizeof(ie_trnt_absent)); + msg->msg_ie_trnt->ie_ident = UNI_IE_TRNT; + msg->msg_ie_trnt->ie_trnt_id_type = + UNI_IE_TRNT_IDT_NATL; + msg->msg_ie_trnt->ie_trnt_id_plan = + UNI_IE_TRNT_IDP_CIC; + KM_COPY(ap->transit.v.network_id, + msg->msg_ie_trnt->ie_trnt_id, + ap->transit.v.length); + } + + /* + * Set cause code + */ + if (ap->cause.tag == T_ATM_PRESENT) { + if (!msg->msg_ie_caus) { + msg->msg_ie_caus = (struct ie_generic *) + atm_allocate(&unisig_iepool); + if (msg->msg_ie_caus == NULL) { + err = ENOMEM; + goto done; + } + } + KM_COPY(&ie_caus_absent, + &msg->msg_ie_caus->ie_u.ie_caus, + sizeof(ie_caus_absent)); + msg->msg_ie_caus->ie_ident = UNI_IE_CAUS; + msg->msg_ie_caus->ie_coding = + ap->cause.v.coding_standard; + msg->msg_ie_caus->ie_caus_loc = + ap->cause.v.location; + msg->msg_ie_caus->ie_caus_cause = + ap->cause.v.cause_value; + + /* + * Don't copy the diagnostics from the attribute + * block, as there's no way to tell how much of + * the diagnostic field is relevant + */ + msg->msg_ie_caus->ie_caus_diag_len = 0; + } + +done: + return(err); +} diff --git a/sys/netatm/uni/unisig_util.c b/sys/netatm/uni/unisig_util.c new file mode 100644 index 0000000..ec4fbd0 --- /dev/null +++ b/sys/netatm/uni/unisig_util.c @@ -0,0 +1,389 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_util.c,v 1.9 1998/08/26 23:29:24 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * Protocol processing module + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: unisig_util.c,v 1.9 1998/08/26 23:29:24 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/unisig.h> +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/unisig_msg.h> + + +/* + * Free a UNISIG signalling message + * + * Free the passed message and any IEs that are attached to it + * + * Arguments: + * msg pointer to UNISIG protocol instance + * + * Returns: + * none + * + */ +void +unisig_free_msg(msg) + struct unisig_msg *msg; +{ + int i; + struct ie_generic *ie, *ienxt; + + ATM_DEBUG1("unisig_free_msg: msg=0x%x\n", msg); + + /* + * First free all the IEs + */ + for (i=0; i<UNI_MSG_IE_CNT; i++) { + ie = msg->msg_ie_vec[i]; + while (ie) { + ienxt = ie->ie_next; + atm_free(ie); + ie = ienxt; + } + } + + /* + * Finally, free the message structure itself + */ + atm_free(msg); +} + + +/* + * Verify a VCCB + * + * Search UNISIG's VCCB queue to verify that a VCCB belongs to UNISIG. + * + * Arguments: + * usp pointer to UNISIG protocol instance + * svp pointer to a VCCB + * + * Returns: + * TRUE the VCCB belongs to UNISIG + * FALSE the VCCB doesn't belong to UNISIG + * + */ +int +unisig_verify_vccb(usp, uvp) + struct unisig *usp; + struct unisig_vccb *uvp; + +{ + struct unisig_vccb *utp, *uvnext; + + for (utp = Q_HEAD(usp->us_vccq, struct unisig_vccb); + utp; utp = uvnext){ + uvnext = Q_NEXT(utp, struct unisig_vccb, uv_sigelem); + if (uvp == utp) { + return(TRUE); + } + } + return(FALSE); +} + + +/* + * Find a connection + * + * Find a VCCB given the call reference + * + * Arguments: + * usp pointer to UNISIG protocol instance + * cref the call reference to search for + * + * Returns: + * 0 there is no such VCCB + * uvp the address of the VCCB + * + */ +struct unisig_vccb * +unisig_find_conn(usp, cref) + struct unisig *usp; + u_int cref; + +{ + struct unisig_vccb *uvp, *uvnext; + + for (uvp = Q_HEAD(usp->us_vccq, struct unisig_vccb); uvp; + uvp = uvnext){ + uvnext = Q_NEXT(uvp, struct unisig_vccb, uv_sigelem); + if (uvp->uv_call_ref == cref) + break; + } + return(uvp); +} + + +/* + * Find a VCCB + * + * Find a VCCB given the VPI and VCI. + * + * Arguments: + * usp pointer to UNISIG protocol instance + * vpi the VPI to search for + * vci the VCI to search for + * dir the direction of the VCC (VCC_IN, VCC_OUT, or both). + * If dir is set to zero, return the address of any VCCB + * with the given VPI/VCI, regardless of direction. + * + * Returns: + * 0 there is no such VCCB + * uvp the address of the VCCB + * + */ +struct unisig_vccb * +unisig_find_vpvc(usp, vpi, vci, dir) + struct unisig *usp; + int vpi, vci; + u_char dir; + +{ + struct unisig_vccb *uvp, *uvnext; + + for (uvp = Q_HEAD(usp->us_vccq, struct unisig_vccb); uvp; + uvp = uvnext){ + uvnext = Q_NEXT(uvp, struct unisig_vccb, uv_sigelem); + if (uvp->uv_vpi == vpi && + uvp->uv_vci == vci && + (uvp->uv_type & dir) == dir) + break; + } + return(uvp); +} + + +/* + * Allocate a call reference value + * + * Arguments: + * usp pointer to UNISIG protocol instance + * + * Returns: + * 0 call reference not available + * cref the call reference value + * + */ +int +unisig_alloc_call_ref(usp) + struct unisig *usp; + +{ + int cref; + + /* + * Get the next call reference value + */ + cref = usp->us_cref; + + /* + * Make sure it hasn't got too large + */ + if (cref >= UNI_MSG_CALL_REF_DUMMY) { + /* XXX */ + log(LOG_ERR, "uni: call reference limit reached\n"); + return(0); + } + + /* + * Bump the call reference value + */ + usp->us_cref++; + + return(cref); +} + + +/* + * Print an ATM address + * + * Convert an ATM address into an ASCII string suitable for printing. + * + * Arguments: + * p pointer to an ATM address + * + * Returns: + * the address of a string with the ASCII representation of the + * address. This routine returns the address of a statically- + * allocated buffer, so if repeated calls to this routine are made, + * each call will destroy the result of the previous call. + * + */ +char * +unisig_addr_print(p) + Atm_addr *p; +{ + int i; + char *fp, *op, t_buff[16]; + u_char *cp; + static char strbuff[256]; + + static char nf_DCC[] = "0xX.XX.X.XXX.XX.XX.XX.XXXXXX.X"; + static char nf_ICD[] = "0xX.XX.X.XXX.XX.XX.XX.XXXXXX.X"; + static char nf_E164[] = "0xX.XXXXXXXX.XX.XX.XXXXXX.X"; + + union { + int w; + char c[4]; + } u1, u2; + + /* + * Clear the print buffer + */ + KM_ZERO(strbuff, sizeof(strbuff)); + + /* + * Select appropriate printing format + */ + switch(p->address_format) { + case T_ATM_ENDSYS_ADDR: + /* + * Select format by NSAP type + */ + switch(((Atm_addr_nsap *)p->address)->aan_afi) { + default: + case AFI_DCC: + fp = nf_DCC; + break; + case AFI_ICD: + fp = nf_ICD; + break; + case AFI_E164: + fp = nf_E164; + break; + } + + /* + * Loop through the format string, converting the NSAP + * to ASCII + */ + cp = (u_char *) p->address; + op = strbuff; + while (*fp) { + if (*fp == 'X') { + /* + * If format character is an 'X', put a + * two-digit hex representation of the + * NSAP byte in the output buffer + */ + sprintf(t_buff, "%x", *cp + 512); + strcpy(op, &t_buff[strlen(t_buff)-2]); + op++; op++; + cp++; + } else { + /* + * If format character isn't an 'X', + * just copy it to the output buffer + */ + *op = *fp; + op++; + } + fp++; + } + + break; + + case T_ATM_E164_ADDR: + /* + * Print the IA5 characters of the E.164 address + */ + for(i=0; i<p->address_length; i++) { + sprintf(&strbuff[strlen(strbuff)], "%c\0", + ((Atm_addr_e164 *)p->address)->aae_addr[i]); + } + break; + + case T_ATM_SPANS_ADDR: + /* + * Get address into integers + */ + u1.c[0] = ((Atm_addr_spans *)p->address)->aas_addr[0]; + u1.c[1] = ((Atm_addr_spans *)p->address)->aas_addr[1]; + u1.c[2] = ((Atm_addr_spans *)p->address)->aas_addr[2]; + u1.c[3] = ((Atm_addr_spans *)p->address)->aas_addr[3]; + u2.c[0] = ((Atm_addr_spans *)p->address)->aas_addr[4]; + u2.c[1] = ((Atm_addr_spans *)p->address)->aas_addr[5]; + u2.c[2] = ((Atm_addr_spans *)p->address)->aas_addr[6]; + u2.c[3] = ((Atm_addr_spans *)p->address)->aas_addr[7]; + + /* + * Print the address as two words xxxxx.yyyyyyyy + */ + sprintf(strbuff, "%x.%x", u1.w, u2.w); + break; + + case T_ATM_ABSENT: + default: + strcpy(strbuff, "-"); + } + + return(strbuff); +} + + +/* + * Print the contents of a message buffer chain + * + * Arguments: + * m pointer to a buffer + * + * Returns: + * none + * + */ +void +unisig_print_mbuf(m) + KBuffer *m; +{ + int i; + caddr_t cp; + + printf("unisig_print_mbuf:\n"); + while (m) { + KB_DATASTART(m, cp, caddr_t); + for (i = 0; i < KB_LEN(m); i++) { + if (i == 0) + printf(" bfr=0x%x: ", (int)m); + printf("%x ", (u_char)*cp++); + } + printf("<end_bfr>\n"); + m = KB_NEXT(m); + } +} diff --git a/sys/netatm/uni/unisig_var.h b/sys/netatm/uni/unisig_var.h new file mode 100644 index 0000000..1e3d01a7 --- /dev/null +++ b/sys/netatm/uni/unisig_var.h @@ -0,0 +1,321 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_var.h,v 1.12 1998/07/24 20:24:34 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * Protocol control blocks + * + */ + +#ifndef _UNISIG_VAR_H +#define _UNISIG_VAR_H + +#ifndef TRUE +#define TRUE 1 +#define FALSE 0 +#endif + +#ifdef ATM_KERNEL +/* + * Structure containing state information for each UNI protocol + * instance. There will be one instance for each ATM device interface + * using the UNI signalling manager. + */ +struct unisig { + struct siginst us_inst; /* Header */ + struct atm_time us_time; /* Timer controls */ + void (*us_lower) /* Lower command handler */ + __P((int, void *, int, int)); + Atm_connection *us_conn; /* Signalling connection */ + int us_cref; /* Call reference allocation */ + u_int us_retry; /* Protocol retry count */ + u_short us_headout; /* Headroom on sig ch output */ + u_char us_proto; /* Signalling version */ +}; + +#define us_next us_inst.si_next +#define us_pif us_inst.si_pif +#define us_addr us_inst.si_addr +#define us_subaddr us_inst.si_subaddr +#define us_vccq us_inst.si_vccq +#define us_state us_inst.si_state +#define us_ipserv us_inst.si_ipserv +#endif /* ATM_KERNEL */ + +/* + * Signalling manager states + */ +#define UNISIG_NULL 0 +#define UNISIG_ADDR_WAIT 1 +#define UNISIG_INIT 2 +#define UNISIG_ACTIVE 3 +#define UNISIG_DETACH 4 + +/* + * Signalling manager events + */ +#define UNISIG_SIGMGR_TIMEOUT 0 +#define UNISIG_SIGMGR_SSCF_EST_IND 1 +#define UNISIG_SIGMGR_SSCF_EST_CNF 2 +#define UNISIG_SIGMGR_SSCF_RLS_IND 3 +#define UNISIG_SIGMGR_SSCF_RLS_CNF 4 +#define UNISIG_SIGMGR_SSCF_DATA_IND 5 +#define UNISIG_SIGMGR_SSCF_UDATA_IND 6 +#define UNISIG_SIGMGR_CALL_CLEARED 7 +#define UNISIG_SIGMGR_DETACH 8 +#define UNISIG_SIGMGR_ADDR_SET 9 + +/* + * Signalling manager timer values + */ +#define UNISIG_SSCF_TIMEOUT (3 * ATM_HZ) + + +#ifdef ATM_KERNEL +/* + * UNI Virtual Channel Connection control block. All information + * regarding the state of a UNI-controlled VCC will be recorded here. + * There will be one UNI VCC control block for each UNI-controlled + * VCC. + */ +struct unisig_vccb { + struct vccb vcp_hdr; /* Generic VCCB */ + u_short uv_retry; /* Xmit retry count */ + u_int uv_call_ref; /* Q.2931 call reference */ +}; + +#define uv_type vcp_hdr.vc_type +#define uv_proto vcp_hdr.vc_proto +#define uv_sstate vcp_hdr.vc_sstate +#define uv_ustate vcp_hdr.vc_ustate +#define uv_pif vcp_hdr.vc_pif +#define uv_nif vcp_hdr.vc_nif +#define uv_sigelem vcp_hdr.vc_sigelem +#define uv_time vcp_hdr.vc_time +#define uv_vpi vcp_hdr.vc_vpi +#define uv_vci vcp_hdr.vc_vci +#define uv_connvc vcp_hdr.vc_connvc +#define uv_ipdus vcp_hdr.vc_ipdus +#define uv_opdus vcp_hdr.vc_opdus +#define uv_ibytes vcp_hdr.vc_ibytes +#define uv_obytes vcp_hdr.vc_obytes +#define uv_ierrors vcp_hdr.vc_ierrors +#define uv_oerrors vcp_hdr.vc_oerrors +#define uv_tstamp vcp_hdr.vc_tstamp +#endif /* ATM_KERNEL */ + +/* + * UNI VCC protocol states. Taken from The ATM Forum UNI 3.0 (section + * 5.2.1.1) + */ +#define UNI_NULL 0 /* No call exists */ +#define UNI_CALL_INITIATED 1 /* Initiating call */ +#define UNI_CALL_OUT_PROC 3 /* Outgoing call proceeding */ +#define UNI_CALL_DELIVERED 4 /* Not supported */ +#define UNI_CALL_PRESENT 6 /* Call coming in */ +#define UNI_CALL_RECEIVED 7 /* Not supported */ +#define UNI_CONNECT_REQUEST 8 /* Call coming in */ +#define UNI_CALL_IN_PROC 9 /* Incoming call proceeding */ +#define UNI_ACTIVE 10 /* Call is established */ +#define UNI_RELEASE_REQUEST 11 /* Clearing call */ +#define UNI_RELEASE_IND 12 /* Network disconnecting */ + +/* + * Additional states required for internal management of VCCs + */ +#define UNI_SSCF_RECOV 13 /* Signalling chan recovery */ +#define UNI_FREE 14 /* Waiting for user to free */ +#define UNI_PVC_ACTIVE 15 /* PVC Active */ +#define UNI_PVC_ACT_DOWN 16 /* PVC Active - i/f down */ + +/* + * UNI VCC events + */ +#define UNI_VC_TIMEOUT 0 /* Timer expired */ +#define UNI_VC_CALLP_MSG 1 /* CALL PROCEEDING message */ +#define UNI_VC_CONNECT_MSG 2 /* CONNECT message */ +#define UNI_VC_CNCTACK_MSG 3 /* CONNECT ACK message */ +#define UNI_VC_SETUP_MSG 4 /* SETUP message */ +#define UNI_VC_RELEASE_MSG 5 /* RELEASE message */ +#define UNI_VC_RLSCMP_MSG 6 /* RELEASE COMPLETE message */ +#define UNI_VC_STATUS_MSG 7 /* STATUS message */ +#define UNI_VC_STATUSENQ_MSG 8 /* STATUS ENQ message */ +#define UNI_VC_ADDP_MSG 9 /* ADD PARTY message */ +#define UNI_VC_ADDPACK_MSG 10 /* ADD PARTY ACK message */ +#define UNI_VC_ADDPREJ_MSG 11 /* ADD PARTY REJ message */ +#define UNI_VC_DROP_MSG 12 /* DROP PARTY message */ +#define UNI_VC_DROPACK_MSG 13 /* DROP PARTY ACK message */ +#define UNI_VC_SETUP_CALL 14 /* Setup routine called */ +#define UNI_VC_ACCEPT_CALL 15 /* Accept call routine called */ +#define UNI_VC_REJECT_CALL 16 /* Reject call routine called */ +#define UNI_VC_RELEASE_CALL 17 /* Release routine called */ +#define UNI_VC_ABORT_CALL 18 /* Abort routine called */ +#define UNI_VC_SAAL_FAIL 19 /* Signalling AAL failed */ +#define UNI_VC_SAAL_ESTAB 20 /* Signalling AAL back up */ + + +#ifdef ATM_KERNEL +/* + * UNI Timer Values. These values (except for T317) are taken from + * The ATM Forum UNI 3.0 (section 5.7.2). + */ +#define UNI_T303 (4 * ATM_HZ) +#define UNI_T308 (30 * ATM_HZ) +#define UNI_T309 (10 * ATM_HZ) +#define UNI_T310 (10 * ATM_HZ) +#define UNI_T313 (4 * ATM_HZ) +#define UNI_T316 (120 * ATM_HZ) +#define UNI_T317 (60 * ATM_HZ) +#define UNI_T322 (4 * ATM_HZ) +#define UNI_T398 (4 * ATM_HZ) +#define UNI_T399 (14 * ATM_HZ) + + +/* + * Timer macros + */ +#define UNISIG_TIMER(s, t) atm_timeout(&(s)->us_time, (t), unisig_timer) +#define UNISIG_CANCEL(s) atm_untimeout(&(s)->us_time) +#define UNISIG_VC_TIMER(v, t) atm_timeout(&(v)->vc_time, (t), unisig_vctimer) +#define UNISIG_VC_CANCEL(v) atm_untimeout(&(v)->vc_time) + + +/* + * Global function declarations + */ +struct usfmt; +struct unisig_msg; + + /* unisig_decode.c */ +int usf_dec_msg __P((struct usfmt *, struct unisig_msg *)); + + /* unisig_encode.c */ +int usf_enc_msg __P((struct usfmt *, struct unisig_msg *)); + + /* unisig_if.c */ +int unisig_start __P((void)); +int unisig_stop __P((void)); +int unisig_free __P((struct vccb *)); + + /* unisig_mbuf.c */ +int usf_init __P((struct usfmt *, struct unisig *, KBuffer *, int, int)); +int usf_byte __P((struct usfmt *, u_char *)); +int usf_short __P((struct usfmt *, u_short *)); +int usf_int3 __P((struct usfmt *, u_int *)); +int usf_int __P((struct usfmt *, u_int *)); +int usf_ext __P((struct usfmt *, u_int *)); +int usf_count __P((struct usfmt *)); +int usf_byte_mark __P((struct usfmt *, u_char *, u_char **)); + + /* unisig_msg.c */ +struct ie_generic; +void unisig_cause_from_attr __P((struct ie_generic *, + Atm_attributes *)); +void unisig_cause_from_msg __P((struct ie_generic *, + struct unisig_msg *, int)); +int unisig_send_msg __P((struct unisig *, + struct unisig_msg *)); +int unisig_send_setup __P((struct unisig *, + struct unisig_vccb *)); +int unisig_send_release __P((struct unisig *, + struct unisig_vccb *, + struct unisig_msg *, + int)); +int unisig_send_release_complete __P((struct unisig *, + struct unisig_vccb *, + struct unisig_msg *, + int)); +int unisig_send_status __P((struct unisig *, + struct unisig_vccb *, + struct unisig_msg *, + int)); +int unisig_rcv_msg __P((struct unisig *, KBuffer *)); + + /* unisig_print.c */ +void usp_print_msg __P((struct unisig_msg *, int)); + + /* unisig_proto.c */ +void unisig_timer __P((struct atm_time *)); +void unisig_vctimer __P((struct atm_time *)); +void unisig_saal_ctl __P((int, void *, void *)); +void unisig_saal_data __P((void *, KBuffer *)); +caddr_t unisig_getname __P((void *)); +void unisig_connected __P((void *)); +void unisig_cleared __P((void *, struct t_atm_cause *)); + + /* unisig_sigmgr_state.c */ +int unisig_sigmgr_state __P((struct unisig *, int, + KBuffer *)); + + /* unisig_subr.c */ +void unisig_set_cause_attr __P((Atm_attributes *, int)); +int unisig_open_vcc __P((struct unisig *, Atm_connvc *)); +int unisig_close_vcc __P((struct unisig *, + struct unisig_vccb *)); +int unisig_clear_vcc __P((struct unisig *, + struct unisig_vccb *, int)); +void unisig_switch_reset __P((struct unisig *, int)); +void unisig_save_attrs __P((struct unisig *, struct unisig_msg *, + Atm_attributes *)); +int unisig_set_attrs __P((struct unisig *, struct unisig_msg *, + Atm_attributes *)); + + /* unisig_util.c */ +void unisig_free_msg __P((struct unisig_msg *)); +int unisig_verify_vccb __P((struct unisig *, + struct unisig_vccb *)); +struct unisig_vccb * + unisig_find_conn __P((struct unisig *, u_int)); +struct unisig_vccb * + unisig_find_vpvc __P((struct unisig *, int, int, + u_char)); +int unisig_alloc_call_ref __P((struct unisig *)); +char * unisig_addr_print __P((Atm_addr *)); +void unisig_print_mbuf __P((KBuffer *)); +void unisig_print_buffer __P((KBuffer *)); + + /* unisig_vc_state.c */ +int unisig_vc_state __P((struct unisig *, + struct unisig_vccb *, + int, + struct unisig_msg *)); + + +/* + * External variables + */ +extern struct sp_info unisig_vcpool; +extern struct sp_info unisig_msgpool; +extern struct sp_info unisig_iepool; + +#endif /* ATM_KERNEL */ + +#endif /* _UNISIG_VAR_H */ diff --git a/sys/netatm/uni/unisig_vc_state.c b/sys/netatm/uni/unisig_vc_state.c new file mode 100644 index 0000000..cfd7635 --- /dev/null +++ b/sys/netatm/uni/unisig_vc_state.c @@ -0,0 +1,2223 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: unisig_vc_state.c,v 1.11 1998/08/06 18:16:29 mks Exp $ + * + */ + +/* + * ATM Forum UNI 3.0/3.1 Signalling Manager + * ---------------------------------------- + * + * VC state machine + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: unisig_vc_state.c,v 1.11 1998/08/06 18:16:29 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include <netatm/uni/unisig.h> +#include <netatm/uni/unisig_var.h> +#include <netatm/uni/unisig_msg.h> +#include <netatm/uni/unisig_mbuf.h> +#include <netatm/uni/unisig_decode.h> + + +/* + * Local functions + */ +static int unisig_vc_invalid __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act01 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act02 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act03 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act04 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act05 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act06 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act07 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act08 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act09 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act10 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act11 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act12 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act13 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act14 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act15 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act16 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act17 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act18 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act19 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act20 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act21 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act22 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act23 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act24 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act25 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act26 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act27 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act28 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act29 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act30 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_act31 __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)); +static int unisig_vc_clear_call __P((struct unisig *, + struct unisig_vccb *, + struct unisig_msg *, + int)); + + +/* + * State table + */ +static int unisig_vc_states[21][17] = { +/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 */ +{ 0, 2, 99, 5, 99, 99, 0, 99, 12, 99, 0, 14, 0, 3, 0, 0, 0 }, +{ 29, 4, 99, 17, 99, 99, 17, 99, 17, 99, 17, 17, 17, 0, 0, 0, 0 }, +{ 29, 6, 99, 6, 99, 99, 17, 99, 17, 99, 17, 17, 17, 0, 0, 0, 0 }, +{ 29, 17, 99, 17, 99, 99, 17, 99, 10, 99, 17, 17, 17, 0, 0, 0, 0 }, +{ 8, 17, 99, 17, 99, 99, 17, 99, 17, 99, 17, 17, 17, 0, 0, 0, 0 }, +{ 29, 7, 99, 15, 99, 99, 15, 99, 15, 99, 15, 16, 17, 0, 0, 0, 0 }, +{ 19, 3, 99, 3, 99, 99, 3, 99, 3, 99, 3, 13, 3, 0, 0, 0, 0 }, +{ 21, 21, 99, 21, 99, 99, 21, 99, 21, 99, 21, 21, 21, 0, 0, 0, 0 }, +{ 22, 22, 99, 22, 99, 99, 22, 99, 22, 99, 22, 22, 22, 0, 0, 0, 0 }, +{ 29, 17, 99, 17, 99, 99, 17, 99, 17, 99, 23, 17, 17, 0, 0, 0, 0 }, +{ 29, 17, 99, 17, 99, 99, 17, 99, 17, 99, 17, 17, 17, 0, 0, 0, 0 }, +{ 29, 17, 99, 17, 99, 99, 17, 99, 17, 99, 17, 17, 17, 0, 0, 0, 0 }, +{ 29, 17, 99, 17, 99, 99, 17, 99, 17, 99, 17, 17, 17, 0, 0, 0, 0 }, +{ 29, 17, 99, 17, 99, 99, 17, 99, 17, 99, 17, 17, 17, 0, 0, 0, 0 }, +{ 1, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99 }, +{ 99, 25, 99, 25, 99, 99, 9, 99, 25, 99, 25, 25, 25, 25, 31, 25, 25 }, +{ 99, 25, 99, 25, 99, 99, 11, 99, 25, 99, 25, 25, 25, 25, 19, 25, 25 }, +{ 99, 12, 99, 12, 99, 99, 25, 99, 12, 99, 12, 19, 19, 30, 19, 99, 99 }, +{ 99, 12, 99, 12, 99, 99, 12, 99, 12, 99, 12, 3, 3, 3, 24, 26, 26 }, +{ 99, 3, 99, 3, 99, 99, 30, 99, 3, 99, 18, 3, 3, 0, 19, 27, 19 }, +{ 99, 7, 99, 7, 99, 99, 30, 99, 7, 99, 19, 19, 19, 20, 19, 19, 28 } +}; + + +/* + * Action vector + * + * A given state, action pair selects an action number from the + * state table. This vector holds the address of the action routine + * for each action number. + */ +#define MAX_ACTION 32 +static int (*unisig_vc_act_vec[MAX_ACTION]) + __P((struct unisig *, struct unisig_vccb *, + struct unisig_msg *)) = { + unisig_vc_invalid, + unisig_vc_act01, + unisig_vc_act02, + unisig_vc_act03, + unisig_vc_act04, + unisig_vc_act05, + unisig_vc_act06, + unisig_vc_act07, + unisig_vc_act08, + unisig_vc_act09, + unisig_vc_act10, + unisig_vc_act11, + unisig_vc_act12, + unisig_vc_act13, + unisig_vc_act14, + unisig_vc_act15, + unisig_vc_act16, + unisig_vc_act17, + unisig_vc_act18, + unisig_vc_act19, + unisig_vc_act20, + unisig_vc_act21, + unisig_vc_act22, + unisig_vc_act23, + unisig_vc_act24, + unisig_vc_act25, + unisig_vc_act26, + unisig_vc_act27, + unisig_vc_act28, + unisig_vc_act29, + unisig_vc_act30, + unisig_vc_act31 +}; + + +/* + * Process an event on a VC + * + * Arguments: + * usp pointer to the UNISIG instance + * uvp pointer to the VCCB for the affected VCC + * event a numeric indication of which event has occured + * msg pointer to a signalling message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +int +unisig_vc_state(usp, uvp, event, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + int event; + struct unisig_msg *msg; +{ + int action, rc, state; + + /* + * Select an action from the state table + */ + if (uvp) + state = uvp->uv_sstate; + else + state = UNI_NULL; + action = unisig_vc_states[event][state]; + if (action >= MAX_ACTION || action < 0) + panic("unisig_vc_state: invalid action\n"); + + /* + * Perform the requested action + */ + ATM_DEBUG4("unisig_vc_state: uvp=0x%x, state=%d, event=%d, action=%d\n", + (int) uvp, state, event, action); + rc = unisig_vc_act_vec[action](usp, uvp, msg); + + return(rc); +} + + +/* + * VC state machine action 0 + * Unexpected action - log an error message + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection (may + be null) + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_invalid(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + log(LOG_ERR, "unisig_vc_state: unexpected action\n"); + return(EINVAL); +} + + +/* + * VC state machine action 1 + * Setup handler called + * + * Send SETUP, start timer T303, go to UNI_CALL_INITIATED state + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act01(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc; + + /* + * Send the setup message + */ + rc = unisig_send_setup(usp, uvp); + if (rc) + return(rc); + + /* + * Set timer T303 + */ + uvp->uv_retry = 0; + UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T303); + + /* + * Set the new state + */ + uvp->uv_sstate = UNI_CALL_INITIATED; + + /* + * Mark the time + */ + uvp->uv_tstamp = time_second; + + return(0); +} + + +/* + * VC state machine action 2 + * Timeout while waiting for CALL PROCEEDING or CONNECT + * + * If this is the second expiration, clear the call. Otherwise, + * retransmit the SETUP message and restart T303. + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act02(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc = 0; + + if (uvp->uv_retry) { + /* + * Clear the call + */ + rc = unisig_clear_vcc(usp, uvp, + T_ATM_CAUSE_NO_ROUTE_TO_DESTINATION); + } else { + uvp->uv_retry++; + (void) unisig_send_setup(usp, uvp); + UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T303); + } + + return(rc); +} + + +/* + * VC state machine action 3 + * + * Clear the call internally + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act03(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc; + + /* + * Clear the VCCB + */ + rc = unisig_clear_vcc(usp, uvp, + T_ATM_CAUSE_DESTINATION_OUT_OF_ORDER); + + return(rc); +} + + +/* + * VC state machine action 4 + * Received CALL PROCEEDING + * + * Start timer T310, go to UNI_CALL_OUT_PROC + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act04(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int cause, rc, vpi, vci; + struct atm_pif *pip = usp->us_pif; + struct ie_generic *iep; + + /* + * Clear any running timer + */ + UNISIG_VC_CANCEL((struct vccb *) uvp); + + /* + * Make sure a Connection ID is part of the message + */ + if (msg->msg_ie_cnid) { + vpi = msg->msg_ie_cnid->ie_cnid_vpci; + vci = msg->msg_ie_cnid->ie_cnid_vci; + } else { + iep = (struct ie_generic *)atm_allocate(&unisig_iepool); + if (!iep) + return(ENOMEM); + iep->ie_ident = UNI_IE_CNID; + iep->ie_err_cause = UNI_IE_CAUS_MISSING; + MSG_IE_ADD(msg, iep, UNI_MSG_IE_ERR); + cause = UNI_IE_CAUS_MISSING; + ATM_DEBUG0("unisig_vc_act04: no CNID in Call Proc\n"); + goto response04; + } + + /* + * Make sure we can handle the specified VPI and VCI + */ + if (vpi > pip->pif_maxvpi || vci > pip->pif_maxvci || + vci < UNI_IE_CNID_MIN_VCI) { + cause = UNI_IE_CAUS_BAD_VCC; + ATM_DEBUG0("unisig_vc_act04: VPI/VCI invalid\n"); + goto response04; + } + + /* + * Make sure the specified VPI and VCI are not in use + */ + if (unisig_find_vpvc(usp, vpi, vci, VCC_OUT)) { + cause = UNI_IE_CAUS_NA_VCC; + ATM_DEBUG0("unisig_vc_act04: VPI/VCI in use\n"); + goto response04; + } + + /* + * Start timer T310 + */ + UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T310); + + /* + * Save the specified VPI and VCI + */ + uvp->uv_vpi = vpi; + uvp->uv_vci = vci; + + /* + * Set the state + */ + uvp->uv_sstate = UNI_CALL_OUT_PROC; + + /* + * Mark the time + */ + uvp->uv_tstamp = time_second; + + return(0); + +response04: + /* + * Initiate call clearing + */ + rc = unisig_vc_clear_call(usp, uvp, msg, cause); + + return(rc); +} + + +/* + * VC state machine action 5 + * Timeout in UNI_CALL_OUT_PROC + * + * Clear call towards network + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act05(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc; + struct unisig_msg *rls_msg; + struct ie_generic *cause_ie; + + /* + * Send a RELEASE message + */ + rls_msg = (struct unisig_msg *) atm_allocate(&unisig_msgpool); + if (rls_msg == NULL) + return(ENOMEM); + cause_ie = (struct ie_generic *) atm_allocate(&unisig_iepool); + if (cause_ie == NULL) { + atm_free(rls_msg); + return(ENOMEM); + } + + /* + * Fill out the RELEASE message + */ + rls_msg->msg_call_ref = uvp->uv_call_ref; + rls_msg->msg_type = UNI_MSG_RLSE; + rls_msg->msg_type_flag = 0; + rls_msg->msg_type_action = 0; + rls_msg->msg_ie_caus = cause_ie; + + /* + * Fill out the cause IE + */ + cause_ie->ie_caus_loc = UNI_IE_CAUS_LOC_USER; + cause_ie->ie_caus_cause = UNI_IE_CAUS_TIMER; + KM_COPY("310", cause_ie->ie_caus_diagnostic, 3); + + /* + * Send the RELEASE message. + */ + rc = unisig_send_msg(usp, rls_msg); + unisig_free_msg(rls_msg); + + /* + * Start timer T308 + */ + UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T308); + + /* + * Set the new state + */ + uvp->uv_sstate = UNI_RELEASE_REQUEST; + uvp->uv_ustate = VCCU_CLOSED; + + /* + * Mark the time + */ + uvp->uv_tstamp = time_second; + + return(rc); +} + + +/* + * VC state machine action 6 + * Received CONNECT + * + * Send CONNECT ACK, go to UNI_ACTIVE state + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act06(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int cause, rc, vci, vpi; + struct atm_pif *pip = usp->us_pif; + struct unisig_msg *cack_msg; + struct ie_generic *iep; + Atm_attributes *ap; + + /* + * Clear any running timer + */ + UNISIG_VC_CANCEL((struct vccb *) uvp); + + ap = &uvp->uv_connvc->cvc_attr; + + /* + * See if a VPI/VCI is specified + */ + if (msg->msg_ie_cnid) { + /* + * Yes--VPI/VCI must be the first specification or must + * match what was specified before + */ + vpi = msg->msg_ie_cnid->ie_cnid_vpci; + vci = msg->msg_ie_cnid->ie_cnid_vci; + if ((uvp->uv_vpi || uvp->uv_vci) && + (vpi != uvp->uv_vpi || + vci != uvp->uv_vci)) { + cause = UNI_IE_CAUS_BAD_VCC; + ATM_DEBUG0("unisig_vc_act06: VPI/VCI invalid\n"); + goto response06; + } + + /* + * Specified VPI/VCI must be within range + */ + if (vpi > pip->pif_maxvpi || vci > pip->pif_maxvci || + vci < UNI_IE_CNID_MIN_VCI) { + cause = UNI_IE_CAUS_BAD_VCC; + ATM_DEBUG0("unisig_vc_act06: VPI/VCI invalid\n"); + goto response06; + } + uvp->uv_vpi = vpi; + uvp->uv_vci = vci; + } else { + /* + * No--VPI/VCI must have been specified earlier + */ + if (!uvp->uv_vpi || !uvp->uv_vci) { + iep = (struct ie_generic *)atm_allocate( + &unisig_iepool); + if (!iep) + return(ENOMEM); + iep->ie_ident = UNI_IE_CNID; + iep->ie_err_cause = UNI_IE_CAUS_MISSING; + MSG_IE_ADD(msg, iep, UNI_MSG_IE_ERR); + cause = UNI_IE_CAUS_MISSING; + ATM_DEBUG0("unisig_vc_act06: CNID missing\n"); + goto response06; + } + } + + /* + * Handle AAL parameters negotiation + */ + if (msg->msg_ie_aalp) { + struct ie_generic *aalp = msg->msg_ie_aalp; + + /* + * AAL parameters must have been sent in SETUP + */ + if ((ap->aal.tag != T_ATM_PRESENT) || + (ap->aal.type != aalp->ie_aalp_aal_type)) { + cause = UNI_IE_CAUS_IECONTENT; + goto response06; + } + + switch (aalp->ie_aalp_aal_type) { + + case UNI_IE_AALP_AT_AAL3: + /* + * Maximum SDU size negotiation + */ + if (aalp->ie_aalp_4_fwd_max_sdu == T_ATM_ABSENT) + break; + if ((ap->aal.v.aal4.forward_max_SDU_size < + aalp->ie_aalp_4_fwd_max_sdu) || + (ap->aal.v.aal4.backward_max_SDU_size < + aalp->ie_aalp_4_bkwd_max_sdu)) { + cause = UNI_IE_CAUS_IECONTENT; + goto response06; + } else { + ap->aal.v.aal4.forward_max_SDU_size = + aalp->ie_aalp_4_fwd_max_sdu; + ap->aal.v.aal4.backward_max_SDU_size = + aalp->ie_aalp_4_bkwd_max_sdu; + } + break; + + case UNI_IE_AALP_AT_AAL5: + /* + * Maximum SDU size negotiation + */ + if (aalp->ie_aalp_5_fwd_max_sdu == T_ATM_ABSENT) + break; + if ((ap->aal.v.aal5.forward_max_SDU_size < + aalp->ie_aalp_5_fwd_max_sdu) || + (ap->aal.v.aal5.backward_max_SDU_size < + aalp->ie_aalp_5_bkwd_max_sdu)) { + cause = UNI_IE_CAUS_IECONTENT; + goto response06; + } else { + ap->aal.v.aal5.forward_max_SDU_size = + aalp->ie_aalp_5_fwd_max_sdu; + ap->aal.v.aal5.backward_max_SDU_size = + aalp->ie_aalp_5_bkwd_max_sdu; + } + break; + } + } + + /* + * Get memory for a CONNECT ACK message + */ + cack_msg = (struct unisig_msg *) atm_allocate(&unisig_msgpool); + if (cack_msg == NULL) + return(ENOMEM); + + /* + * Fill out the CONNECT ACK message + */ + cack_msg->msg_call_ref = uvp->uv_call_ref; + cack_msg->msg_type = UNI_MSG_CACK; + cack_msg->msg_type_flag = 0; + cack_msg->msg_type_action = 0; + + /* + * Send the CONNECT ACK message + */ + rc = unisig_send_msg(usp, cack_msg); + unisig_free_msg(cack_msg); + + /* + * Set the new state + */ + uvp->uv_sstate = UNI_ACTIVE; + uvp->uv_ustate = VCCU_OPEN; + + /* + * Mark the time + */ + uvp->uv_tstamp = time_second; + + /* + * Notify the user that the connection is now active + */ + atm_cm_connected(uvp->uv_connvc); + + return(0); + +response06: + /* + * Initiate call clearing + */ + rc = unisig_vc_clear_call(usp, uvp, msg, cause); + + return(rc); +} + + +/* + * VC state machine action 7 + * Abort routine called or signalling SAAL session reset while in + * one of the call setup states + * + * Clear the call, send RELEASE COMPLETE, notify the user. + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act07(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc; + + /* + * Clear any running timer + */ + UNISIG_VC_CANCEL((struct vccb *) uvp); + + /* + * Send a RELEASE COMPLETE message rejecting the connection + */ + rc = unisig_send_release_complete(usp, uvp, msg, + UNI_IE_CAUS_TEMP); + + /* + * Clear the call VCCB + */ + uvp->uv_sstate = UNI_FREE; + uvp->uv_ustate = VCCU_CLOSED; + + /* + * Mark the time + */ + uvp->uv_tstamp = time_second; + + /* + * Notify the user + */ + unisig_set_cause_attr(&uvp->uv_connvc->cvc_attr, + T_ATM_CAUSE_NORMAL_CALL_CLEARING); + atm_cm_cleared(uvp->uv_connvc); + + return(rc); +} + + +/* + * VC state machine action 8 + * Received SETUP + * + * Check call paramaters, notify user that a call has been received, + * set UNI_CALL_PRESENT state + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act08(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int cause = 0, rc, vpi, vci; + struct atm_pif *pip = usp->us_pif; + struct atm_nif *nip; + Atm_addr_nsap *nap; + Atm_attributes attr; + + ATM_DEBUG3("unisig_vc_act08: usp=0x%x, uvp=0x%x, msg=0x%x\n", + (int) usp, (int) uvp, (int) msg); + + /* + * Make sure that the called address is the right format + */ + if (msg->msg_ie_cdad->ie_cdad_plan != UNI_IE_CDAD_PLAN_NSAP) { + cause = UNI_IE_CAUS_IECONTENT; + ATM_DEBUG0("unisig_vc_act08: bad address format\n"); + goto response08; + } + + /* + * Make sure that the called address is ours + */ + nap = (Atm_addr_nsap *) msg->msg_ie_cdad->ie_cdad_addr.address; + if (bcmp(usp->us_addr.address, nap, /* XXX */ + sizeof(Atm_addr_nsap)-1)) { + cause = UNI_IE_CAUS_IECONTENT; + ATM_DEBUG0("unisig_vc_act08: address not mine\n"); + goto response08; + } + + /* + * Find the right NIF for the given selector byte + */ + nip = pip->pif_nif; + while (nip && nip->nif_sel != nap->aan_sel) { + nip = nip->nif_pnext; + } + if (!nip) { + cause = UNI_IE_CAUS_IECONTENT; + ATM_DEBUG0("unisig_vc_act08: bad selector byte\n"); + goto response08; + } + + /* + * See if we can handle the specified encapsulation + */ + if (msg->msg_ie_blli->ie_blli_l2_id != UNI_IE_BLLI_L2P_LLC && + (msg->msg_ie_blli->ie_blli_l2_id != 0 || + msg->msg_ie_blli->ie_blli_l3_id != + UNI_IE_BLLI_L3P_ISO9577)) { + cause = UNI_IE_CAUS_UNAVAIL; + ATM_DEBUG0("unisig_vc_act08: bad encapsulation\n"); + goto response08; + } + + /* + * See if we recognize the specified AAL + */ + if (msg->msg_ie_aalp->ie_aalp_aal_type != UNI_IE_AALP_AT_AAL3 && + msg->msg_ie_aalp->ie_aalp_aal_type != + UNI_IE_AALP_AT_AAL5) { + cause = UNI_IE_CAUS_UAAL; + ATM_DEBUG0("unisig_vc_act08: bad AAL\n"); + goto response08; + } + + /* + * Should verify that we can handle requested + * connection QOS + */ + + /* + * Make sure the specified VPI/VCI is valid + */ + vpi = msg->msg_ie_cnid->ie_cnid_vpci; + vci = msg->msg_ie_cnid->ie_cnid_vci; + if (vpi > pip->pif_maxvpi || + vci > pip->pif_maxvci || + vci < UNI_IE_CNID_MIN_VCI) { + cause = UNI_IE_CAUS_BAD_VCC; + ATM_DEBUG0("unisig_vc_act08: VPI/VCI invalid\n"); + goto response08; + } + + /* + * Make sure the specified VPI/VCI isn't in use already + */ + if (unisig_find_vpvc(usp, vpi, vci, VCC_IN)) { + cause = UNI_IE_CAUS_NA_VCC; + ATM_DEBUG0("unisig_vc_act08: VPI/VCI in use\n"); + goto response08; + } + + /* + * Make sure it's a point-to-point connection + */ + if (msg->msg_ie_bbcp->ie_bbcp_conn_config != + UNI_IE_BBCP_CC_PP) { + cause = UNI_IE_CAUS_NI_BC; + ATM_DEBUG0("unisig_vc_act08: conn not pt-pt\n"); + goto response08; + } + + /* + * Fill in the VCCB fields that we can at this point + */ + uvp->uv_type = VCC_SVC | VCC_IN | VCC_OUT; + uvp->uv_proto = pip->pif_sigmgr->sm_proto; + uvp->uv_sstate = UNI_CALL_PRESENT; + uvp->uv_ustate = VCCU_POPEN; + uvp->uv_pif = pip; + uvp->uv_nif = nip; + uvp->uv_vpi = msg->msg_ie_cnid->ie_cnid_vpci; + uvp->uv_vci = msg->msg_ie_cnid->ie_cnid_vci; + uvp->uv_tstamp = time_second; + + /* + * Copy the connection attributes from the SETUP message + * to an attribute block + */ + KM_ZERO(&attr, sizeof(attr)); + attr.nif = nip; + attr.aal.tag = T_ATM_ABSENT; + attr.traffic.tag = T_ATM_ABSENT; + attr.bearer.tag = T_ATM_ABSENT; + attr.bhli.tag = T_ATM_ABSENT; + attr.blli.tag_l2 = T_ATM_ABSENT; + attr.blli.tag_l3 = T_ATM_ABSENT; + attr.llc.tag = T_ATM_ABSENT; + attr.called.tag = T_ATM_ABSENT; + attr.calling.tag = T_ATM_ABSENT; + attr.qos.tag = T_ATM_ABSENT; + attr.transit.tag = T_ATM_ABSENT; + attr.cause.tag = T_ATM_ABSENT; + unisig_save_attrs(usp, msg, &attr); + + /* + * Notify the connection manager of the new VCC + */ + ATM_DEBUG0("unisig_vc_act08: notifying user of connection\n"); + rc = atm_cm_incoming((struct vccb *)uvp, &attr); + if (rc) + goto response08; + + /* + * Wait for the connection recipient to issue an accept + * or reject + */ + return(0); + +response08: + ATM_DEBUG1("unisig_vc_act08: reject with cause=%d\n", cause); + + /* + * Clear the VCCB state + */ + uvp->uv_sstate = UNI_NULL; + + /* + * Mark the time + */ + uvp->uv_tstamp = time_second; + + /* + * Some problem was detected with the request. Send a Q.2931 + * message rejecting the connection. + */ + rc = unisig_send_release_complete(usp, uvp, msg, cause); + + return(rc); +} + + +/* + * VC state machine action 9 + * Accept routine called by user + * + * Send CONNECT, start timer T313, go to UNI_CONNECT_REQUEST state + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act09(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc; + struct unisig_msg *conn_msg; + + conn_msg = (struct unisig_msg *) atm_allocate(&unisig_msgpool); + if (conn_msg == NULL) + return(ENOMEM); + + /* + * Fill out the response + */ + conn_msg->msg_call_ref = uvp->uv_call_ref; + conn_msg->msg_type = UNI_MSG_CONN; + conn_msg->msg_type_flag = 0; + conn_msg->msg_type_action = 0; + + /* + * Send the CONNECT message. If the send fails, the other + * side will eventually time out and close the connection. + */ + rc = unisig_send_msg(usp, conn_msg); + unisig_free_msg(conn_msg); + if (rc) { + return(rc); + } + + /* + * Start timer T313 + */ + UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T313); + + /* + * Set the new state + */ + uvp->uv_sstate = UNI_CONNECT_REQUEST; + + /* + * Mark the time + */ + uvp->uv_tstamp = time_second; + + return(0); +} + + +/* + * VC state machine action 10 + * Received CONNECT ACK + * + * Go to UNI_ACTIVE state + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act10(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + /* + * Clear any running timer + */ + UNISIG_VC_CANCEL((struct vccb *) uvp); + + /* + * Set the state + */ + uvp->uv_sstate = UNI_ACTIVE; + uvp->uv_ustate = VCCU_OPEN; + + /* + * Mark the time + */ + uvp->uv_tstamp = time_second; + + /* + * Notify the user that the call is up + */ + atm_cm_connected(uvp->uv_connvc); + + return (0); +} + + +/* + * VC state machine action 11 + * Reject handler called + * + * Send RELEASE COMPLETE, clear the call + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act11(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc; + + /* + * Send a RELEASE COMPLETE message + */ + rc = unisig_send_release_complete(usp, uvp, msg, + UNI_IE_CAUS_REJECT); + + /* + * Clear the call VCCB + */ + uvp->uv_sstate = UNI_FREE; + uvp->uv_ustate = VCCU_CLOSED; + + /* + * Mark the time + */ + uvp->uv_tstamp = time_second; + + return(rc); +} + + +/* + * VC state machine action 12 + * Release or abort routine called + * + * Send RELEASE, start timer T308, go to UNI_RELEASE_REQUEST state + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act12(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc; + + /* + * Clear any running timer + */ + UNISIG_VC_CANCEL((struct vccb *) uvp); + + /* + * Send the RELEASE message + */ + rc = unisig_vc_clear_call(usp, uvp, (struct unisig_msg *)0, + T_ATM_ABSENT); + + return(rc); +} + + +/* + * VC state machine action 13 + * RELEASE COMPLETE received + * + * Clear the call + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act13(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + /* + * Clear any running timer + */ + UNISIG_VC_CANCEL((struct vccb *) uvp); + + /* + * Set the state + */ + uvp->uv_sstate = UNI_FREE; + if (uvp->uv_ustate != VCCU_ABORT) + uvp->uv_ustate = VCCU_CLOSED; + + /* + * Mark the time + */ + uvp->uv_tstamp = time_second; + + /* + * Notify the user that the call is now closed + */ + unisig_set_cause_attr(&uvp->uv_connvc->cvc_attr, + T_ATM_CAUSE_NORMAL_CALL_CLEARING); + atm_cm_cleared(uvp->uv_connvc); + + return(0); +} + + +/* + * VC state machine action 14 + * Timer expired while waiting for RELEASE COMPLETE + * + * If this is the second expiration, just clear the call. Otherwise, + * retransmit the RELEASE message and restart timer T308. + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act14(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc; + + /* + * Check the retry count + */ + if (uvp->uv_retry) { + /* + * Clear the connection + */ + rc = unisig_clear_vcc(usp, uvp, + T_ATM_CAUSE_NORMAL_CALL_CLEARING); + } else { + /* + * Increment the retry count + */ + uvp->uv_retry++; + + /* + * Resend the RELEASE message + */ + rc = unisig_send_release(usp, uvp, + (struct unisig_msg *)0, T_ATM_ABSENT); + if (rc) + return(rc); + + /* + * Restart timer T308 + */ + UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T308); + } + + return(0); +} + + +/* + * VC state machine action 15 + * RELEASE received in UNI_ACTIVE state + * + * Send RELEASE COMPLETE, go to UNI_FREE, notify the user + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act15(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int cause, rc; + struct ie_generic *iep; + + /* + * Clear any running timer + */ + UNISIG_VC_CANCEL((struct vccb *) uvp); + + /* + * If there was no Cause IE, flag an error + */ + if (!msg->msg_ie_caus) { + cause = UNI_IE_CAUS_MISSING; + for (iep=msg->msg_ie_err; iep; iep=iep->ie_next) { + if (iep->ie_ident == UNI_IE_CAUS && + iep->ie_err_cause == + UNI_IE_CAUS_IECONTENT) { + cause = UNI_IE_CAUS_IECONTENT; + } + } + if (cause == UNI_IE_CAUS_MISSING) { + iep = (struct ie_generic *)atm_allocate( + &unisig_iepool); + if (!iep) + return(ENOMEM); + iep->ie_ident = UNI_IE_CNID; + iep->ie_err_cause = UNI_IE_CAUS_MISSING; + MSG_IE_ADD(msg, iep, UNI_MSG_IE_ERR); + } + } else { + cause = UNI_IE_CAUS_NORM_UNSP; + } + + /* + * Send a RELEASE COMPLETE message + */ + rc = unisig_send_release_complete(usp, uvp, msg, cause); + + /* + * Set the state + */ + uvp->uv_sstate = UNI_FREE; + uvp->uv_ustate = VCCU_CLOSED; + + /* + * Mark the time + */ + uvp->uv_tstamp = time_second; + + /* + * Notify the user that the call is cleared + */ + unisig_set_cause_attr(&uvp->uv_connvc->cvc_attr, + T_ATM_CAUSE_NORMAL_CALL_CLEARING); + atm_cm_cleared(uvp->uv_connvc); + + return(rc); +} + + +/* + * VC state machine action 16 + * RELEASE received in UNI_RELEASE_REQUEST state + * + * Clear the call + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act16(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc; + + /* + * Clear any running timer + */ + UNISIG_VC_CANCEL((struct vccb *) uvp); + + /* + * Clear the VCCB + */ + rc = unisig_clear_vcc(usp, uvp, + T_ATM_CAUSE_NORMAL_CALL_CLEARING); + + return(rc); +} + + +/* + * VC state machine action 17 + * Protocol error + * + * Send a STATUS message with cause 101, "message not compatible with + * call state" + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act17(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc; + + ATM_DEBUG3("unisig_vc_perror: usp=0x%x, uvp=0x%x, msg=0x%x\n", + (int) usp, (int) uvp, (int) msg); + + /* + * Clear any running timer + */ + UNISIG_VC_CANCEL((struct vccb *) uvp); + + /* + * Send a STATUS message + */ + rc = unisig_send_status(usp, uvp, msg, UNI_IE_CAUS_STATE); + + return(rc ? rc : EINVAL); +} + + +/* + * VC state machine action 18 + * Signalling AAL connection has been lost + * + * Start timer T309. If the timer expires before the SAAL connection + * comes back, the VCC will be cleared. + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act18(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + /* + * Clear any running timer + */ + UNISIG_VC_CANCEL((struct vccb *) uvp); + + /* + * Start timer T309 + */ + UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T309); + + /* + * Set new state + */ + uvp->uv_sstate = UNI_SSCF_RECOV; + + return(0); +} + + +/* + * VC state machine action 19 + * Ignore the event + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act19(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + return(0); +} + + +/* + * VC state machine action 20 + * SSCF establish indication in UNI_SSCF_RECOV state -- signalling + * AAL has come up after an outage + * + * Send STATUS ENQ to make sure we're in compatible state with other end + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act20(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc; + struct unisig_msg *stat_msg; + + /* + * Clear any running timer + */ + UNISIG_VC_CANCEL((struct vccb *) uvp); + + /* + * Get memory for a STATUS ENQUIRY message + */ + stat_msg = (struct unisig_msg *)atm_allocate(&unisig_msgpool); + if (stat_msg == NULL) + return(ENOMEM); + + /* + * Fill out the message + */ + stat_msg->msg_call_ref = uvp->uv_call_ref; + stat_msg->msg_type = UNI_MSG_SENQ; + stat_msg->msg_type_flag = 0; + stat_msg->msg_type_action = 0; + + /* + * Send the STATUS ENQUIRY message + */ + rc = unisig_send_msg(usp, stat_msg); + unisig_free_msg(stat_msg); + + /* + * Return to active state + */ + uvp->uv_sstate = UNI_ACTIVE; + + return(rc); +} + + +/* + * VC state machine action 21 + * STATUS received + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection (may + * be NULL) + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act21(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int cause, rc; + + /* + * Ignore a STATUS message with the global call reference + */ + if (GLOBAL_CREF(msg->msg_call_ref)) { + return(0); + } + + /* + * If the network thinks we're in NULL state, clear the VCC + */ + if (msg->msg_ie_clst->ie_clst_state == UNI_NULL) { + if (uvp) { + (void)unisig_clear_vcc(usp, uvp, + T_ATM_CAUSE_DESTINATION_OUT_OF_ORDER); + } + return(0); + } + + /* + * If we are in NULL state, send a RELEASE COMPLETE + */ + if (!uvp || (uvp->uv_sstate == UNI_FREE) || + (uvp->uv_sstate == UNI_NULL)) { + rc = unisig_send_release_complete(usp, + uvp, msg, UNI_IE_CAUS_STATE); + return(rc); + } + + /* + * If the reported state doesn't match our state, close the VCC + * unless we're in UNI_RELEASE_REQUEST or UNI_RELEASE_IND + */ + if (msg->msg_ie_clst->ie_clst_state != uvp->uv_sstate) { + if (uvp->uv_sstate == UNI_RELEASE_REQUEST || + uvp->uv_sstate == UNI_RELEASE_IND) { + return(0); + } + rc = unisig_clear_vcc(usp, uvp, + T_ATM_CAUSE_NORMAL_CALL_CLEARING); + } + + /* + * States match, check for an error on one of our messages + */ + cause = msg->msg_ie_caus->ie_caus_cause; + if (cause == UNI_IE_CAUS_MISSING || + cause == UNI_IE_CAUS_MTEXIST || + cause == UNI_IE_CAUS_IEEXIST || + cause == UNI_IE_CAUS_IECONTENT || + cause == UNI_IE_CAUS_STATE) { + ATM_DEBUG2("unisig_vc_act21: error %d on message 0x%x\n", + cause, + msg->msg_ie_caus->ie_caus_diagnostic[0]); + if (uvp) { + (void)unisig_clear_vcc(usp, uvp, + T_ATM_CAUSE_INVALID_INFO_ELEMENT_CONTENTS); + } + } + + return(0); +} + + +/* + * VC state machine action 22 + * Received STATUS ENQ + * + * Send STATUS with cause 30 "response to STATUS ENQUIRY" and + * current state + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection (may + * be NULL) + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act22(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc; + struct unisig_msg *status; + struct ie_generic *callst_ie, *cause_ie; + + ATM_DEBUG3("unisig_vc_perror: usp=0x%x, uvp=0x%x, msg=0x%x\n", + (int) usp, (int) uvp, (int) msg); + + /* + * Get memory for a STATUS message + */ + status = (struct unisig_msg *) atm_allocate(&unisig_msgpool); + if (status == NULL) + return(ENOMEM); + callst_ie = (struct ie_generic *) atm_allocate(&unisig_iepool); + if (callst_ie == NULL) { + atm_free(status); + return(ENOMEM); + } + cause_ie = (struct ie_generic *) atm_allocate(&unisig_iepool); + if (cause_ie == NULL) { + atm_free(status); + atm_free(callst_ie); + return(ENOMEM); + } + + /* + * Fill out the response + */ + if (uvp) { + status->msg_call_ref = uvp->uv_call_ref; + } else if (msg) { + if (msg->msg_call_ref & UNI_MSG_CALL_REF_RMT) + status->msg_call_ref = msg->msg_call_ref & + UNI_MSG_CALL_REF_MASK; + else + status->msg_call_ref = msg->msg_call_ref | + UNI_MSG_CALL_REF_RMT; + } else { + status->msg_call_ref = UNI_MSG_CALL_REF_GLOBAL; + } + status->msg_type = UNI_MSG_STAT; + status->msg_type_flag = 0; + status->msg_type_action = 0; + status->msg_ie_clst = callst_ie; + status->msg_ie_caus = cause_ie; + + /* + * Fill out the call state IE + */ + callst_ie->ie_ident = UNI_IE_CLST; + callst_ie->ie_coding = 0; + callst_ie->ie_flag = 0; + callst_ie->ie_action = 0; + if (uvp) { + switch(uvp->uv_sstate) { + case UNI_FREE: + callst_ie->ie_clst_state = UNI_NULL; + break; + default: + callst_ie->ie_clst_state = uvp->uv_sstate; + } + } else { + callst_ie->ie_clst_state = UNI_NULL; + } + + /* + * Fill out the cause IE + */ + cause_ie->ie_ident = UNI_IE_CAUS; + cause_ie->ie_coding = 0; + cause_ie->ie_flag = 0; + cause_ie->ie_action = 0; + cause_ie->ie_caus_loc = UNI_IE_CAUS_LOC_USER; + cause_ie->ie_caus_cause = UNI_IE_CAUS_SENQ; + + /* + * Send the STATUS message + */ + rc = unisig_send_msg(usp, status); + unisig_free_msg(status); + return(rc); +} + + +/* + * VC state machine action 23 + * Received ADD PARTY + * + * We don't support multipoint connections, so send an ADD PARTY REJECT + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act23(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc; + struct unisig_msg *apr_msg; + + /* + * Get memory for the ADD PARTY REJECT message + */ + apr_msg = (struct unisig_msg *) atm_allocate(&unisig_msgpool); + if (apr_msg == NULL) + return(ENOMEM); + + /* + * Fill out the message + */ + if (msg->msg_call_ref & UNI_MSG_CALL_REF_RMT) + apr_msg->msg_call_ref = msg->msg_call_ref & + UNI_MSG_CALL_REF_MASK; + else + apr_msg->msg_call_ref = msg->msg_call_ref | + UNI_MSG_CALL_REF_RMT; + apr_msg->msg_type = UNI_MSG_ADPR; + apr_msg->msg_type_flag = 0; + apr_msg->msg_type_action = 0; + + /* + * Use the endpoint reference IE from the received message + */ + apr_msg->msg_ie_eprf = msg->msg_ie_eprf; + + /* + * Send the ADD PARTY REJECT message + */ + rc = unisig_send_msg(usp, apr_msg); + apr_msg->msg_ie_eprf = NULL; + unisig_free_msg(apr_msg); + + return(rc); +} + + +/* + * VC state machine action 24 + * User error + * + * Return EALREADY + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act24(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + return(EALREADY); +} + + +/* + * VC state machine action 25 + * User error + * + * Return EINVAL + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act25(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + return(EINVAL); +} + + +/* + * VC state machine action 26 + * PVC abort + * + * The abort handler was called to abort a PVC. Clear the VCCB and + * notify the user. + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act26(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc; + + /* + * Clear any running timer + */ + UNISIG_VC_CANCEL((struct vccb *) uvp); + + /* + * Close the VCCB + */ + rc = unisig_close_vcc(usp, uvp); + if (rc) + return(rc); + + /* + * Notify the user + */ + unisig_set_cause_attr(&uvp->uv_connvc->cvc_attr, + T_ATM_CAUSE_NORMAL_CALL_CLEARING); + atm_cm_cleared(uvp->uv_connvc); + + return(0); +} + + +/* + * VC state machine action 27 + * Signalling AAL failure + * + * Change PVC state to UNI_PVC_ACT_DOWN. + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act27(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + /* + * Set the state + */ + uvp->uv_sstate = UNI_PVC_ACT_DOWN; + + /* + * Mark the time + */ + uvp->uv_tstamp = time_second; + + return(0); +} + + +/* + * VC state machine action 28 + * Signalling AAL established + * + * Set PVC state to UNI_PVC_ACTIVE. + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act28(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + /* + * Set the state + */ + uvp->uv_sstate = UNI_PVC_ACTIVE; + + /* + * Mark the time + */ + uvp->uv_tstamp = time_second; + + return(0); +} + + +/* + * VC state machine action 29 + * Protocol error + * + * Send a RELEASE COMPLETE message with cause 81, "invalid call + * reference value" + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection (may + * be NULL) + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act29(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + int rc; + + /* + * Send a RELEASE COMPLETE message + */ + rc = unisig_send_release_complete(usp, uvp, msg, + UNI_IE_CAUS_CREF); + + return(rc); +} + + +/* + * VC state machine action 30 + * Release routine called while SSCF session down, or SSCF session + * reset or lost while in UNI_CALL_PRESENT + * + * Go to UNI_FREE state + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act30(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + /* + * Clear any running timer + */ + UNISIG_VC_CANCEL((struct vccb *) uvp); + + /* + * Clear the call state + */ + uvp->uv_sstate = UNI_FREE; + uvp->uv_ustate = VCCU_CLOSED; + + /* + * Mark the time + */ + uvp->uv_tstamp = time_second; + + return(0); +} + + +/* + * VC state machine action 31 + * Accept handler called in UNI_FREE state. + * + * The call was in UNI_CALL_PRESENT state when it was closed because + * of an SSCF failure. Return an error indication. The accept + * handler will free the VCCB and return the proper code to the + * caller. + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to a UNISIG message structure + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_act31(usp, uvp, msg) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; +{ + return(ENETDOWN); +} + + +/* + * Initiate clearing a call by sending a RELEASE message. + * + * Arguments: + * usp pointer to protocol instance block + * uvp pointer to the VCCB for the affected connection + * msg pointer to UNI signalling message that the RELEASE + * responds to (may be NULL) + * cause the reason for clearing the call; a value of + * T_ATM_ABSENT indicates that the cause code is + * in the VCC's ATM attributes block + * + * Returns: + * 0 success + * errno error encountered + * + */ +static int +unisig_vc_clear_call(usp, uvp, msg, cause) + struct unisig *usp; + struct unisig_vccb *uvp; + struct unisig_msg *msg; + int cause; +{ + int rc; + + /* + * Clear the retry count + */ + uvp->uv_retry = 0; + + /* + * Make sure the ATM attributes block has a valid cause code, + * if needed + */ + if (cause == T_ATM_ABSENT && + uvp->uv_connvc->cvc_attr.cause.tag != + T_ATM_PRESENT) { + uvp->uv_connvc->cvc_attr.cause.tag = T_ATM_PRESENT; + uvp->uv_connvc->cvc_attr.cause.v.coding_standard = + T_ATM_ITU_CODING; + uvp->uv_connvc->cvc_attr.cause.v.location = + T_ATM_LOC_USER; + uvp->uv_connvc->cvc_attr.cause.v.cause_value = + usp->us_proto == ATM_SIG_UNI30 ? + T_ATM_CAUSE_UNSPECIFIED_NORMAL : + T_ATM_CAUSE_NORMAL_CALL_CLEARING; + } + + /* + * Send a RELEASE message + */ + rc = unisig_send_release(usp, uvp, msg, cause); + if (rc) + return(rc); + + /* + * Start timer T308 + */ + UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T308); + + /* + * Set the VCCB state + */ + uvp->uv_sstate = UNI_RELEASE_REQUEST; + if (uvp->uv_ustate != VCCU_ABORT) + uvp->uv_ustate = VCCU_CLOSED; + + /* + * Mark the time + */ + uvp->uv_tstamp = time_second; + + return(0); +} |
