r64_message_ie.h

wimax bs模拟器

{
    BYTE id[R64_MSID_LENGTH];  /*type: 102, len: 6 byte,value: Any valid MAC address,comments:The MAC address of the MS*/
}R64_MS_ID_S;

typedef struct _R64_MS_NAI_
{
    WORD length;
    BYTE nai[R64_MAX_MS_NAI_LEN];  /*type: 1, len: 256(max) bytes,value: Any String in UTF format.,comments:NAI of user*/
}R64_MS_NAI_S;

typedef struct _R64_BS_ID_
{
    BYTE id[R64_BSID_LENGTH]; /*type:2, len: 6 bytes,value: Any binary string,comments:6 byte BS identifier*/
}R64_BS_ID_S;

typedef struct _R64_SFID_
{
    DWORD id; /*type : 4, len: 4   bytes,value: 0~4G,comments:Uniquely identifies a SF for a MS.*/
}R64_SFID_S;

typedef struct _R64_CAUSE_CODE_
{
    DWORD code; /*type:6, len: 4 bytes,value: see R64_CAUSE_CODE_E,comments:Identifies reason why a message was rejected*/
}R64_CAUSE_CODE_S;

typedef struct _R64_REGISTRATION_TYPE_
{
    DWORD type; /*type:7, len: 4 bytes,value: see R64_REGISTRATION_TYPE_E,comments:Identifies the registration type*/
}R64_REGISTRATION_TYPE_S;

typedef struct _R64_CS_TYPE_
{
    BYTE type; /*type:9, len: 1 bytes,value: see R64_CS_TYPE_E,comments:The convergence sublayer type*/
}R64_CS_TYPE_S;

typedef struct _R64_KEY_SN_
{
    BYTE type; /*type:10, len: 1 bytes,value: 2-bit sequence number (TEK)
    4-bit sequence number (AK)
    ,comments:The convergence sublayer type*/
}R64_KEY_SN_S;

typedef struct _R64_GW_ID_
{
    DWORD id;            /*type:11, len: 4 bytes,value: valid IP address,comments:Unique identifier for the Anchor GW / Anchor Data Path Function.
                        The Identifier might be in format of either 4-octet IPv4 Address, 6 -octet IEEE 802.16 BS ID or 16-octet IPv6 Address. The length defines also the format of the Identifier. 
                        */
}R64_GW_ID_S,
R64_PDF_ID_S;

typedef struct _R64_ANCHOR_GW_INFO_
{
    R64_GW_ID_S gwId; /*type:103, len: variable bytes,value: N /A,comments:Compound TLV consisting of the following TLVs
                        "    Anchor GW ID and Anchor DPF ID
                        */
}R64_ANCHOR_GW_INFO_S;

typedef struct _R64_ANCHOR_AUTHENTICATOR_ID_
{
    DWORD id;            /*type:12, len: 4 bytes,value: valid IP address,comments:Unique identifier for the authenticator. */
}R64_ANCHOR_AUTHENTICATOR_ID_S;

typedef struct _R64_AK_
{
    BYTE  ak[20];            /*type:14, len: 20 bytes,value: Any binary string,comments:160 bit AK value*/
}R64_AK_S;

typedef struct _R64_AK_ID_
{
    BYTE id[8];                /*type:15, len: 8 bytes,value: Any binary string,comments:64 bit AK ID*/
}R64_AK_ID_S;

typedef struct _R64_AK_LIFE_TIME_
{
    WORD lifeTime;        /*type:16, len: 2 bytes,value: 0~65535,comments:16 bit AK lifetime*/
}R64_AK_LIFE_TIME_S;

typedef struct _R64_AK_SN_
{
    BYTE sn;                /*type:17, len: 1 bytes,value: 0~255,comments:8 bit AK sequence number*/
}R64_AK_SN_S;

