ooq931.c

来自「一个非常美妙的proxy。功能强大。基于sip的协议。如果还要的话」· C语言 代码 · 共 1,944 行 · 第 1/5 页

   releaseComplete->reason.t = h225ReasonCode;

   /* Add user-user ie */
   q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=TRUE; 
   q931msg->userInfo->h323_uu_pdu.h245Tunneling = OO_TESTFLAG (call->flags, OO_M_TUNNELING);
   q931msg->userInfo->h323_uu_pdu.h323_message_body.t = 
           T_H225H323_UU_PDU_h323_message_body_releaseComplete;
   
   q931msg->userInfo->h323_uu_pdu.h323_message_body.u.releaseComplete = 
                                                             releaseComplete;
   releaseComplete->m.callIdentifierPresent = 1;
   releaseComplete->protocolIdentifier = gProtocolID;
   releaseComplete->callIdentifier.guid.numocts = 
           call->callIdentifier.guid.numocts;
   memcpy(releaseComplete->callIdentifier.guid.data, 
                                  call->callIdentifier.guid.data,
                                  call->callIdentifier.guid.numocts);

   OOTRACEDBGA3("Built Release Complete message (%s, %s)\n",
                call->callType, call->callToken);
   /* Send H225 message */   
   ret = ooSendH225Msg(call, q931msg);
   if(ret != OO_OK)
   {
      OOTRACEERR3("Error:Failed to enqueue ReleaseComplete message to outbound"
                  " queue.(%s, %s)\n", call->callType, call->callToken);
   }
   memReset(&gH323ep.msgctxt);

   return ret;
}


int ooSendConnect(OOH323CallData *call)
{
   ooAcceptCall(call);
   return OO_OK;
}

