iannerw.c

基于h323协议的软phone

        hton16(CRV, &pheader[IAnnexET10PayloadS_SESSION]);
        hton16((RvUint16)size, &pheader[IAnnexET10PayloadS_DATA_LENGTH]);

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

annexEStatus annexECloseNode(
    IN  HANNEXE                 hAnnexE,
    IN  RvUint32                ip,
    IN  RvUint16                port
) {
    tAnnexE *pAnnexE = AsAnnexE(hAnnexE);
    tNode   *pNode;

    if (!pAnnexE)
        return annexEStatusBadParameter;

    if ((ip == 0) && (port == 0))
        return annexEStatusNormal; /* Nothing to close, really */

    pNode = get_node(pAnnexE, ip, port);
    if (pNode == NULL)
    {
        RvLogError(&pAnnexE->log,
            (&pAnnexE->log, "annexECloseNode() - no such Remote Host(%08x:%i)!", ip, port));
        return annexEStatusBadParameter;
    }
    else
    {
        RvLogInfo(&pNode->pAnnexE->log, (&pNode->pAnnexE->log, "Remote Host(%08x:%i) closed!", pNode->RemoteHost.nIP, pNode->RemoteHost.nPort));
        del_node(pNode);
    }

    return annexEStatusNormal;
}

void
remote_host_is_dead(tNode* pNode)
{
    RvLogInfo(&pNode->pAnnexE->log,
        (&pNode->pAnnexE->log, "Remote Host(%08x:%i) is dead!", pNode->RemoteHost.nIP, pNode->RemoteHost.nPort));
    if (pNode->pAnnexE->events.AnnexEEvConnectionBroken != NULL) {
        pNode->pAnnexE->events.AnnexEEvConnectionBroken(
                AsHANNEXE(pNode->pAnnexE),
                pNode->pAnnexE->hAppAnnexE,
                pNode->RemoteHost.nIP,
                pNode->RemoteHost.nPort
           );
    }
    else
        del_node(pNode);
}

void
remote_host_is_alive(tNode* pNode) {
    if ((pNode->pWaitingForAckPDU == NULL)) {

        pNode->nRetry = 0;
        start_retransmit_or_ima_timer(pNode);
    }
}

void annexEEvent(
    IN RvSelectEngine*  selectEngine,
    IN RvSelectFd*      fd,
    IN RvSelectEvents   selectEvent,
    IN RvBool           error)
{
    RvH323Connection * connection = RV_GET_STRUCT(RvH323Connection, fd, fd);
    tAnnexE* pAnnexE = RV_GET_STRUCT(tAnnexE, connection, connection);
    tNode* pNode;
    RvAddress remoteAddress;
    RvStatus ret;

    RV_UNUSED_ARG(selectEngine);

    if ((error) || (selectEvent))
    {
        /* ToDo: handle error and select event */
    }

    ret = RvSocketReceiveBuffer(&connection->socket, &pAnnexE->pRecvPDU->PDU[0], pAnnexE->pRecvPDU->nMaxSize,
        &pAnnexE->pRecvPDU->nSize, &remoteAddress);

    if ((ret == RV_OK) && (pAnnexE->pRecvPDU->nSize > 0))
    {
        /* Get the IP/Port and put in the receive PDU */
        pAnnexE->pRecvPDU->nIP = RvAddressIpv4GetIp(RvAddressGetIpv4(&remoteAddress));
        pAnnexE->pRecvPDU->nPort = RvAddressGetIpPort(&remoteAddress);

        /* check AnnexE PDU header! */
        if ((pAnnexE->pRecvPDU->nSize <= sizeof_IAnnexEHeader) ||
            (AEHGet_VER( pAnnexE->pRecvPDU->PDU ) != 0) ||
            (AEHGet_RES( pAnnexE->pRecvPDU->PDU ) != 0))
        {
            /* reject! */
            RvLogError(&pAnnexE->log,
                (&pAnnexE->log, "(incoming PDU) bad header, rejected!" ));
            return;
        }

        /* search for node  */
        pNode = get_node( pAnnexE, pAnnexE->pRecvPDU->nIP, pAnnexE->pRecvPDU->nPort );

        if (pNode == NULL) {
            pNode = add_node( pAnnexE, pAnnexE->pRecvPDU->nIP, pAnnexE->pRecvPDU->nPort );

            if (pNode == NULL)
            {
                /* no free resources - reject! */
                RvLogError(&pAnnexE->log,
                    (&pAnnexE->log, "(incoming PDU) no free resources, rejected!" ));
                return;
            }
        }

        pNode->nRef++; /* protect node  */
        process_pdu( pNode, pAnnexE->pRecvPDU );
        if (pNode->nRef == 1) {
            del_node( pNode );
        }
        else
            pNode->nRef--; /* unprotect node */
    }
}

