iannexe.h

基于h323协议的软phone

/*
typedef struct {
    RvUint8             SEQNUM[3];
    RvUint8             DATA_LENGTH;
    RvUint8             REASON[2];
    RvUint8             DATA[1];
} IAnnexENAckReason;
*/

#define sizeof_IAnnexENAckReason_ND 6
typedef RvUint8 IAnnexENAckReason;

#define IAnnexENAckReason_SEQNUM 0
#define IAnnexENAckReason_DATA_LENGTH 3
#define IAnnexENAckReason_REASON 4
#define IAnnexENAckReason_DATA 6


#define AsNAckReason( reason ) \
    ((IAnnexENAckReason*)(reason))

#define countof_NAckReasonData( reason ) \
    (AsNAckReason( reason )[IAnnexENAckReason_DATA_LENGTH])

#define sizeof_NAckReason( reason ) \
    (sizeof_IAnnexENAckReason_ND + countof_NAckReasonData( reason ))

/* REASON=1: Request the sender to use an alternate port for the specified static payload type */
/*
typedef struct {
    RvUint8             SEQNUM[3];
    RvUint8             DATA_LENGTH;
    RvUint8             REASON[2];
    RvUint8             STATIC_TYPE;
    RvUint8             RESERVED;
    RvUint8             ALTERNATE_PORT[2];
    RvUint8             ALTERNATE_IP[4];
} IAnnexENAckReason1;
*/

#define sizeof_IAnnexENAckReason1 14
typedef RvUint8 IAnnexENAckReason1;

#define IAnnexENAckReason1_STATIC_TYPE 6
#define IAnnexENAckReason1_RESERVED 7
#define IAnnexENAckReason1_ALTERNATE_PORT 8
#define IAnnexENAckReason1_ALTERNATE_IP 10

#define AsNAckReason1( reason ) \
    ((IAnnexENAckReason1*)(reason))

/* REASON=3: Transport-payload type not supported  */
/*
typedef struct {
    RvUint8             SEQNUM[3];
    RvUint8             DATA_LENGTH;
    RvUint8             REASON[2];
    RvUint8             TRANSPORT_TYPE;
} IAnnexENAckReason3;
*/

#define sizeof_IAnnexENAckReason3 7
typedef RvUint8 IAnnexENAckReason3;

#define IAnnexENAckReason3_SEQNUM 0
#define IAnnexENAckReason3_DATA_LENGTH 3
#define IAnnexENAckReason3_REASON 4
#define IAnnexENAckReason3_TRANSPORT_TYPE 6

#define AsNAckReason3( reason ) \
    ((IAnnexENAckReason3*)(reason))

/* REASON=4: Static-payload type not supported  */
/*
typedef struct {
    RvUint8             SEQNUM[3];
    RvUint8             DATA_LENGTH;
    RvUint8             REASON[2];
    RvUint8             STATIC_TYPE;
} IAnnexENAckReason4;
*/

#define sizeof_IAnnexENAckReason4 7
typedef RvUint8 IAnnexENAckReason4;

#define IAnnexENAckReason4_SEQNUM 0
#define IAnnexENAckReason4_DATA_LENGTH 3
#define IAnnexENAckReason4_REASON 4
#define IAnnexENAckReason4_STATIC_TYPE 6

#define AsNAckReason4( reason ) \
    ((IAnnexENAckReason4*)(reason))

/* REASON=5: OID-Payload not supported */


/* REASON=6: Payload corrupted  */
/*
typedef struct {
    RvUint8             SEQNUM[3];
    RvUint8             DATA_LENGTH;
    RvUint8             REASON[2];
    RvUint8             PAYLOAD_NUMBER;
} IAnnexENAckReason6;
*/

#define sizeof_IAnnexENAckReason6 7
typedef RvUint8 IAnnexENAckReason6;

#define IAnnexENAckReason6_SEQNUM 0
#define IAnnexENAckReason6_DATA_LENGTH 3
#define IAnnexENAckReason6_REASON 4
#define IAnnexENAckReason6_PAYLOAD_NUMBER 6

#define AsNAckReason6( reason ) \
    ((IAnnexENAckReason6*)(reason))

/*
typedef struct {
    IAnnexET00Header    Header[sizeof_IAnnexET00Header];
    RvUint8             NACK_COUNT[2];
} IAnnexET00NAckHeader;
*/

#define sizeof_IAnnexET00NAckHeader 4
typedef RvUint8 IAnnexET00NAckHeader;

