iannerw.c

基于h323协议的软phone

/***********************************************************************
        Copyright (c) 2002 RADVISION Ltd.
************************************************************************
NOTICE:
This document contains information that is confidential and proprietary
to RADVISION Ltd.. No part of this document may be reproduced in any
form whatsoever without written prior approval by RADVISION Ltd..

RADVISION Ltd. reserve the right to revise this publication and make
changes without obligation to notify any person of such revisions or
changes.
***********************************************************************/

#include "rvinternal.h"
#include "rvtimestamp.h"
#include "annexe.h"
#include "iannexe.h"

/* todo: remove the following dependencies */
#include "cmutils.h"
#include "transportint.h"

#ifdef __cplusplus
extern "C" {
#endif



RvUint32
get_next_seqn(tNode* pNode)
{
    RvUint32 res = pNode->nNext_SEQ++;
    if (pNode->nNext_SEQ >= 0x01000000U)
        pNode->nNext_SEQ = 0;
    return res;
}

RvBool
is_old_seqn(RvUint32 seqn, RvUint32 prev_seqn)
{
    if (prev_seqn == 0xffffffffU)
        return RV_FALSE;
    if (prev_seqn >= 0x7fffffU)
    {
        if ((seqn <= prev_seqn) && (seqn >= (prev_seqn - 0x7fffffU)))
            return RV_TRUE;
        return RV_FALSE;
    }
    else
    {
        if ((seqn <= prev_seqn) || (seqn >= (0x7fffffU + prev_seqn)))
            return RV_TRUE;
        return RV_FALSE;
    }
}

void
send_pdu(tAnnexE* pAnnexE, tPDU* pPDU)
{
    if (pPDU->fPDUIsWaitingForSend)
        return;
    if ((!IsListEmpty(&pAnnexE->WaitingForTransmissionList)) || (!pAnnexE->fReadyToSend))
    {
        pPDU->fPDUIsWaitingForSend = RV_TRUE;
        InsertTailList(&pAnnexE->WaitingForTransmissionList, &pPDU->lPDULink);
        pPDU = NULL;
    }
    if (pAnnexE->fReadyToSend)
    {
        if(pAnnexE->fReadyToSend)
        {
            RvAddress remoteAddress;
            int res;

            if (pPDU == NULL)
            {
                RV_PLIST_ENTRY plink;
                if (IsListEmpty(&pAnnexE->WaitingForTransmissionList))
                    return;
                plink = RemoveHeadList(&pAnnexE->WaitingForTransmissionList);
                pPDU = RV_GET_STRUCT(tPDU, lPDULink, plink);
                pPDU->fPDUIsWaitingForSend = RV_FALSE;
            }

            /* Wrap this UDP and send it. Make sure the buffer can be disposed right after
               we send it. */
            RvAddressConstructIpv4(&remoteAddress, pPDU->nIP, pPDU->nPort);
            res = RvSocketSendBuffer(&pAnnexE->connection.socket, &pPDU->PDU[0], pPDU->nSize,
                &remoteAddress, NULL);
            RvAddressDestruct(&remoteAddress);

            if (res != RV_OK)
            {
                pPDU->fPDUIsWaitingForSend = RV_TRUE;
                InsertHeadList(&pAnnexE->WaitingForTransmissionList, &pPDU->lPDULink);
                pAnnexE->fReadyToSend = RV_FALSE;
                return;
            }
            if (AEHGet_A(pPDU->PDU) == 0)
                free_pdu(pAnnexE, pPDU);

            pPDU = NULL;
        }
    }
}

void
free_pdu(tAnnexE* pAnnexE, tPDU* pPDU) {
    if (pPDU->fPDUIsWaitingForSend) {
        RemoveEntryList(&pPDU->lPDULink);
        pPDU->fPDUIsWaitingForSend = RV_FALSE;
    }
    pPDU->nSize = 0;
    InsertTailList(&pAnnexE->FreePDUList, &pPDU->lPDULink);
    unblock_res_blocked_nodes(pAnnexE);
}

void
unblock_res_blocked_nodes(tAnnexE* pAnnexE) {
    RV_PLIST_ENTRY last;
    tNode*      lastPNode;
    RvBool      finished = RV_FALSE;

    if (pAnnexE->State != RUNNING)
        return;

    last = GetLastList(&pAnnexE->ResBlockedNodeList);
    lastPNode = RV_GET_STRUCT(tNode, lPendLink, last);

    while ((!IsListEmpty(&pAnnexE->FreePDUList)) &&
           (!IsListEmpty(&pAnnexE->ResBlockedNodeList)) &&
           (!finished)) {

        tNode*      pNode;

        RV_PLIST_ENTRY plink = RemoveHeadList(&pAnnexE->ResBlockedNodeList);
        pNode = RV_GET_STRUCT(tNode, lPendLink, plink);

        if (pAnnexE->events.AnnexEEvWriteable != NULL) {
            pNode->nRef++; /* protect node */
            pAnnexE->events.AnnexEEvWriteable(
                    AsHANNEXE(pNode->pAnnexE),
                    pNode->pAnnexE->hAppAnnexE,
                    pNode->RemoteHost.nIP,
                    pNode->RemoteHost.nPort
               );
            if (pNode->nRef == 1) {
                del_node(pNode);
                continue;
            }
            pNode->nRef--; /* unprotect node */
        }

        if (pNode == lastPNode)
            finished = RV_TRUE;
    }
}

void
send_current_pdu(tNode* pNode)
{
    tPDU* pPDU;

#if defined(RV_ANNEXE_DEBUG)
    if (pNode->pCurrentPDU == NULL)
    {
        RvLogExcep(&pNode->pAnnexE->log, (&pNode->pAnnexE->log,
            "send_current_pdu: No current PDU..."));
        return;
    }
#endif

    if (AEHGet_A(pNode->pCurrentPDU->PDU) != 0)
    {
#if defined(RV_ANNEXE_DEBUG)
        if (pNode->pWaitingForAckPDU != NULL)
        {
            RvLogExcep(&pNode->pAnnexE->log, (&pNode->pAnnexE->log,
                "send_current_pdu: Already waiting for an ack."));
            return;
        }
#endif
        pNode->nRetry = 0;
        pNode->pWaitingForAckPDU = pNode->pCurrentPDU;
        start_retransmit_or_ima_timer(pNode);
    };
    pPDU = pNode->pCurrentPDU;
    pNode->pCurrentPDU = NULL;
    send_pdu(pNode->pAnnexE, pPDU);
}

RvBool
send_payload(
        tNode*      pNode,
        void*       payload_header,
        int         payload_header_size,
        void*       payload_data,
        int         payload_data_size,
        void*       payload_exdata,
        int         payload_exdata_size,
        RvBool      AckFlag,
        RvBool      HFlag,
        RvBool      SendNow
       )
{
    tPDU*   pCurrentPDU;
    RvBool  fFirstPayload = RV_FALSE;

    /* if can't send add to the list of pended nodes */
    if (AckFlag && (pNode->pWaitingForAckPDU != NULL)) {
        return RV_FALSE;
    }

    /* get free PDU if needed   */
    if (pNode->pCurrentPDU == NULL) {
        RV_PLIST_ENTRY plink;
        if (IsListEmpty(&pNode->pAnnexE->FreePDUList)) {
            InsertTailList(&pNode->pAnnexE->ResBlockedNodeList, &pNode->lPendLink);
            return RV_FALSE;
        }
        fFirstPayload = RV_TRUE;
        plink = RemoveHeadList(&pNode->pAnnexE->FreePDUList);
        pNode->pCurrentPDU = RV_GET_STRUCT(tPDU, lPDULink, plink);

        pCurrentPDU = pNode->pCurrentPDU;

        pCurrentPDU->nIP    = pNode->RemoteHost.nIP;
        pCurrentPDU->nPort  = pNode->RemoteHost.nPort;

        pCurrentPDU->PDU[IAnnexEHeader_FLAGS] = 0;

        hton24(get_next_seqn(pNode), &pCurrentPDU->PDU[IAnnexEHeader_SEQN]);

        pCurrentPDU->nSize = sizeof_IAnnexEHeader;

        if (payload_header_size + payload_data_size + payload_exdata_size >= (int)(pCurrentPDU->nMaxSize - pCurrentPDU->nSize))
        {
            /* this is serious APPLICATION bug (payload is greather than PDU size)!!! */
            RvLogExcep(&pNode->pAnnexE->log, (&pNode->pAnnexE->log,
                "send_payload: Payload is greather than PDU size!"));
            return RV_FALSE;
        }
    }
    else
        pCurrentPDU = pNode->pCurrentPDU;

    /* check for free space in PDU */
    if (payload_header_size + payload_data_size + payload_exdata_size < (int)(pCurrentPDU->nMaxSize - pCurrentPDU->nSize)) {
        /* append payload to the PDU */
        if (payload_header_size > 0) {
            memcpy(&pCurrentPDU->PDU[pCurrentPDU->nSize], payload_header, payload_header_size);
            pCurrentPDU->nSize += payload_header_size;
        }
        if (payload_data_size > 0) {
            memcpy(&pCurrentPDU->PDU[pCurrentPDU->nSize], payload_data, payload_data_size);
            pCurrentPDU->nSize += payload_data_size;
        }
        if (payload_exdata_size > 0) {
            memcpy(&pCurrentPDU->PDU[pCurrentPDU->nSize], payload_exdata, payload_exdata_size);
            pCurrentPDU->nSize += payload_exdata_size;
        }

        AEHOr_A(pCurrentPDU->PDU, AckFlag);
        AEHOr_H(pCurrentPDU->PDU, HFlag);

        if ((SendNow) && (!pNode->fDontSend)) {
            send_current_pdu(pNode);
        }

        return RV_TRUE;
    }
    else {
        /* no place for that payload => send current PDU!   */
        send_current_pdu(pNode);

        if (AckFlag && (pNode->pWaitingForAckPDU != NULL))
            return RV_FALSE;
        else
            return send_payload(pNode, payload_header, payload_header_size, payload_data, payload_data_size, payload_exdata, payload_exdata_size, AckFlag, HFlag, SendNow);
    }
}

annexEStatus annexESendMessage(
    IN  HANNEXE                 hAnnexE,
    IN  RvUint32                ip,
    IN  RvUint16                port,
    IN  RvUint16                CRV,
    IN  void*                   message,
    IN  int                     size,
    IN  RvBool                  fAckHint,
    IN  RvBool                  fReplyHint,
    IN  RvBool                  fSendHint
)
{
    tAnnexE *pAnnexE = AsAnnexE(hAnnexE);
    tNode   *pNode;

    if (!pAnnexE)
        return annexEStatusBadParameter;

    pNode = get_node(pAnnexE, ip, port);
    if (pNode == NULL)
    {
        pNode = add_node(pAnnexE, ip, port);
    }
    if (pNode == NULL)
    {
        RvLogError(&pAnnexE->log, (&pAnnexE->log, "annexESendMessage() - annexEStatusResourceProblem!"));
        return annexEStatusResourceProblem;
    }

    if (pNode->fLocalAddressUsed)
    {
        IAnnexET10PayloadSA pheader[sizeof_IAnnexET10PayloadSA_ND];

        pheader[IAnnexET10PayloadSA_Header + IAnnexET10Header_PFLAGS] = AEP_MASK_A | AEP_MASK_S | (AEPT_StaticMessage << AEP_SHFT_T);
        /*
        pheader.Header.A            = 1;
        pheader.Header.S            = 1;
        pheader.Header.RES          = 0;
        pheader.Header.T            = AEPT_StaticMessage;
        */
        pheader[IAnnexET10PayloadSA_Header + IAnnexET10Header_STATIC_TYPE]  = 0; /* h.225 messages */

        hton32(pNode->nLocalAddress, &pheader[IAnnexET10PayloadSA_ADDRESS]);
        hton16(CRV, &pheader[IAnnexET10PayloadSA_SESSION]);
        hton16((RvUint16)size, &pheader[IAnnexET10PayloadSA_DATA_LENGTH]);

        if (send_payload(pNode, pheader, sizeof_IAnnexET10PayloadSA_ND, message, size, NULL, 0, fAckHint, fReplyHint, fSendHint)) {
            return annexEStatusNormal;
        }
        else {
            return annexEStatusWouldBlock;
        }
    }
    else {
        IAnnexET10PayloadS  pheader[sizeof_IAnnexET10PayloadS_ND];

        pheader[IAnnexET10PayloadS_Header + IAnnexET10Header_PFLAGS] = AEP_MASK_S | (AEPT_StaticMessage << AEP_SHFT_T);
        /*
        pheader.Header.A            = 0;
        pheader.Header.S            = 1;
        pheader.Header.RES          = 0;
        pheader.Header.T            = AEPT_StaticMessage;
        */
        pheader[IAnnexET10PayloadS_Header + IAnnexET10Header_STATIC_TYPE]   = 0; /* h.225 messages  */