void
send_ima(tNode* pNode, RvBool fSendNow) 
{
    IAnnexET00IAmAlive  ima[sizeof_IAnnexET00IAmAlive_ND];
    RvUint8             cookie[4];

    ima[IAnnexET00IAmAlive_Header+IAnnexET00Header_PFLAGS]  = 0;
    AEPOr_T(ima[IAnnexET00IAmAlive_Header+IAnnexET00Header_PFLAGS], AEPT_TransportMessage);
    /*
    ima.Header.S    = 0;
    ima.Header.A    = 0;
    ima.Header.RES  = 0;
    */
    ima[IAnnexET00IAmAlive_Header+IAnnexET00Header_TRANSPORT_TYPE] = AEPT00_IAmAlive;

    IMASet_P(ima);

    hton16((RvUint16)get_ima_interval(pNode), &ima[IAnnexET00IAmAlive_VALIDITY]);

    IMASet_CookieLen(ima, sizeof(RvUint32));

    hton32((RvUint32)Rv64Divide(RvTimestampGet(), RV_TIME64_NSECPERMSEC), &cookie[0]);

    send_payload(
            pNode,
            ima,
            sizeof_IAmAliveHeader(&ima),
            &cookie[0],
            4,
            NULL,
            0,
            RV_FALSE,
            RV_FALSE,
            fSendNow
       );
}

void
i_am_alive_request_received(tNode* pNode, IAnnexET00IAmAlive* pPayload) {
    RvLogInfo(&pNode->pAnnexE->log,
        (&pNode->pAnnexE->log, "IAmAlive request from Host(%08x:%i)!", pNode->RemoteHost.nIP, pNode->RemoteHost.nPort));
    IMAClr_P(pPayload);
    send_payload(
            pNode,
            pPayload,
            sizeof_IAmAliveHeader(pPayload),
            &pPayload[IAnnexET00IAmAlive_COOKIE],
            sizeof_IAmAliveCookie(pPayload),
            NULL,
            0,
            RV_FALSE,
            RV_FALSE,
            RV_TRUE
       );
}

#if (RV_LOGMASK_COMPILEMASK & RV_LOGLEVEL_DEBUG)
static void
i_am_alive_response_received(tNode* pNode, IAnnexET00IAmAlive* pPayload)
{
    /* do nothing! remote_host_is_alive() is called from process_pdu() ;-)  */
    if (sizeof_IAmAliveCookie(pPayload) >= 4)
    {
        RvUint32 send_time = ntoh32(&pPayload[IAnnexET00IAmAlive_COOKIE]);
        RvLogDebug(&pNode->pAnnexE->log,
            (&pNode->pAnnexE->log, "IAmAlive response from Host(%08x:%i), delay(%ims)",
            pNode->RemoteHost.nIP, pNode->RemoteHost.nPort,
                (RvUint32)Rv64Divide(RvTimestampGet(), RV_TIME64_NSECPERMSEC) - send_time));
    }
}
#else
#define i_am_alive_response_received(_pNode, _pPayload)
#endif

void
use_alternate_port(tNode* pNode, RvUint32 ip, RvUint16 port) {
    cmTransportAddress      newAddress;

    RvLogInfo(&pNode->pAnnexE->log,
        (&pNode->pAnnexE->log, "Use_Alternate_Port received from Host(%08x:%i), New Host(%08x:%i)", pNode->RemoteHost.nIP, pNode->RemoteHost.nPort, ip, port));
    if (pNode->pAnnexE->events.AnnexEEvUseOtherAddress == NULL)
        return;
    newAddress.distribution = cmDistributionUnicast;
    newAddress.type         = cmTransportTypeIP;
    newAddress.ip           = ip;
    newAddress.port         = port;

    pNode->pAnnexE->events.AnnexEEvUseOtherAddress(
            AsHANNEXE(pNode->pAnnexE),
            pNode->pAnnexE->hAppAnnexE,
            pNode->RemoteHost.nIP,
            pNode->RemoteHost.nPort,
            &newAddress
   );
}

void
static_type0_is_not_supported(tNode* pNode) {

    RvLogInfo(&pNode->pAnnexE->log,
        (&pNode->pAnnexE->log, "Static Type=0 is not supported from remote Host(%08x:%i)", pNode->RemoteHost.nIP, pNode->RemoteHost.nPort));
    if (pNode->pAnnexE->events.AnnexEEvNotSupported == NULL)
        return;

    pNode->pAnnexE->events.AnnexEEvNotSupported(
            AsHANNEXE(pNode->pAnnexE),
            pNode->pAnnexE->hAppAnnexE,
            pNode->RemoteHost.nIP,
            pNode->RemoteHost.nPort
   );
}

