iannexe.h

基于h323协议的软phone

        ((AsOIDHeader(payload)[IAnnexET01Header_PFLAGS] & AEP_MASK_S) ? \
                ((AsOIDHeader(payload)[IAnnexET01Header_PFLAGS] & AEP_MASK_A) ? \
                        sizeof_OIDDataSA( GetOIDDataPtr(payload) ) \
                    : \
                        sizeof_OIDDataS( GetOIDDataPtr(payload) ) \
                ) \
            : \
                ((AsOIDHeader(payload)[IAnnexET01Header_PFLAGS] & AEP_MASK_A) ? \
                        sizeof_OIDDataA( GetOIDDataPtr(payload) ) \
                    : \
                        sizeof_OIDData( GetOIDDataPtr(payload) ) \
                ) \
        ) \
    )


/* Annex E payloads: IAnnexEPayloadHeader.T=10 - Static-payload 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|
    |---------------|---------------|---------------|---------------|
    |1 0|?|?|  RES  |  STATIC_TYPE  |...
    |---------------|---------------|

STATIC_TYPE:        Annex E Static types
                    0   - H.225
                    -ff - ?
*/

/*
typedef struct {
    RvUint8             PFLAGS;

    RvUint8             STATIC_TYPE;
} IAnnexET10Header;
*/

#define sizeof_IAnnexET10Header 2

typedef RvUint8 IAnnexET10Header;

#define IAnnexET10Header_PFLAGS 0
#define IAnnexET10Header_STATIC_TYPE 1

#define AsStaticHeader( payload ) \
    ((IAnnexET10Header*)(payload))

#define sizeof_StaticHeader( payload ) \
    sizeof_IAnnexET10Header

/* S=0 & A=0: basic static-typed payload */
/*
typedef struct {
    IAnnexET10Header    Header[sizeof_IAnnexET10Header];
    RvUint8             DATA_LENGTH[2];
    RvUint8             DATA[1];
} IAnnexET10Payload;
*/

#define sizeof_IAnnexET10Payload_ND 4
typedef RvUint8 IAnnexET10Payload;

#define IAnnexET10Payload_Header 0
#define IAnnexET10Payload_DATA_LENGTH sizeof_IAnnexET10Header
#define IAnnexET10Payload_DATA (sizeof_IAnnexET10Header + 2)

#define AsStatic( payload ) \
    ((IAnnexET10Payload*)(payload))

#define sizeof_StaticNoSA( payload )  \
    (sizeof_IAnnexET10Payload_ND + \
    (AsStatic(payload)[IAnnexET10Payload_DATA_LENGTH] << 8) + \
     AsStatic(payload)[IAnnexET10Payload_DATA_LENGTH+1])

/* S=1 & A=0: Extended-1 static-typed payload */

/*
typedef struct {
    IAnnexET10Header    Header[sizeof_IAnnexET10Header];
    RvUint8             SESSION[2];
    RvUint8             DATA_LENGTH[2];
    RvUint8             DATA[1];
} IAnnexET10PayloadS;
*/

#define sizeof_IAnnexET10PayloadS_ND 6

typedef RvUint8 IAnnexET10PayloadS;

#define IAnnexET10PayloadS_Header 0
#define IAnnexET10PayloadS_SESSION sizeof_IAnnexET10Header
#define IAnnexET10PayloadS_DATA_LENGTH (sizeof_IAnnexET10Header+2)
#define IAnnexET10PayloadS_DATA (sizeof_IAnnexET10Header+4)

#define AsStaticS( payload ) \
    ((IAnnexET10PayloadS*)(payload))

#define sizeof_StaticS( payload )  \
    (sizeof_IAnnexET10PayloadS_ND + \
    (AsStaticS(payload)[IAnnexET10PayloadS_DATA_LENGTH] << 8) + \
     AsStaticS(payload)[IAnnexET10PayloadS_DATA_LENGTH+1])

/* S=1 & A=1: Extended-2 static-typed payload */

/*
typedef struct {
    IAnnexET10Header    Header[sizeof_IAnnexET10Header];
    RvUint8             SESSION[2];
    RvUint8             ADDRESS[4];
    RvUint8             DATA_LENGTH[2];
    RvUint8             DATA[1];
} IAnnexET10PayloadSA;
*/