#define IAnnexET00NAckHeader_Header 0
#define IAnnexET00NAckHeader_NACK_COUNT sizeof_IAnnexET00Header

#define AsNAckHeader( payload ) \
    ((IAnnexET00NAckHeader*)(payload))

#define countof_NAckReasons( payload ) \
    ((AsNAckHeader( payload )[IAnnexET00NAckHeader_NACK_COUNT] << 8) + \
      AsNAckHeader( payload )[IAnnexET00NAckHeader_NACK_COUNT])

#define GetNAckReasonPtr( payload ) \
    ((void*)( ((RvUint8*)(payload)) + sizeof_IAnnexET00NAckHeader ))


/*
    Restart message

    |       0       |       1       |       2       |       3       |
    |0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|
    |---------------|---------------|---------------|---------------|
    |0 0|0|0|  RES  |     0x03      |            RESERVED           |
    |---------------|---------------|---------------|---------------|
*/

/*
typedef struct {
    IAnnexET00Header    Header[sizeof_IAnnexET00Header];
    RvUint8             RESERVED[2];
} IAnnexET00Restart;
*/

#define sizeof_IAnnexET00Restart 4
typedef RvUint8 IAnnexET00Restart;

#define IAnnexET00Restart_Header 0
#define IAnnexET00Restart_RESERVED sizeof_IAnnexET00Header

#define AsRestart( payload ) \
    ((IAnnexET00Restart*)(payload))


/* Annex E payloads: IAnnexEPayloadHeader.T=01 - ObjectID-typed messages
*******************************************************************************

    |       0       |       1       |       2       |       3       |
    |0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|
    |---------------|---------------|---------------|---------------|
    |0 1|?|?|  RES  |   OID_LENGTH  |     OID[0]    |...
    |---------------|---------------|---------------|

*/

/*
typedef struct {
    RvUint8             PFLAGS;

    RvUint8             OID_LENGTH;
    RvUint8             OID[1];
} IAnnexET01Header;
*/

#define sizeof_IAnnexET01Header_ND 1
typedef RvUint8 IAnnexET01Header;

#define IAnnexET01Header_PFLAGS 0
#define IAnnexET01Header_OID_LENGTH 1
#define IAnnexET01Header_OID 2

#define AsOIDHeader( payload ) \
    ((IAnnexET01Header*)(payload))

#define sizeof_OIDHeader( payload ) \
    (sizeof_IAnnexET01Header_ND + AsOIDHeader( payload )[IAnnexET01Header_OID_LENGTH])

#define GetOIDDataPtr( payload ) \
    ((void*)&(AsOIDHeader(payload)[IAnnexET01Header_OID+AsOIDHeader(payload)[IAnnexET01Header_OID_LENGTH]]))

/*  |       0       |       1       |       2       |       3       |
    |0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|
    |---------------|---------------|---------------|---------------|
    |0 1|0|0|  RES  |   OID_LENGTH  |     OID[0]    |...
    |---------------|---------------|---------------|
    |...
    |-------------------------------|---------------|---------------|
->  |           PAYLOAD_LEN         |    DATA[0]    |...
    |-------------------------------|---------------|
*/

/*
typedef struct {
    RvUint8             PAYLOAD_LEN[2];
    RvUint8             DATA[1];
} IAnnexET01Data;
*/

#define sizeof_IAnnexET01Data_ND 2
typedef RvUint8 IAnnexET01Data;

#define IAnnexET01Data_PAYLOAD_LEN 0
#define IAnnexET01Data_DATA 2

#define AsOIDData( oiddata ) \
    ((IAnnexET01Data*)(oiddata))

#define countof_OIDData( oiddata ) \
    ((AsOIDData(oiddata)[IAnnexET01Data_PAYLOAD_LEN] << 8) + \
      AsOIDData(oiddata)[IAnnexET01Data_PAYLOAD_LEN+1])

#define sizeof_OIDData( oiddata ) \
    (sizeof_IAnnexET01Data_ND + countof_OIDData(oiddata) * sizeof(RvUint8))

/*
    |       0       |       1       |       2       |       3       |
    |0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|
    |---------------|---------------|---------------|---------------|
    |0 1|1|0|  RES  |   OID_LENGTH  |     OID[0]    |...
    |---------------|---------------|---------------|
    |...
    |-------------------------------|-------------------------------|
->  |            SESSION            |           PAYLOAD_LEN         |
    |-------------------------------|-------------------------------|
    |    DATA[0]    |...
    |---------------|
*/
/*
typedef struct {
    RvUint8             SESSION[2];
    RvUint8             PAYLOAD_LEN[2];
    RvUint8             DATA[1];
} IAnnexET01DataS;
*/