void
send_ack(tNode* pNode, RvUint32 seqn, RvBool fSendNow)
{
    IAnnexET00Ack ack[sizeof_IAnnexET00Ack_ND+sizeof_IAnnexEAckData];
    ack[IAnnexET00Ack_Header+IAnnexET00Header_PFLAGS] = 0;
    /*
    ack.Header.T = 0;
    ack.Header.A = 0;
    ack.Header.S = 0;
    ack.Header.RES = 0;
    */
    ack[IAnnexET00Ack_Header+IAnnexET00Header_TRANSPORT_TYPE] = AEPT00_Ack;
    hton16(1, &ack[IAnnexET00Ack_ACK_COUNT]);
    hton24(seqn, &ack[IAnnexET00Ack_ACK+IAnnexEAckData_SEQNUM]);
    ack[IAnnexET00Ack_ACK+IAnnexEAckData_RESERVED] = 0;

    send_payload(
            pNode,
            ack,
            sizeof_AckHeader(&ack),
            &ack[IAnnexET00Ack_ACK],
            sizeof_IAnnexEAckData,
            NULL,
            0,
            RV_FALSE,
            RV_FALSE,
            fSendNow
       );
}

void
send_nack3(tNode* pNode, RvUint32 seqn, int transport_type, RvBool fSendNow) {
    /* send NACK REASON_3:"Transport-payload not supported" */
    IAnnexET00NAckHeader header[sizeof_IAnnexET00NAckHeader];
    IAnnexENAckReason3   reason[sizeof_IAnnexENAckReason3];

    RvLogInfo(&pNode->pAnnexE->log,
        (&pNode->pAnnexE->log, "Send NAck3(Transport-payload-type=%i not supported, SEQN=%i) to Host(%08x:%i)", transport_type, seqn, pNode->RemoteHost.nIP, pNode->RemoteHost.nPort));

    header[IAnnexET00NAckHeader_Header+IAnnexET00Header_PFLAGS] = 0;
    /*
    header.Header.T = 0;
    header.Header.A = 0;
    header.Header.S = 0;
    header.Header.RES = 0;
    */
    header[IAnnexET00NAckHeader_Header+IAnnexET00Header_TRANSPORT_TYPE] = AEPT00_NAck;
    hton16(1, &header[IAnnexET00NAckHeader_NACK_COUNT]);

    hton24(seqn, &reason[IAnnexENAckReason3_SEQNUM]);
    reason[IAnnexENAckReason3_DATA_LENGTH] = 1;
    hton16(3, &reason[IAnnexENAckReason3_REASON]);
    reason[IAnnexENAckReason3_TRANSPORT_TYPE] = (RvUint8)transport_type;

    send_payload(
            pNode,
            header,
            sizeof_IAnnexET00NAckHeader,
            reason,
            sizeof_IAnnexENAckReason3,
            NULL,
            0,
            RV_FALSE,
            RV_FALSE,
            fSendNow
       );
}

void
send_nack4(tNode* pNode, RvUint32 seqn, int static_type, RvBool fSendNow) {
    /* send NACK REASON_4:"Static-payload type not supported"   */
    IAnnexET00NAckHeader header[sizeof_IAnnexET00NAckHeader];
    IAnnexENAckReason4   reason[sizeof_IAnnexENAckReason4];

    RvLogInfo(&pNode->pAnnexE->log,
        (&pNode->pAnnexE->log, "Send NAck4(Static-payload-type=%i not supported, SEQN=%i) to Host(%08x:%i)",
            static_type, seqn, pNode->RemoteHost.nIP, pNode->RemoteHost.nPort));

    header[IAnnexET00NAckHeader_Header+IAnnexET00Header_PFLAGS] = 0;
    /*
    header.Header.T = 0;
    header.Header.A = 0;
    header.Header.S = 0;
    header.Header.RES = 0;
    */
    header[IAnnexET00NAckHeader_Header+IAnnexET00Header_TRANSPORT_TYPE] = AEPT00_NAck;
    hton16(1, &header[IAnnexET00NAckHeader_NACK_COUNT]);

    hton24(seqn, &reason[IAnnexENAckReason4_SEQNUM]);
    reason[IAnnexENAckReason4_DATA_LENGTH] = 1;
    hton16(4, &reason[IAnnexENAckReason4_REASON]);
    reason[IAnnexENAckReason4_STATIC_TYPE] = (RvUint8)static_type;

    send_payload(
            pNode,
            header,
            sizeof_IAnnexET00NAckHeader,
            reason,
            sizeof_IAnnexENAckReason4,
            NULL,
            0,
            RV_FALSE,