#define sizeof_IAnnexET10PayloadSA_ND 10

typedef RvUint8 IAnnexET10PayloadSA;

#define IAnnexET10PayloadSA_Header 0
#define IAnnexET10PayloadSA_SESSION sizeof_IAnnexET10Header
#define IAnnexET10PayloadSA_ADDRESS (sizeof_IAnnexET10Header + 2)
#define IAnnexET10PayloadSA_DATA_LENGTH (sizeof_IAnnexET10Header + 6)
#define IAnnexET10PayloadSA_DATA (sizeof_IAnnexET10Header + 8)

#define AsStaticSA( payload ) \
    ((IAnnexET10PayloadSA*)(payload))

#define sizeof_StaticSA( payload )  \
    (sizeof_IAnnexET10PayloadSA_ND + \
    (AsStaticSA(payload)[IAnnexET10PayloadSA_DATA_LENGTH] << 8) + \
     AsStaticSA(payload)[IAnnexET10PayloadSA_DATA_LENGTH+1])

/* S=0 & A=1: Extended-3 static-typed payload */
/*
typedef struct {
    IAnnexET10Header    Header[sizeof_IAnnexET10Header];
    RvUint8             DATA_LENGTH[2];
    RvUint8             ADDRESS[4];
    RvUint8             DATA[1];
} IAnnexET10PayloadA;
*/

#define sizeof_IAnnexET10PayloadA_ND 8
typedef RvUint8 IAnnexET10PayloadA;

#define IAnnexET10PayloadA_Header 0
#define IAnnexET10PayloadA_DATA_LENGTH sizeof_IAnnexET10Header
#define IAnnexET10PayloadA_ADDRESS (sizeof_IAnnexET10Header + 2)
#define IAnnexET10PayloadA_DATA (sizeof_IAnnexET10Header + 6)

#define AsStaticA( payload ) \
    ((IAnnexET10PayloadA*)(payload))

#define sizeof_StaticA( payload )  \
    (sizeof_IAnnexET10PayloadA_ND + \
    (AsStaticA(payload)[IAnnexET10PayloadA_DATA_LENGTH] << 8) + \
     AsStaticA(payload)[IAnnexET10PayloadA_DATA_LENGTH+1])

#define sizeof_Static(payload) \
    ((AsStaticHeader(payload)[IAnnexET10Header_PFLAGS] & AEP_MASK_S) ? \
            ((AsStaticHeader(payload)[IAnnexET10Header_PFLAGS] & AEP_MASK_A) ? \
                    sizeof_StaticSA(payload) \
                : \
                    sizeof_StaticS(payload) \
            ) \
        : \
            ((AsStaticHeader(payload)[IAnnexET10Header_PFLAGS] & AEP_MASK_A) ? \
                    sizeof_StaticA(payload) \
                : \
                    sizeof_StaticNoSA(payload) \
            ) \
    )

/* Annex E module - internal structures
*******************************************************************************
******************************************************************************/

typedef enum {
    NOT_INITIALIZED,
    INITIALIZED,
    RUNNING
} eAnnexEState;

typedef struct _tAnnexE     *tpAnnexE;
typedef struct _tNode       *tpNode;
typedef struct _tPDU        *tpPDU;

/* tAnnexE
******************************************************************************/

typedef struct _tAnnexE
{
    HAPPANNEXE              hAppAnnexE;

    eAnnexEState            State;

    RV_LIST_ENTRY           FreeNodesList;
    RV_LIST_ENTRY           FreePDUList;

    HHASH                   ActiveNodesHash;

    RV_LIST_ENTRY           WaitingForTransmissionList;
    RV_LIST_ENTRY           ResBlockedNodeList;

    tpPDU                   pRecvPDU;

    int                     t_R1;
    int                     t_R2;
    int                     n_R1;
    int                     t_IMA1;
    int                     n_IMA1;
    int                     t_DT;

    RvH323TimerPoolHandle   hTimers; /* Timers pool for Annex E timers */

    RvSelectEngine*         pSelEngine; /* Select Engine, used for the file descriptors */
    RvPortRange*            pPortRange; /* Port range to use */
    RvH323Connection        connection; /* UDP connection to use for Annex E messages */

    RvBool                  fReadyToSend;

    RvAddress               localAddr; /* Local address to use for Annex E */

    annexEEvents            events;

    RvLogSource             log;

    HRPOOLELEM              firstMsg;
    HRPOOLELEM              lastMsg;
} tAnnexE;

