endpoint.cxx

mgcp协议源代码。支持多种编码：g711

        Endpoint* destEp = &eps[call1->endpoint[1].id];
        CallData* call2 = destEp->call;
        call2->playDtmfDigit = call1->dtmfDigits[0];
        call1->dtmfDigits[0] = 0;

        /* Forward DTMF digit to the other party */
        notifyEndpoint (destEp, DigitsCollected);
    }
    return 1;
}    /* dtmfDigit */


void
processEvent (Endpoint* ep, int event)
{
    switch (event)
    {
        case Restart:
        {
            initRestart (ep);
        }
        break;
        case OffHook:
        {
            if (ep->state == Idle)
            {
                dialingComplete (ep);
            }
            else
            {
                answer (ep);
            }
        }
        break;
        case DigitsCollected:
        {
            dtmfDigit (ep);
        }
        break;
        case ReceiveCall:
        {
            receiveCall (ep);
        }
        break;
        case Connect:
        {
            connected (ep);
        }
        break;
        case OnHook:
        {
            if (ep->state == Connected)
            {
                disconnect (ep);
            }
            else
            {
                disconnectResponse (ep);
            }
        }
        break;
        case ClearCall:
        {
            clearCall (ep);
        }
        break;
        default:
        cerr << "Unexpected Event" << endl;
    }    /* switch */
}   /* processEvent */


int
newSocket (struct sockaddr_in* socketAddress, int port)
{
    int sfd = -1;

    if ((sfd = socket (PF_INET, SOCK_DGRAM, 0)) == -1)
    {
        cerr << "newSocket: socket() failed - " << strerror (errno) << endl;
    }
    else
    {
        memset (socketAddress, 0, sizeof (sockaddr_in));

        socketAddress->sin_family = AF_INET;
        socketAddress->sin_addr.s_addr = INADDR_ANY;
        socketAddress->sin_port = htons (port);

        if (bind (sfd, (struct sockaddr *)socketAddress, sizeof (sockaddr_in)) == -1)
        {
            cerr << "newSocket: bind() failed - " << strerror (errno) << endl;
            shutdown (sfd, 2);
            sfd = -1;
        }
    }
    return sfd;
}    /* newSocket */


