gateway.cxx

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

        } // end switch
    }

    else
        cout << "received hardware input for which no handling exists\n";
}


void stateHalfOpenIn(StateEvent* event, StateMachine* state)
{
    if (event->getStimulus() == StimulusNewMessage)
    {
        Sptr < MgCommand > msgPtr = event->getMessage();
        Sptr < MgCreateConnection > crcxPtr;

        switch (msgPtr->getType())
        {
            case MgCreateConnectionType:
            {
                // state 5 -- receive create connection
                crcxPtr.dynamicCast(msgPtr);
                if (crcxPtr == NULL)
                    wrongMessage();

                // store required paramters
                state->endpointId = crcxPtr->getEndpointId();
                state->currentRequestId = crcxPtr->getRequestIdentifier();
                state->callId = crcxPtr->getCallId();
                state->connectionMode = crcxPtr->getConnectionMode();

                if (state->connectionMode != "sendrecv")
                    wrongMessage();

                // ignore all optional parameters except remoteSD
                state->remoteSD = crcxPtr->getRemoteConnectionDescriptor();

                // setup local session descriptor
                state->localSD.setSessionName("test session");
                state->localSD.setUserName("testID");
                state->localSD.setAddress(getHost());
                state->localSD.setSessionId(128538);
                state->localSD.setVersion(0);

                SdpConnection* sessionConnection = new SdpConnection;
                sessionConnection->setUnicast ((state->localSD.getAddress()).c_str());
                state->localSD.setConnection (*sessionConnection);

                SdpMedia* media = new SdpMedia;
                media->setMediaType (MediaTypeAudio);
                media->setTransportType (TransportTypeRTP);
                media->setPort (6060);
                state->localSD.addMedia (media);

                // send a reply with connection id and local connection
                // description information; connection id is bogus (= callId)
                // and session descriptor is hardcoded
                state->connectionId = state->callId;
                crcxPtr->setConnectionId(state->connectionId);
                crcxPtr->setLocalConnectionDescriptor(state->localSD);

                // reply with successful response code and string,
                // transaction id handled by mgcp stack
                crcxPtr->setResponseCode(RSP_CODE_NORMAL);
                crcxPtr->setResponseString("OK");
                state->callAgent->reply(crcxPtr);

                // setup audio
                int localPort = 0;
                vector < SdpMedia* > localMediaList = state->localSD.getMediaList();
                if (localMediaList.size() > 0)
                {
                    localPort = localMediaList[0]->getPort();
                }

                int remotePort = 0;
                vector < SdpMedia* > remoteMediaList = state->remoteSD.getMediaList();
                if (remoteMediaList.size() > 0)
                {
                    remotePort = remoteMediaList[0]->getPort();
                }

                state->hardware->audioStart
                (localPort,
                 state->remoteSD.getAddress().c_str(),
                 remotePort);

                state->setState(stateActiveNoNotifications);
            }
            break;
            default:
            // ignore other messages
            cout << "received message for which no handling exists\n";
            break;
        } // end switch
    }

    else
        cout << "received hardware input for which no handling exists\n";
}


void stateHalfOpen(StateEvent* event, StateMachine* state)
{
    if (event->getStimulus() == StimulusNewMessage)
    {
        Sptr < MgCommand > msgPtr = event->getMessage();
        Sptr < MgModifyConnection > mdcxPtr;

        switch (msgPtr->getType())
        {
            case MgModifyConnectionType:
            {
                // state 7 -- receive create connection
                mdcxPtr.dynamicCast (msgPtr);
                if (mdcxPtr == NULL)
                    wrongMessage();

                // check for matching callId
                if (mdcxPtr->getCallId() != state->callId)
                    wrongMessage();

                // check connection mode
                //if (mdcxPtr->getConnectionMode() != state->connectionMode)
                //wrongMessage();

                // ignore all optional parameters except remoteSD
                state->remoteSD = mdcxPtr->getRemoteConnectionDescriptor();

                // stop ringback
                state->hardware->sendSignal(SignalLocalRingbackStop);

                // setup audio
                int localPort = 0;
                vector < SdpMedia* > localMediaList = state->localSD.getMediaList();
                if (localMediaList.size() > 0)
                {
                    localPort = localMediaList[0]->getPort();
                }

                int remotePort = 0;
                vector < SdpMedia* > mediaList = state->remoteSD.getMediaList();
                if (mediaList.size() > 0)
                {
                    remotePort = mediaList[0]->getPort();
                }

                state->hardware->audioStart
                (localPort,
                 state->remoteSD.getAddress().c_str(),
                 remotePort);

                // reply with successful response code and string,
                // transaction id handled by mgcp stack
                mdcxPtr->setResponseCode(RSP_CODE_NORMAL);
                mdcxPtr->setResponseString("OK");
                state->callAgent->reply(mdcxPtr);

                state->setState(stateActiveNoNotifications);
                break;
            }
            default:
            // ignore other messages
            cout << "received message for which no handling exists\n";
            break;
        } // end switch
    }

    else
        cout << "received hardware input for which no handling exists\n";
}