/* tNode
******************************************************************************/
typedef struct {
    RvUint32            nIP;
    RvUint16            nPort;
} tNodeKey;

#define sizeof_tNodeKey 6


typedef struct _tNode {
    tpAnnexE            pAnnexE;
    int                 nRef;

    tNodeKey            RemoteHost;

    RvUint32            nLast_Ack_SEQ;
    RvUint32            nNext_SEQ;

    tpPDU               pWaitingForAckPDU;

    RvBool              fLocalAddressUsed;
    RvUint32            nLocalAddress;

    int                 nRetry;
    RvTimer*            hResendAndIMATimer;

    tpPDU               pCurrentPDU;

    /* LIST Entries!*/
    RV_LIST_ENTRY       lNodeLink;
    RV_LIST_ENTRY       lPendLink;

    RvBool              fDontSend;
} tNode;

/* following functions are implemented in IAnnESes.c */
tNode* get_node( tAnnexE* pAnnexE, RvUint32 ip, RvUint16 port );
tNode* add_node( tAnnexE* pAnnexE, RvUint32 ip, RvUint16 port );
void del_node( tNode* pNode );
void del_all_nodes( tAnnexE* pAnnexE );

/* following functions are implemented in IAnnETmr.c */
#if 0
/* delayed send not supported */
void RVCALLCONV delay_timer_event(void* context);
#endif

RvBool retransmit_or_ima_timer_event(IN void* context);
RvUint32 get_delay_interval( tNode* pNode );
RvUint32 get_retransmit_interval( tNode* pNode );
RvUint32 get_ima_interval( tNode* pNode );
RvBool start_retransmit_or_ima_timer( IN tNode* pNode );

/* following functions are implemented in IAnnERW.c */
void remote_host_is_dead( tNode* pNode );
void remote_host_is_alive( tNode* pNode );
RvBool check_pdu(IN tNode* pNode, IN tpPDU pPDU);
void process_pdu(IN tNode* pNode, IN tpPDU pPDU);


/* tPDU
******************************************************************************/

typedef struct _tPDU {
    RvSize_t            nMaxSize;
    RvSize_t            nSize;

    RvUint32            nIP;

    RvBool              fPDUIsWaitingForSend;

    /* LIST Enties!*/
    RV_LIST_ENTRY       lPDULink;

    RvUint16            nPort;

    RvUint8             PDU[1];

} tPDU;

/* following functions are implemented in IAnnERW.c */
void send_ima( tNode* pNode, RvBool fSendNow );
void send_current_pdu( tNode* pNode );
void send_pdu( tAnnexE* pAnnexE, tPDU* pPDU );
void free_pdu( tAnnexE* pAnnexE, tPDU* pPDU );
void unblock_res_blocked_nodes( tAnnexE* pAnnexE );

/* Annex E default timing & retransmit counter values
******************************************************************************/

#define ANNEXE_TR1      500     /* ms = 0.5s */
#define ANNEXE_NR1      8
#define ANNEXE_TIMA1    6000    /* ms = 6.0s */
#define ANNEXE_NIMA1    6

/* helper functions & macroses
******************************************************************************/

#define MAX_UDP_FRAME 512

#ifdef _DEBUG
    /* safe typecast functions (only in DEBUG mode)*/
    tAnnexE*        AsAnnexE( HANNEXE hannexe );
    HANNEXE         AsHANNEXE( tAnnexE* pannexe );
#else
    /* direct typecast functions*/
#define         AsAnnexE( hannexe ) ((tAnnexE*)(hannexe))
#define         AsHANNEXE( pannexe ) ((HANNEXE)(pannexe))

#endif

/* following functions are implemented in IAnnexE.c */
void hton16( RvUint16 h, RvUint8* ptr );
void hton24( RvUint32 h, RvUint8* ptr );
void hton32( RvUint32 h, RvUint8* ptr );
RvUint16 ntoh16( RvUint8* ptr );
RvUint32 ntoh24( RvUint8* ptr );
RvUint32 ntoh32( RvUint8* ptr );


#ifdef __cplusplus
}
#endif /* __cplusplus*/

#endif /* _IAnnexE_H_*/