typedef struct _R64_EAP_MESSAGE_
{
    WORD msgLen;
    BYTE message[R64_MAX_EAP_MESSAGE_LEN]; /*type:19, len:512(max)  bytes,value: Any binary string,comments:EAP payload between MS and AAA*/
}R64_EAP_MESSAGE_S;


typedef struct _R64_PACKET_CLASSIFIER_RULE_PRIORITY_
{
    BYTE priority;        /*type:23, len: 1 bytes,value:0~255, comments:
                        Priority of classification rule. 0 is the highest and 255 the lowest.*/
}R64_PACKET_CLASSIFIER_RULE_PRIORITY_S;

typedef struct _R64_DSCP_RANG_AND_MASK_
{
    BYTE dscp[3];        /*type: 24, len: 3 bytes,value: Any binary string, comments: The value field is structured as follows:
                        "    Lower Limit - 1 byte
                        "    Higher Limit - 1 byte
                        "    Mask - 1 byte
                        The values of the field specify the matching parameters for the IP type of service/DSCP [IETF RFC 2474] byte range and mask. An IP packet with IP type of service (ToS) byte value "ip-tos" matches this parameter if tos-low less than or equal (ip-tos AND tos-mask) less than or equal tos-high. If this field is omitted, then comparison of the IP packet ToS byte for this entry is irrelevant
                        */
}R64_DSCP_RANG_AND_MASK_S;

typedef struct _R64_IP_PROTOCOL_
{
    WORD num;
    WORD protocol[R64_MAX_IP_ADDR_NUM];        /*type: 25, len: N*2 bytes(N<=R64_MAX_IP_ADDR_NUM),value: see R64_IP_PROTOCOL_TYPE_E, comments:List of 2 byte IP protocols*/
}R64_IP_PROTOCOL_S;

typedef struct _R64_IP_AND_MASK_
{
    DWORD ipAddr;
    DWORD mask;
}R64_IP_AND_MASK_S;

typedef struct _R64_SOURCE_ADDRESS_AND_MASK_
{
    WORD num;
    R64_IP_AND_MASK_S addr[R64_MAX_IP_ADDR_NUM];        /*type: 26, len: N*8 bytes(N<=R64_MAX_IP_ADDR_NUM),value: Any IP address and netmask, comments:List of {4 byte IP address followed by 4 byte IP mask }*/
}R64_SOURCE_ADDRESS_AND_MASK_S;

typedef struct _R64_DESTINATION_ADDRESS_AND_MASK_
{
    WORD num;
    R64_IP_AND_MASK_S addr[R64_MAX_IP_ADDR_NUM];        /*type: 27, len: N*8 bytes(N<=R64_MAX_IP_ADDR_NUM),value: Any IP address and netmask, comments:List of {4 byte IP address followed by 4 byte IP mask }*/
}R64_DESTINATION_ADDRESS_AND_MASK_S;


typedef struct _R64_SOURCE_PORT_RANGE_
{
    WORD num;
    DWORD  port[R64_MAX_IP_ADDR_NUM];        /*type: 28, len: N*4 bytes(N<=R64_MAX_IP_ADDR_NUM),value: Any integer, comments:List of {2 byte lower port followed by 2 byte upper port }*/
}R64_SOURCE_PORT_RANGE_S;

typedef struct _R64_DESTINATION_PORT_RANGE_
{
    WORD num;
    DWORD  port[R64_MAX_IP_ADDR_NUM];        /*type: 29, len: N*4 bytes(N<=R64_MAX_IP_ADDR_NUM),value: Any integer, comments:List of {2 byte lower port followed by 2 byte upper port }*/
}R64_DESTINATION_PORT_RANGE_S;

typedef struct _R64_TRAFIC_PRIORITY_
{
    BYTE priority;        /*type:31, len: 1 bytes,value:0~7 , comments:Higher numbers indicate higher priority. 
            Default 0.
            The value of this parameter specifies the priority assigned to a service flow. Given two service flows identical in all QoS parameters besides priority, the higher priority service flow should be given lower delay and higher buffering preference. For otherwise non-identical service flows, the priority parameter should not take precedence over any conflicting service flow QoS parameter. The specific algorithm for enforcing this parameter is not mandated here.
            */
}R64_TRAFIC_PRIORITY_S;