void
saveDigits (Endpoint* ep,
#ifndef NCS_PROFILE
            Sptr < MgcDTMFPackageEvent > event
#else  // NCS_PROFILE
            Sptr < MgcNCSLinePackageEvent > event
#endif
           )
{
    if (ep->call == NULL)
    {
        ep->call = newCallData (ep);
    }
    assert (ep->call);

    switch (event->getType())
    {
#ifndef NCS_PROFILE
        case MgcDTMFPackageDTMF_0:
        {
            sprintf (ep->call->dtmfDigits, "%c", '0');
        }
        break;
        case MgcDTMFPackageDTMF_1:
        {
            sprintf (ep->call->dtmfDigits, "%c", '1');
        }
        break;
        case MgcDTMFPackageDTMF_2:
        {
            sprintf (ep->call->dtmfDigits, "%c", '2');
        }
        break;
        case MgcDTMFPackageDTMF_3:
        {
            sprintf (ep->call->dtmfDigits, "%c", '3');
        }
        break;
        case MgcDTMFPackageDTMF_4:
        {
            sprintf (ep->call->dtmfDigits, "%c", '4');
        }
        break;
        case MgcDTMFPackageDTMF_5:
        {
            sprintf (ep->call->dtmfDigits, "%c", '5');
        }
        break;
        case MgcDTMFPackageDTMF_6:
        {
            sprintf (ep->call->dtmfDigits, "%c", '6');
        }
        break;
        case MgcDTMFPackageDTMF_7:
        {
            sprintf (ep->call->dtmfDigits, "%c", '7');
        }
        break;
        case MgcDTMFPackageDTMF_8:
        {
            sprintf (ep->call->dtmfDigits, "%c", '8');
        }
        break;
        case MgcDTMFPackageDTMF_9:
        {
            sprintf (ep->call->dtmfDigits, "%c", '9');
        }
        break;
        case MgcDTMFPackageDTMF_Hash:
        {
            sprintf (ep->call->dtmfDigits, "%c", '#');
        }
        break;
        case MgcDTMFPackageDTMF_Star:
        {
            sprintf (ep->call->dtmfDigits, "%c", '*');
        }
        break;
        case MgcDTMFPackageDTMF_A:
        {
            sprintf (ep->call->dtmfDigits, "%c", 'A');
        }
        break;
        case MgcDTMFPackageDTMF_B:
        {
            sprintf (ep->call->dtmfDigits, "%c", 'B');
        }
        break;
        case MgcDTMFPackageDTMF_C:
        {
            sprintf (ep->call->dtmfDigits, "%c", 'C');
        }
        break;
        case MgcDTMFPackageDTMF_D:
        {
            sprintf (ep->call->dtmfDigits, "%c", 'D');
        }
        break;
#else  // NCS_PROFILE
        case MgcNCSLinePackageDTMF_0:
        {
            sprintf (ep->call->dtmfDigits, "%c", '0');
        }
        break;
        case MgcNCSLinePackageDTMF_1:
        {
            sprintf (ep->call->dtmfDigits, "%c", '1');
        }
        break;
        case MgcNCSLinePackageDTMF_2:
        {
            sprintf (ep->call->dtmfDigits, "%c", '2');
        }
        break;
        case MgcNCSLinePackageDTMF_3:
        {
            sprintf (ep->call->dtmfDigits, "%c", '3');
        }
        break;
        case MgcNCSLinePackageDTMF_4:
        {
            sprintf (ep->call->dtmfDigits, "%c", '4');
        }
        break;
        case MgcNCSLinePackageDTMF_5:
        {
            sprintf (ep->call->dtmfDigits, "%c", '5');
        }
        break;
        case MgcNCSLinePackageDTMF_6:
        {
            sprintf (ep->call->dtmfDigits, "%c", '6');
        }
        break;
        case MgcNCSLinePackageDTMF_7:
        {
            sprintf (ep->call->dtmfDigits, "%c", '7');
        }
        break;
        case MgcNCSLinePackageDTMF_8:
        {
            sprintf (ep->call->dtmfDigits, "%c", '8');
        }
        break;
        case MgcNCSLinePackageDTMF_9:
        {
            sprintf (ep->call->dtmfDigits, "%c", '9');
        }
        break;
        case MgcNCSLinePackageDTMF_Hash:
        {
            sprintf (ep->call->dtmfDigits, "%c", '#');
        }
        break;
        case MgcNCSLinePackageDTMF_Star:
        {
            sprintf (ep->call->dtmfDigits, "%c", '*');
        }
        break;
        case MgcNCSLinePackageDTMF_A:
        {
            sprintf (ep->call->dtmfDigits, "%c", 'A');
        }
        break;
        case MgcNCSLinePackageDTMF_B:
        {
            sprintf (ep->call->dtmfDigits, "%c", 'B');
        }
        break;
        case MgcNCSLinePackageDTMF_C:
        {
            sprintf (ep->call->dtmfDigits, "%c", 'C');
        }
        break;
        case MgcNCSLinePackageDTMF_D:
        {
            sprintf (ep->call->dtmfDigits, "%c", 'D');
        }
        break;
#endif
        default:
        cerr << "Invalid DTMF event " << (int)event->getType() << endl;
    }    /* switch */
}    /* saveDigits */


int
mapLinePackageEvent (
#ifndef NCS_PROFILE
    Sptr < MgcLinePackageEvent > event
#else  // NCS_PROFILE
Sptr < MgcNCSLinePackageEvent > event
#endif
)
{
    int epEvent = Unknown;

    switch (event->getType())
    {
#ifndef NCS_PROFILE
        case MgcLinePackageOffHookTransition:
        {
            epEvent = OffHook;
        }
        break;
        case MgcLinePackageOnHookTransition:
        {
            epEvent = OnHook;
        }
        break;
#else   // NCS_PROFILE
        case MgcNCSLinePackageOffHookTransition:
        {
            epEvent = OffHook;
        }
        break;
        case MgcNCSLinePackageOnHookTransition:
        {
            epEvent = OnHook;
        }
        break;
#endif
        default:
        //   cerr << "Unexpected Line Package event " << (int) event->getType() << endl;
        break;
    }    /* switch */
    return epEvent;
}    /* mapLinePackageEvent */