/*TODO: Need to clean logical channel in case of failure after creating one */
int ooAcceptCall(OOH323CallData *call)
{
   int ret = 0, i=0, j=0, remoteMediaPort=0, remoteMediaControlPort = 0, dir=0;
   char remoteMediaIP[20], remoteMediaControlIP[20];
   H225Connect_UUIE *connect;
   H225TransportAddress_ipAddress *h245IpAddr;
   H225VendorIdentifier *vendor;
   Q931Message *q931msg=NULL;
   DListNode *pNode = NULL;
   H245OpenLogicalChannel *olc = NULL, printOlc;
   ooH323EpCapability *epCap = NULL;
   ASN1DynOctStr *pFS=NULL;
   OOCTXT *pctxt = &gH323ep.msgctxt;   
   H245H2250LogicalChannelParameters *h2250lcp = NULL;  
   ooLogicalChannel* pChannel;

   ret = ooCreateQ931Message(&q931msg, Q931ConnectMsg);
   if(ret != OO_OK)
   {      
      OOTRACEERR1("Error: In allocating memory for - H225 "
                  "Connect message\n");
      return OO_FAILED;
   }
   q931msg->callReference = call->callReference;

   /* Set bearer capability */
   if(OO_OK != ooSetBearerCapabilityIE(q931msg, Q931CCITTStd, 
                       Q931TransferUnrestrictedDigital, Q931TransferPacketMode,
                       Q931TransferRatePacketMode, Q931UserInfoLayer1G722G725))
     //                          Q931TransferSpeech, Q931TransferCircuitMode,
     //                   Q931TransferRate64Kbps, Q931UserInfoLayer1G711ULaw))
   {
      OOTRACEERR3("Error: Failed to set bearer capability ie. (%s, %s)\n",
                   call->callType, call->callToken);
      return OO_FAILED;
   }

   q931msg->userInfo = (H225H323_UserInformation*)
      memAllocZ (pctxt,sizeof(H225H323_UserInformation));

   if(!q931msg->userInfo)
   {
      OOTRACEERR1("ERROR:Memory - ooAcceptCall - userInfo\n");
      return OO_FAILED;
   }   

   q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=TRUE; 

   q931msg->userInfo->h323_uu_pdu.h245Tunneling = 
      OO_TESTFLAG (call->flags, OO_M_TUNNELING); 

   q931msg->userInfo->h323_uu_pdu.h323_message_body.t = 
      T_H225H323_UU_PDU_h323_message_body_connect;
   
   connect = (H225Connect_UUIE*)
      memAllocZ (pctxt, sizeof(H225Connect_UUIE));

   if(!connect)
   {
      OOTRACEERR1("ERROR:Memory - ooAcceptCall - connect\n");
      return OO_FAILED;
   }

   q931msg->userInfo->h323_uu_pdu.h323_message_body.u.connect = connect;
   connect->m.fastStartPresent = 0;
   connect->m.multipleCallsPresent = 1;
   connect->m.maintainConnectionPresent = 1;
   connect->multipleCalls = FALSE;
   connect->maintainConnection = FALSE;
   
   
   connect->conferenceID.numocts = 16;
   for (i = 0; i < 16; i++)
      connect->conferenceID.data[i] = i + 1;

   connect->m.callIdentifierPresent = 1;
   connect->callIdentifier.guid.numocts = 
                                 call->callIdentifier.guid.numocts;
   memcpy(connect->callIdentifier.guid.data, call->callIdentifier.guid.data, 
                                         call->callIdentifier.guid.numocts);
   
   connect->conferenceID.numocts = call->confIdentifier.numocts;
   memcpy(connect->conferenceID.data, call->confIdentifier.data,
          call->confIdentifier.numocts);
   /* Populate alias addresses */
   connect->m.connectedAddressPresent = TRUE;
   if(call->ourAliases)
      ret = ooPopulateAliasList(pctxt, call->ourAliases, 
                                      &connect->connectedAddress);
   else
      ret =  ooPopulateAliasList(pctxt, gH323ep.aliases, 
                                        &connect->connectedAddress);
   if(OO_OK != ret)
   {
      OOTRACEERR1("Error:Failed to populate alias list in Connect message\n");
      memReset(pctxt);
      return OO_FAILED;
   }
   connect->m.presentationIndicatorPresent = TRUE;
   connect->presentationIndicator.t = 
                             T_H225PresentationIndicator_presentationAllowed;
   connect->m.screeningIndicatorPresent = TRUE;
   connect->screeningIndicator = userProvidedNotScreened;

   connect->protocolIdentifier = gProtocolID;  

   /* Pose as Terminal or Gateway */
   if(gH323ep.isGateway)
      connect->destinationInfo.m.gatewayPresent = TRUE;
   else
      connect->destinationInfo.m.terminalPresent = TRUE;

   
   connect->destinationInfo.m.vendorPresent = 1;
   vendor = &connect->destinationInfo.vendor;
      
   vendor->vendor.t35CountryCode = gH323ep.t35CountryCode;
   vendor->vendor.t35Extension = gH323ep.t35Extension;
   vendor->vendor.manufacturerCode = gH323ep.manufacturerCode;
   if(gH323ep.productID)
   {
      vendor->m.productIdPresent = 1;
      vendor->productId.numocts = ASN1MIN(strlen(gH323ep.productID), 
                                            sizeof(vendor->productId.data));
      strncpy(vendor->productId.data, gH323ep.productID, 
                                                   vendor->productId.numocts);
   }
   if(gH323ep.versionID)
   {
      vendor->m.versionIdPresent = 1;
      vendor->versionId.numocts = ASN1MIN(strlen(gH323ep.versionID), 
                                           sizeof(vendor->versionId.data));
      strncpy(vendor->versionId.data, gH323ep.versionID, 
                                                   vendor->versionId.numocts); 
   }
   /* If fast start supported and remote endpoint has sent faststart element */
   if(OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART) && 
      call->remoteFastStartOLCs.count>0)
   {
      pFS = (ASN1DynOctStr*)memAlloc(pctxt, 
                        call->remoteFastStartOLCs.count*sizeof(ASN1DynOctStr));
      if(!pFS)
      {
         OOTRACEERR3("Error:Memory - ooAcceptCall - pFS (%s, %s)\n", 
                      call->callType, call->callToken);    
         return OO_FAILED;
      }
      memset(pFS, 0, call->remoteFastStartOLCs.count*sizeof(ASN1DynOctStr));


      for(i=0, j=0; i<(int)call->remoteFastStartOLCs.count; i++)
      {

         pNode = dListFindByIndex(&call->remoteFastStartOLCs, i);
         olc = (H245OpenLogicalChannel*)pNode->data;

         if(olc->forwardLogicalChannelParameters.dataType.t != 
                                                   T_H245DataType_nullData &&
            olc->m.reverseLogicalChannelParametersPresent)
         {
            OOTRACEINFO3("Ignoring bidirectional OLC as it is not supported."
                         "(%s, %s)\n", call->callType, call->callToken);
            continue;
         }

         /* Forward Channel - remote transmits - local receives */
         if(olc->forwardLogicalChannelParameters.dataType.t != 
                                                   T_H245DataType_nullData)
         {
            OOTRACEDBGC4("Processing received forward olc %d (%s, %s)\n", 
                          olc->forwardLogicalChannelNumber, call->callType, 
                          call->callToken);
            dir = OORX;
            epCap = ooIsDataTypeSupported(call, 
                                &olc->forwardLogicalChannelParameters.dataType,
                                OORX);
            if(!epCap) 
               continue;
            OOTRACEINFO1("Receive Channel data type supported\n");
            if(olc->forwardLogicalChannelParameters.multiplexParameters.t !=
               T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters)
            {
               OOTRACEERR4("ERROR:Unknown multiplex parameter type for "
                           "channel %d (%s, %s)\n", 
                           olc->forwardLogicalChannelNumber, 
                           call->callType, call->callToken);
               memFreePtr(call->pctxt, epCap);
               epCap = NULL;
               continue;
            }
            h2250lcp = olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters;

            if(ooIsSessionEstablished(call, olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters->sessionID, "receive"))
            {

               OOTRACEINFO4("Receive channel with sessionID %d already "
                            "established.(%s, %s)\n", olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters->sessionID, 
                            call->callType, call->callToken);
               memFreePtr(call->pctxt, epCap);
               epCap = NULL;
               continue;
            }

            /* Extract mediaControlChannel info, if supplied */
            if(h2250lcp->m.mediaControlChannelPresent)
            {
               if(OO_OK != ooGetIpPortFromH245TransportAddress(call, 
                                &h2250lcp->mediaControlChannel, 
                                remoteMediaControlIP, &remoteMediaControlPort))
               {
                  OOTRACEERR3("Error: Invalid media control channel address "
                              "(%s, %s)\n", call->callType, call->callToken);
                  memFreePtr(call->pctxt, epCap);
                  epCap = NULL;
                  continue;
               }
            }
         }
         else if(olc->m.reverseLogicalChannelParametersPresent)
         {/* Reverse channel - remote receives - local transmits */
            OOTRACEDBGC4("Processing received reverse olc %d (%s, %s)\n", 
                          olc->forwardLogicalChannelNumber, call->callType, 
                          call->callToken);
            dir = OOTX;
            epCap = ooIsDataTypeSupported(call, 
                                &olc->reverseLogicalChannelParameters.dataType,
                                OOTX);
            if(!epCap) 
               continue;

            OOTRACEINFO1("Transmit Channel data type supported\n");

            if(olc->reverseLogicalChannelParameters.multiplexParameters.t != 
               T_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters)
            {
               OOTRACEERR4("ERROR:Unknown multiplex parameter type for "
                           "channel %d (%s, %s)\n", 
                           olc->forwardLogicalChannelNumber, 
                           call->callType, call->callToken);
               memFreePtr(call->pctxt, epCap);
               epCap = NULL;
               continue;
            }
            if(ooIsSessionEstablished(call, olc->reverseLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters->sessionID, "transmit"))
            {

               OOTRACEINFO4("Transmit session with sessionID %d already "
                            "established.(%s, %s)\n", olc->reverseLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters->sessionID, call->callType, call->callToken);

               memFreePtr(call->pctxt, epCap);
               epCap = NULL;
               continue;
            }
             /* Extract the remote media endpoint address */
            h2250lcp = olc->reverseLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters;
            if(!h2250lcp)
            {
               OOTRACEERR3("ERROR:Invalid OLC received in fast start. No "
                           "reverse Logical Channel Parameters found. "
                           "(%s, %s)\n", call->callType, call->callToken);
               memFreePtr(call->pctxt, epCap);
               epCap = NULL;
               return OO_FAILED;
            }
            if(!h2250lcp->m.mediaChannelPresent)
            {
               OOTRACEERR3("ERROR:Invalid OLC received in fast start. No "
                           "reverse media channel information found. "
                           "(%s, %s)\n", call->callType, call->callToken);
               memFreePtr(call->pctxt, epCap);
               epCap = NULL;
               return OO_FAILED;
            }
            if(OO_OK != ooGetIpPortFromH245TransportAddress(call, 
                                &h2250lcp->mediaChannel, 
                                remoteMediaIP, &remoteMediaPort))
            {
               OOTRACEERR3("Error: Invalid media  channel address "
                           "(%s, %s)\n", call->callType, call->callToken);
               memFreePtr(call->pctxt, epCap);
               epCap = NULL;
               continue;
            }

            /* Extract mediaControlChannel info, if supplied */
            if(h2250lcp->m.mediaControlChannelPresent)
            {
               if(OO_OK != ooGetIpPortFromH245TransportAddress(call, 
                                &h2250lcp->mediaControlChannel, 
                                remoteMediaControlIP, &remoteMediaControlPort))
               {
                  OOTRACEERR3("Error: Invalid media control channel address "
                              "(%s, %s)\n", call->callType, call->callToken);
                  memFreePtr(call->pctxt, epCap);
                  epCap = NULL;
                  continue;
               }
            }
         }

         if(dir & OOTX)
	 {  /* According to the spec if we are accepting olc for transmission
               from called endpoint to calling endpoint, called endpoint should
               insert a unqiue forwardLogicalChannelNumber into olc
	    */
            olc->forwardLogicalChannelNumber =  call->logicalChanNoCur++;
            if(call->logicalChanNoCur > call->logicalChanNoMax)
               call->logicalChanNoCur = call->logicalChanNoBase;
         }

         
         ooPrepareFastStartResponseOLC(call, olc, epCap, pctxt, dir);
         
         pChannel = ooFindLogicalChannelByLogicalChannelNo
	    (call, olc->forwardLogicalChannelNumber);
   
         if(dir & OORX)
         {
            strcpy(pChannel->remoteIP, remoteMediaControlIP);
            pChannel->remoteMediaControlPort = remoteMediaControlPort;
            if(epCap->startReceiveChannel)
            {   
               epCap->startReceiveChannel(call, pChannel);      
               OOTRACEINFO4("Receive channel of type %s started (%s, %s)\n", 
                        (epCap->capType == OO_CAP_TYPE_AUDIO)?"audio":"video",
                        call->callType, call->callToken);
            }
            else{
               OOTRACEERR4("ERROR:No callback registered to start receive %s"
                          " channel (%s, %s)\n", 
                        (epCap->capType == OO_CAP_TYPE_AUDIO)?"audio":"video", 
                           call->callType, call->callToken);
               return OO_FAILED;
            }
         }
         if(dir & OOTX)
         {
            pChannel->remoteMediaPort = remoteMediaPort;
            strcpy(pChannel->remoteIP, remoteMediaIP);
            pChannel->remoteMediaControlPort = remoteMediaControlPort;

            if(epCap->startTransmitChannel)
            {   
               epCap->startTransmitChannel(call, pChannel);      
               OOTRACEINFO3("Transmit channel of type audio started "
                            "(%s, %s)\n", call->callType, call->callToken);
	       /*OO_SETFLAG (call->flags, OO_M_AUDIO);*/
            }
            else{