typedef struct _R64_MAXIMAM_SUSTAINED_TRAFIC_RATE_
{
    DWORD rate;        /*type: 32, len: 4 bytes,value: 0~4G , comments:32-bit integer representing rate (in bits per second).
                    This parameter defines the peak information rate of the service. The rate is expressed in bits per second and pertains to the SDUs at the input to the system. Explicitly, this parameter does not include MAC overhead such as MAC headers or CRCs. This parameter does not limit the instantaneous rate of the service since this is governed by the physical attributes of the ingress port. If this parameter is omitted or set to zero, then there is no explicitly mandated maximum rate. This field specifies only a bound, not a guarantee that the rate is available. The algorithm for policing to this parameter is left to vendor differentiation and is outside the scope of the standard.*/
}R64_MAXIMAM_SUSTAINED_TRAFIC_RATE_S;

typedef struct _R64_MINIMAM_RESERVED_TRAFIC_RATE_
{
    DWORD rate;        /*type:34, len: 4 bytes,value: 32-bit unsigned 
                    integer representing rate (in bits per second). , 
                    comments:This parameter specifies the minimum rate reserved for this service flow. 
                    The rate is expressed in bits per second and specifies the minimum amount of data to be transported on behalf of the service flow when averaged over time. The specified rate shall only be honored when sufficient data is available for scheduling. When insufficient data exists, the requirement imposed by this parameter shall be satisfied by assuring the available data is transmitted as soon as possible.*/
}R64_MINIMAM_RESERVED_TRAFIC_RATE_S;

typedef struct _R64_MAXIMAM_LATENCY_
{
    DWORD latency;        /*type:35, len: 4 bytes,value: 32-bit integer specifies the maximum latency (in milliseconds), comments:Time period between the reception of a packet by the BS or MS on its network interface and the delivering the packet to the RF Interface of the peer device. If defined, this parameter represents a service commitment (or admission criteria) at the BS or MS and shall be guaranteed by the BS or MS. A BS or MS does not have to meet this service commitment for service flows that exceed their minimum reserved rate. */
}R64_MAXIMAM_LATENCY_S;


typedef struct _CARE_OF_ADDRESS_
{
    DWORD address;        /*4 bytes*/
}CARE_OF_ADDRESS_S;

typedef struct _R64_CID_
{
    WORD cid;        /*2 bytes*/
}R64_CID_S;

typedef struct _R64_CLASSIFIER_ACTION_
{
    BYTE    action; /*1 byte,see R64_CLASSIFIER_ACTION_E*/
}R64_CLASSIFIER_ACTION_S;

typedef struct _R64_TOLERATED_JITTER_
{
    DWORD jitter;        /*type:36, len:4 bytes,value:32-bit unsigned integer representing the maximum delay variation (jitter) (in milliseconds).  , comments:O (omission means jitter equal to maximum latency)*/
}R64_TOLERATED_JITTER_S;

typedef struct _R64_SDU_SIZE_
{
    BYTE size;        /*type:37, len:1 bytes,value: 8-bit unsigned integer. Default = 49, comments:Represents the number of bytes in the fixed size SDU
                        O (omission means variable size SDU)
                        */
}R64_SDU_SIZE_S;


typedef struct _R64_UNSOLICITED_GRANT_INTERVAL_
{
    WORD interval;        /*type:39, len:?? bytes,value: ??, comments:??*/
}R64_UNSOLICITED_GRANT_INTERVAL_S;

typedef struct _R64_MAXIMAM_TRAFIC_BURST_
{
    DWORD num;        /*type:40, len: 4 bytes,value:32-bit integer representing burst size (in bytes). , comments:This parameter defines the maximum burst size that shall be accommodated for the service. Since the physical speed of ingress/egress ports, the air interface, and the backhaul will in general be greater than the maximum sustained traffic rate parameter for a service, this parameter describes the maximum continuous burst the system should accommodate for the service assuming the service is not currently using any of its available resources. */
}R64_MAXIMAM_TRAFIC_BURST_S;