void
decodeNotify (Endpoint* ep, Sptr < MgcNotify > ntfy)
{
    int event = Unknown;

    Sptr < MgcEvent > observedEvent = ntfy->getItemObservedEvents (0);

    assert (observedEvent != 0);

    switch (observedEvent->getPackageType ())
    {
#ifndef NCS_PROFILE
        case MgcpDTMFPackageType:
        {
            Sptr < MgcDTMFPackageEvent > dtmf;
            dtmf.dynamicCast(observedEvent);
            saveDigits (ep, dtmf);
            event = DigitsCollected;
        }
        break;
        case MgcpLinePackageType:
        {
            Sptr < MgcLinePackageEvent > line;
            line.dynamicCast(observedEvent);
            event = mapLinePackageEvent(line);
        }
        break;
#else   // NCS_PROFILE
        case MgcpNCSLinePackageType:
        {
            Sptr < MgcNCSLinePackageEvent > line;
            line.dynamicCast(observedEvent);

            event = mapLinePackageEvent(line);

            if ( event == Unknown )
            {
                Sptr < MgcNCSLinePackageEvent > dtmf;
                dtmf.dynamicCast(observedEvent);
                saveDigits (ep, dtmf);
                event = DigitsCollected;
            }

        }
        break;
#endif
        default:
        cerr << "Unexpected package " << (int)observedEvent->getPackageType () << endl;
    }    /* switch */

    ntfy->setResponseCode (TransactionExecuted);
    ntfy->setResponseString (OKResponse);
    ep->gw->reply (ntfy);

    processEvent (ep, event);
}    /* decodeNotify */


void
stackEvent (Endpoint* ep)
{
    //    cout << "started decoding\n";
    Sptr < MgcCommand > cmd = ep->gw->receive ();

    //    cout << "finished decoding\n";
    switch (cmd->getType())
    {
        case MgcNotifyType:
        {
            Sptr < MgcNotify > ntfy;
            decodeNotify (ep, ntfy.dynamicCast(cmd));
            break;
        }
        default:
        {
            cerr << "Unexpected command " << static_cast < int > (cmd->getType()) << endl;
        }
    }
}    /* stackEvent */


void*
epStart (void* ptr)
{
    Endpoint* ep = (Endpoint*)ptr;
    int msgLen = 0;
    int event = -1;
    char buf[32];

    ep->sfd = newSocket (&(ep->socketAddress), UDP_PORT_MAX - ep->id);

    if (ep->sfd < 0)
    {
        cerr << "unable to open socket!\n";
    }

    fd_set fds;
    int retval;

    while (1)
    {
        //	cerr << "in loop\n";
        FD_ZERO (&fds);

        ep->gw->addToFdSet (&fds);
        FD_SET(0, &fds);
        FD_SET(ep->sfd, &fds);

        struct timeval tv;
        tv.tv_sec = 0;
        tv.tv_usec = 300;

        if ((retval = select(129, &fds, NULL, NULL, &tv)) > 0)
        {
            if (FD_ISSET (0, &fds))
            {
                char c;
                c = getchar();
                if (c == 'q')
                {
                    exit(0);
                }
            }
            if (FD_ISSET (ep->sfd, &fds))
            {
                //		cerr << "received message\n";
                if ((msgLen = recvfrom (ep->sfd, buf, 256, 0, NULL, NULL)) > 0)
                {
                    event = strtol (buf, NULL, 0);
                    processEvent (ep, event);
                }
                else
                {
                    break;
                }
            }    /* FD_ISSET */

            if (ep->gw->checkMsgReady (&fds) == true)
            {
                stackEvent (ep);
            }
        }    /* select */
        else if (retval == 0)
        {
            if (ep->gw->checkMsgReady (&fds) == true)
            {
                //		cout << "processing a message\n";
                stackEvent (ep);
            }
            else
            {
                //		cout << "timeout\n";
            }


        }
    }
    return NULL;
}    /* epStart */