void stateActiveNoNotifications(StateEvent* event, StateMachine* state)
{
    if (event->getStimulus() == StimulusNewMessage)
    {
        Sptr < MgCommand > msgPtr = event->getMessage();
        Sptr < MgNotificationRequest > rqntPtr;

        switch (msgPtr->getType())
        {
            case MgNotificationRequestType:
            rqntPtr.dynamicCast (msgPtr);
            if (rqntPtr == NULL)
                wrongMessage();

            // store required paramters
            state->endpointId = rqntPtr->getEndpointId();
            state->currentRequestId = rqntPtr->getRequestIdentifier();

            // ignore all optional paramters

            // reply with successful response code and string,
            // transaction id handled by mgcp stack
            rqntPtr->setResponseCode(RSP_CODE_NORMAL);
            rqntPtr->setResponseString("OK");
            state->callAgent->reply(rqntPtr);
            state->setState(stateActive);
            break;
            default:
            // ignore other messages
            cout << "received message for which no handling exists\n";
            break;
        } // end switch
    }

    else
        cout << "received hardware input for which no handling exists\n";
}


void stateActive(StateEvent* event, StateMachine* state)
{
    // wait for dlcx, onhook, or DTMF digits
    if (event->getStimulus() == StimulusNewMessage)
    {
        Sptr < MgCommand > msgPtr = event->getMessage();
        Sptr < MgDeleteConnectionAgent > dlcxPtr;
        Sptr < MgNotificationRequest > rqntPtr;

        switch (msgPtr->getType())
        {
            case MgNotificationRequestType:
            rqntPtr. dynamicCast (msgPtr);
            if (rqntPtr == NULL)
                wrongMessage();

            // store required paramters
            state->endpointId = rqntPtr->getEndpointId();
            state->currentRequestId = rqntPtr->getRequestIdentifier();

            // check for request to play DTMF tones
            if (rqntPtr->getNumSignalRequests())
            {
                Sptr < MgEvent > signalPtr = rqntPtr->getItemSignalRequests(0);
#ifndef NCS_PROFILE
                Sptr < MgDTMFPackageEvent > dtmfPtr;
#else // NCS_PROFILE
Sptr < MgNCSLinePackageEvent > dtmfPtr;
#endif
                dtmfPtr.dynamicCast(signalPtr);
                assert (dtmfPtr != 0);
                switch (dtmfPtr->getType())
                {
#ifndef NCS_PROFILE
                    case MgcDTMFPackageDTMF_0:
                    cerr << "received DTMF 0 from far end\n";
                    break;
                    case MgcDTMFPackageDTMF_1:
                    cerr << "received DTMF 1 from far end\n";
                    break;
                    case MgcDTMFPackageDTMF_2:
                    cerr << "received DTMF 2 from far end\n";
                    break;
                    case MgcDTMFPackageDTMF_3:
                    cerr << "received DTMF 3 from far end\n";
                    break;
                    case MgcDTMFPackageDTMF_4:
                    cerr << "received DTMF 4 from far end\n";
                    break;
                    case MgcDTMFPackageDTMF_5:
                    cerr << "received DTMF 5 from far end\n";
                    break;
                    case MgcDTMFPackageDTMF_6:
                    cerr << "received DTMF 6 from far end\n";
                    break;
                    case MgcDTMFPackageDTMF_7:
                    cerr << "received DTMF 7 from far end\n";
                    break;
                    case MgcDTMFPackageDTMF_8:
                    cerr << "received DTMF 8 from far end\n";
                    break;
                    case MgcDTMFPackageDTMF_9:
                    cerr << "received DTMF 9 from far end\n";
                    break;
                    case MgcDTMFPackageDTMF_Hash:
                    cerr << "received DTMF # from far end\n";
                    break;
                    case MgcDTMFPackageDTMF_Star:
                    cerr << "received DTMF * from far end\n";
                    break;
#else  // NCS_PROFILE
                    case MgcNCSLinePackageDTMF_0:
                    cerr << "received DTMF 0 from far end\n";
                    break;
                    case MgcNCSLinePackageDTMF_1:
                    cerr << "received DTMF 1 from far end\n";
                    break;
                    case MgcNCSLinePackageDTMF_2:
                    cerr << "received DTMF 2 from far end\n";
                    break;
                    case MgcNCSLinePackageDTMF_3:
                    cerr << "received DTMF 3 from far end\n";
                    break;
                    case MgcNCSLinePackageDTMF_4:
                    cerr << "received DTMF 4 from far end\n";
                    break;
                    case MgcNCSLinePackageDTMF_5:
                    cerr << "received DTMF 5 from far end\n";
                    break;
                    case MgcNCSLinePackageDTMF_6:
                    cerr << "received DTMF 6 from far end\n";
                    break;
                    case MgcNCSLinePackageDTMF_7:
                    cerr << "received DTMF 7 from far end\n";
                    break;
                    case MgcNCSLinePackageDTMF_8:
                    cerr << "received DTMF 8 from far end\n";
                    break;
                    case MgcNCSLinePackageDTMF_9:
                    cerr << "received DTMF 9 from far end\n";
                    break;
                    case MgcNCSLinePackageDTMF_Hash:
                    cerr << "received DTMF # from far end\n";
                    break;
                    case MgcNCSLinePackageDTMF_Star:
                    cerr << "received DTMF * from far end\n";
                    break;
#endif
                    default:
                    cerr << "received DTMF (unknown) from far end\n";
                    break;
                } // end switch
            }
            // reply with successful response code and string,
            // transaction id handled by mgcp stack

            rqntPtr->setResponseCode(RSP_CODE_NORMAL);
            rqntPtr->setResponseString("OK");
            state->callAgent->reply(rqntPtr);
            break;

            case MgDeleteConnectionAgentType:
            dlcxPtr.dynamicCast (msgPtr);
            if (dlcxPtr == NULL)
                wrongMessage();

            // check endpoint and connection id
            //if (state->endpointId != dlcxPtr->getEndpointId())
            //wrongMessage();
            //if (state->connectionId != dlcxPtr->getConnectionId())
            //wrongMessage();

            // ignore all optional paramters

            // reply with successful response code and string,
            // transaction id handled by mgcp stack
            dlcxPtr->setResponseCode(RSP_CODE_NORMAL);
            dlcxPtr->setResponseString("OK");
            state->callAgent->reply(dlcxPtr);

            state->setState(stateWaitOnHook);

            // close the audio channel
            state->hardware->sendSignal(SignalAudioStop);
            break;
            default:
            // ignore other messages
            cout << "received message for which no handling exists\n";
            break;
        } // end switch
    }

    else if (event->getStimulus() == StimulusOnHook)
    {
        // create and send a Notify msg regarding the onHook event
        MgNotify ntfy(state->endpointId, state->currentRequestId,
#ifndef NCS_PROFILE
                      (MgLinePackage::notifyOnHookTransition())
#else  // NCS_PROFILE
                      (MgNCSLinePackage::notifyOnHookTransition())
#endif
                     );
        state->callAgent->send(ntfy);

        state->setState(stateWaitForClose);
    }
#ifndef NCS_PROFILE
    else if (event->getStimulus() == StimulusDigit0)
    {
        MgNotify ntfy(state->endpointId, state->currentRequestId,
                      (MgDTMFPackage::notifyDTMF_0()));
        state->callAgent->send(ntfy);
        // remain in current state
    }

    else if (event->getStimulus() == StimulusDigit1)
    {
        MgNotify ntfy(state->endpointId, state->currentRequestId,
                      (MgDTMFPackage::notifyDTMF_1()));
        state->callAgent->send(ntfy);
        // remain in current state
    }

    else if (event->getStimulus() == StimulusDigit2)
    {
        MgNotify ntfy(state->endpointId, state->currentRequestId,
                      (MgDTMFPackage::notifyDTMF_2()));
        state->callAgent->send(ntfy);
        // remain in current state
    }

    else if (event->getStimulus() == StimulusDigit3)
    {
        MgNotify ntfy(state->endpointId, state->currentRequestId,
                      (MgDTMFPackage::notifyDTMF_3()));
        state->callAgent->send(ntfy);
        // remain in current state
    }

    else if (event->getStimulus() == StimulusDigit4)
    {
        MgNotify ntfy(state->endpointId, state->currentRequestId,
                      (MgDTMFPackage::notifyDTMF_4()));
        state->callAgent->send(ntfy);
        // remain in current state
    }

    else if (event->getStimulus() == StimulusDigit5)
    {
        MgNotify ntfy(state->endpointId, state->currentRequestId,
                      (MgDTMFPackage::notifyDTMF_5()));
        state->callAgent->send(ntfy);
        // remain in current state
    }