typedef struct _R64_SERVICE_FLOW_TYPE_
{
    BYTE type;        /*type:42, len:1 bytes,value: see R64_SERVICE_FLOW_TYPE_E, comments:The value of this parameter specifies the scheduling service that shall be enabled for the associated Service Flow. If the parameter is omitted, BE service is assumed. Scheduling type is encoded as follows:*/
}R64_SERVICE_FLOW_TYPE_S;

typedef struct _R64_REQUEST_TRANSMISSION_POLICY_TYPE_OF_DATA_DELIVERY_SERVICE_
{
    DWORD broadcastOpportunityForbidden:1;        /*type:43, len:4 bytes,value:bit map , comments:The value of this parameter provides the capability to specify certain attributes for the associated service flow. These attributes include options for PDU formation, and for uplink service flows, restrictions on the types of bandwidth request options that may be used. An attribute is enabled by setting the corresponding bit position to */
    DWORD reserved0:1;
    DWORD piggybackForbidden:1;
    DWORD fragmentForbidden:1;
    DWORD suppressForbidden:1;
    DWORD multipleFragmentForbidden:1;
    DWORD crcForbidden:1;
}R64_REQUEST_TRANSMISSION_POLICY_TYPE_OF_DATA_DELIVERY_SERVICE_S;

typedef struct _R64_REDUCED_SOURCE_CODE_
{
    DWORD code;        /*type:44, len:4 bytes,value: , comments:This code indicates that the requesting entity will accept reduced resources if therequested resources are not available. (TBD: encoding)*/
}R64_REDUCED_SOURCE_CODE_S;

typedef struct _R64_DATA_PATH_TYPE_
{
    BYTE type;        /*type:45, len:1 bytes,value:see R64_DATA_PATH_TYPE_E , comments:Data path type*/
}R64_DATA_PATH_TYPE_S;

typedef struct _R64_DATA_PATH_ID_
{
    DWORD dpId;        /*type:46, len:4 bytes,value: 0~4G, comments:The GRE key*/
}R64_DATA_PATH_ID_S;

typedef struct _R64_RESERVATION_ACTION_
{
    BYTE create:1;        /*type:104, len:1 bytes,value: see R64_RESERVED_ACTION_E, comments:Bitmask that describes action(s) to be performed for a service flow*/
    BYTE admit:1;
    BYTE activate:1;
    BYTE modify:1;
    BYTE del:1;
}R64_RESERVATION_ACTION_S;

typedef struct _R64_SA_ID_
{
    DWORD id;        /*type:81, len: 4 bytes,value: , comments:*/
}R64_SA_ID_S;

typedef struct _R64_SA_INDEX_
{
    DWORD index;        /*type:82, len:4 bytes,value: , comments:Index which AAA Server assigns to an SA.*/
}R64_SA_INDEX_S;


typedef struct _R64_SA_TYPE_
{
    BYTE type;        /*type:83, len:1 bytes,value: see R64_SA_TYPE_E, comments:Code identifying the value of SA-type as defined below.
0: Primary;
1: Static;
2: Dynamic
3 - 127: Reserved
128 - 255 Vendor Specific
*/
}R64_SA_TYPE_S;

typedef struct _R64_SA_SERVICE_TYPE_
{
    BYTE type;        /*type:84, len:1 bytes,value:see R64_SA_SERVICE_TYPE_E , comments:*/
}R64_SA_SERVICE_TYPE_S;

typedef struct _R64_DL_PHY_QUALITY_INFO_
{
    DWORD qualityInfo;        /*type:60, len:4 bytes,value:32-bit integer encoding 8-bit DL RSSI Mean, 8-bit DL RSSI Std, 8-bit DL CINR Mean,8-bit DL CINR Std , comments:*/
}R64_DL_PHY_QUALITY_INFO_S;