#define sizeof_IAnnexET01DataS_ND 4
typedef RvUint8 IAnnexET01DataS;

#define IAnnexET01DataS_SESSION 0
#define IAnnexET01DataS_PAYLOAD_LEN 2
#define IAnnexET01DataS_DATA 4

#define AsOIDDataS( oiddata ) \
    ((IAnnexET01DataS*)(oiddata))

#define countof_OIDDataS( oiddata ) \
    ((AsOIDDataS(oiddata)[IAnnexET01DataS_PAYLOAD_LEN] << 8) + \
      AsOIDDataS(oiddata)[IAnnexET01DataS_PAYLOAD_LEN+1])

#define sizeof_OIDDataS( oiddata ) \
    (sizeof_IAnnexET01DataS_ND + countof_OIDDataS(oiddata) * sizeof(RvUint8))


/*
    |       0       |       1       |       2       |       3       |
    |0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|
    |---------------|---------------|---------------|---------------|
    |0 1|0|1|  RES  |   OID_LENGTH  |     OID[0]    |...
    |---------------|---------------|---------------|
    |...
    |---------------------------------------------------------------|
->  |                            ADDRESS                            |
    |---------------------------------------------------------------|
    |          PAYLOAD_LEN          |    DATA[0]    |...
    |-------------------------------|---------------|
*/
/*
typedef struct {
    RvUint8             ADDRESS[4];
    RvUint8             PAYLOAD_LEN[2];
    RvUint8             DATA[1];
} IAnnexET01DataA;
*/

#define sizeof_IAnnexET01DataA_ND 6
typedef RvUint8 IAnnexET01DataA;

#define IAnnexET01DataA_ADDRESS 0
#define IAnnexET01DataA_PAYLOAD_LEN 4
#define IAnnexET01DataA_DATA 6

#define AsOIDDataA( oiddata ) \
    ((IAnnexET01DataA*)(oiddata))

#define countof_OIDDataA( oiddata ) \
    ((AsOIDDataA(oiddata)[IAnnexET01DataA_PAYLOAD_LEN] << 8) + \
      AsOIDDataA(oiddata)[IAnnexET01DataA_PAYLOAD_LEN+1])

#define sizeof_OIDDataA( oiddata ) \
    (sizeof_IAnnexET01DataA_ND + countof_OIDDataA(oiddata) * sizeof(RvUint8))

/*
    |       0       |       1       |       2       |       3       |
    |0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|0-1-2-3-4-5-6-7|
    |---------------|---------------|---------------|---------------|
    |0 1|1|1|  RES  |   OID_LENGTH  |     OID[0]    |...
    |---------------|---------------|---------------|
    |...
    |-------------------------------|-------------------------------|
->  |            SESSION            |           PAYLOAD_LEN         |
    |---------------------------------------------------------------|
    |                            ADDRESS                            |
    |---------------------------------------------------------------|
    |    DATA[0]    |...
    |---------------|
*/
/*
typedef struct {
    RvUint8             SESSION[2];
    RvUint8             PAYLOAD_LEN[2];
    RvUint8             ADDRESS[4];
    RvUint8             DATA[1];
} IAnnexET01DataSA;
*/

#define sizeof_IAnnexET01DataSA_ND 8
typedef RvUint8 IAnnexET01DataSA;

#define IAnnexET01DataSA_SESSION 0
#define IAnnexET01DataSA_PAYLOAD_LEN 2
#define IAnnexET01DataSA_ADDRESS 4
#define IAnnexET01DataSA_DATA 8

#define AsOIDDataSA( oiddata ) \
    ((IAnnexET01DataSA*)(oiddata))

#define countof_OIDDataSA( oiddata ) \
    ((AsOIDDataSA(oiddata)[IAnnexET01DataSA_PAYLOAD_LEN] << 8) + \
      AsOIDDataSA(oiddata)[IAnnexET01DataSA_PAYLOAD_LEN+1])

#define sizeof_OIDDataSA( oiddata ) \
    (sizeof_IAnnexET01DataSA_ND + countof_OIDDataSA(oiddata) * sizeof(RvUint8))

#define sizeof_OID( payload ) \
    (sizeof_OIDHeader(payload) + \