typedef struct _R64_UL_PHY_QUALITY_INFO_
{
    DWORD qualityInfo;        /*type:61, len:4 bytes,value:32-bit integer encoding 8-bit DL RSSI Mean, 8-bit DL RSSI Std, 8-bit DL CINR Mean,8-bit DL CINR Std , comments:*/
}R64_UL_PHY_QUALITY_INFO_S;

typedef struct _R64_RELATIVE_DELAY_
{
    BYTE delay;        /*type:62, len:1 bytes,value:8-bit integer representing Target BS Relative Delay , comments:*/
}R64_RELATIVE_DELAY_S;

typedef struct _R64_HO_ID_
{
    BYTE id;        /*type:63, len:1 bytes,value: , comments:There is no definition in stage3. (refer to R1)*/
}R64_HO_ID_S;


typedef struct _R64_SERVICE_LEVEL_PREDICTION_
{
    BYTE prediction;        /*type:64, len:1 bytes,value: , comments:8-bit integer representing Service Level Prediction

*/
}R64_SERVICE_LEVEL_PREDICTION_S;

typedef struct _R64_HO_PROCESS_OPTIMIZATION_
{
    BYTE optimization;        /*type:65, len:1 bytes,value:8-bit integer representing HO Process Optimization code. , comments:*/
}R64_HO_PROCESS_OPTIMIZATION_S;

typedef struct _R64_HO_AUTHORIZATION_POLICY_SUPPORT_
{            /*type:66, len:1 bytes,value:8-bit bitmask representing HO Authorization Policy.
            " Bit #0: RSA authorization
            " Bit #1: EAP authorization
            " Bit #2: Authenticated-EAP authorization
            " Bit #3: HMAC supported
            " Bit #4: CMAC supported
            " Bit #5: 64-bit Short-HMAC
            " Bit #6: 80-bit Short-HMAC
            " Bit #7: 96-bit Short-HMAC

             , comments:*/
    BYTE     rsaAuth:1;
    BYTE    eapAuth:1;
    BYTE     authedEapAuth:1;
    BYTE    hmacSupport:1;
    BYTE    cmacSupport:1;
    BYTE    hmac64Bit:1;
    BYTE    hmac80Bit:1;
    BYTE    hmac96Bit:1;
}R64_HO_AUTHORIZATION_POLICY_SUPPORT_S;

typedef struct _R64_DATA_PATH_ESTABLISHMENT_OPTION_
{
    BYTE option;        /*type:67, len:1 bytes,value:0 FALSE 1 TRUE , comments:A flag indicating whether or not Data Path SHOULD be (pre -)established by the entity hosting the Target HO Function (e.g. Target BS, Target ASN)*/
}R64_DATA_PATH_ESTABLISHMENT_OPTION_S;


typedef struct _R64_HO_AUTHORIZATION_POLICY_INDICATOR_
{
    BYTE indicator;        /*type:68, len:1 bytes,value: see R64_HO_AUTHORIZATION_POLICY_INDICATOR_E , comments:To indicate if authorization negotiation is used inHO procedure.
                        0: EAP authorization and the value of the MAC mode field in the current BS (default)
                        1: The authorization policy for the target BS is negotiated.
                        */
}R64_HO_AUTHORIZATION_POLICY_INDICATOR_S;

typedef struct _R64_ACTION_TIME_
{
    BYTE time;        /*type:69, len:1 bytes,value: , comments:For HO, this value is defined as number of frames until the Target BS allocates a dedicated
                    transmission opportunity for RNG-REQ message to be transmitted by the MS using
                    Fast_Ranging_IE.
                    */
}R64_ACTION_TIME_S;

typedef struct _R64_RESOURCE_RETAIN_TYPE_
{
    BYTE type;        /*type:, len:1 bytes,value: 0 = the connection information for the MS is deleted

                    1 = the connection information for the MS is retained