ooq931.c

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

               OOTRACEERR3("ERROR:No callback registered to start transmit"
                           " audio channel (%s, %s)\n", call->callType, 
                           call->callToken);
               return OO_FAILED;
            }
         }
         /* Do not specify msg buffer let automatic allocation work */
         setPERBuffer(pctxt, NULL, 0, 1);
         if(asn1PE_H245OpenLogicalChannel(pctxt, olc) != ASN_OK)
         {
            OOTRACEERR3("ERROR:Encoding of olc failed for faststart "
                        "(%s, %s)\n", call->callType, call->callToken);
            ooFreeQ931Message(q931msg);
            if(call->callState < OO_CALL_CLEAR)
            {
               call->callEndReason = OO_REASON_LOCAL_CLEARED;
               call->callState = OO_CALL_CLEAR;
            }
            return OO_FAILED;
         }
         pFS[j].data = encodeGetMsgPtr(pctxt, &(pFS[j].numocts));

         /* Dump faststart element in logfile for debugging purpose */
         setPERBuffer(pctxt,  (char*)pFS[j].data, pFS[j].numocts, 1);
         initializePrintHandler(&printHandler, "FastStart Element");
         setEventHandler (pctxt, &printHandler);
         memset(&printOlc, 0, sizeof(printOlc));
         ret = asn1PD_H245OpenLogicalChannel(pctxt, &(printOlc));
         if(ret != ASN_OK)
         {
            OOTRACEERR3("Error: Failed decoding FastStart Element (%s, %s)\n", 
                        call->callType, call->callToken);
            ooFreeQ931Message(q931msg);
            if(call->callState < OO_CALL_CLEAR)
            {
               call->callEndReason = OO_REASON_LOCAL_CLEARED;
               call->callState = OO_CALL_CLEAR;
            }
            return OO_FAILED;
         }
         finishPrint();
         removeEventHandler(pctxt); 

         olc = NULL;
         j++;
         epCap = NULL;
      }
      OOTRACEDBGA4("Added %d fast start elements to CONNECT message "
                   "(%s, %s)\n",  j, call->callType, call->callToken);
      if(j != 0)
      {
         connect->m.fastStartPresent = TRUE;
         connect->fastStart.n = j;
         connect->fastStart.elem = pFS; 
      }else{
         OOTRACEINFO3("None of the faststart elements received in setup can be"
                      " supported, rejecting faststart.(%s, %s)\n", 
                      call->callType, call->callToken);
         connect->m.fastStartPresent = FALSE;
         OO_CLRFLAG(call->flags, OO_M_FASTSTART);
         OOTRACEDBGC3("Faststart for call is disabled by local endpoint."
                      "(%s, %s)\n", call->callType, call->callToken);
      }
   }

   /* Add h245 listener address. Do not add H245 listener address in case
      of fast-start. */
   if ((!OO_TESTFLAG(call->flags, OO_M_FASTSTART) || 
        call->remoteFastStartOLCs.count == 0) &&
       !OO_TESTFLAG (call->flags, OO_M_TUNNELING))
   {
      ooCreateH245Listener(call); /* First create an H.245 listener */
      connect->m.h245AddressPresent = TRUE;
      connect->h245Address.t = T_H225TransportAddress_ipAddress;
   
      h245IpAddr = (H225TransportAddress_ipAddress*)
	 memAllocZ (pctxt, sizeof(H225TransportAddress_ipAddress));
      if(!h245IpAddr)
      {
         OOTRACEERR3("Error:Memory - ooAcceptCall - h245IpAddr"
                     "(%s, %s)\n", call->callType, call->callToken);
	return OO_FAILED;
      }
      ooSocketConvertIpToNwAddr(call->localIP, h245IpAddr->ip.data);
      h245IpAddr->ip.numocts=4;
      h245IpAddr->port = *(call->h245listenport);
      connect->h245Address.u.ipAddress = h245IpAddr;
   }

   OOTRACEDBGA3("Built H.225 Connect message (%s, %s)\n", call->callType,
                 call->callToken);

   /* H225 message callback */
   if(gH323ep.h225Callbacks.onBuiltConnect)
      gH323ep.h225Callbacks.onBuiltConnect(call, q931msg);

   ret=ooSendH225Msg(call, q931msg);
   if(ret != OO_OK)
   {
      OOTRACEERR3("Error:Failed to enqueue Connect message to outbound queue.(%s, %s)\n", call->callType, call->callToken);
      memReset(&gH323ep.msgctxt);
      return OO_FAILED;
   }
   memReset(&gH323ep.msgctxt);

#if 0
   if (OO_TESTFLAG (call->flags, OO_M_TUNNELING))
   {
      /* Start terminal capability exchange and master slave determination */
      ret = ooSendTermCapMsg(call);
      if(ret != OO_OK)
      {
         OOTRACEERR3("ERROR:Sending Terminal capability message (%s, %s)\n",
                      call->callType, call->callToken);
         return ret;
      }
      ret = ooSendMasterSlaveDetermination(call);
      if(ret != OO_OK)
      {
         OOTRACEERR3("ERROR:Sending Master-slave determination message "
                  "(%s, %s)\n", call->callType, call->callToken);
         return ret;
      }   
   }
#endif
   return OO_OK;
}

int ooH323HandleCallFwdRequest(OOH323CallData *call)
{
   OOH323CallData *fwdedCall=NULL;
   OOCTXT *pctxt;
   ooAliases *pNewAlias=NULL, *alias=NULL;
   int i=0, ret = OO_OK;
   /* Note: We keep same callToken, for new call which is going
      to replace an existing call, thus treating it as a single call.*/

   fwdedCall = ooCreateCall("outgoing", call->callToken);

   pctxt = fwdedCall->pctxt;

   /* Retrieve new destination info from original call */
   if(!ooUtilsIsStrEmpty(call->pCallFwdData->ip))
   {
      strcpy(fwdedCall->remoteIP, call->pCallFwdData->ip);
   }
   fwdedCall->remotePort = call->pCallFwdData->port;
   
   if(call->pCallFwdData->aliases)
   {
      alias = call->pCallFwdData->aliases;
      while(alias)
      {
         pNewAlias = (ooAliases*) memAlloc(pctxt, sizeof(ooAliases));
         pNewAlias->value = (char*) memAlloc(pctxt, strlen(alias->value)+1);
         if(!pNewAlias || !pNewAlias->value)
         {
            OOTRACEERR3("Error:Memory - ooH323HandleCallFwdRequest - "
                        "pNewAlias/pNewAlias->value"
                        "(%s, %s)\n", call->callType, call->callToken);
            ooCleanCall(fwdedCall);
            return OO_FAILED;
         }
         pNewAlias->type = alias->type;
         strcpy(pNewAlias->value, alias->value);
         pNewAlias->next = fwdedCall->remoteAliases;
         fwdedCall->remoteAliases = pNewAlias;
         alias = alias->next;
         pNewAlias = NULL;
      }
   }

   fwdedCall->callReference = ooGenerateCallReference();
   ooGenerateCallIdentifier(&fwdedCall->callIdentifier);
   fwdedCall->confIdentifier.numocts = 16;
   for (i = 0; i < 16; i++)
      fwdedCall->confIdentifier.data[i] = i+1;
      

   if(gH323ep.gkClient && !OO_TESTFLAG(fwdedCall->flags, OO_M_DISABLEGK))
   {
     /* No need to check registration status here as it is already checked for
        MakeCall command */
      ret = ooGkClientSendAdmissionRequest(gH323ep.gkClient, fwdedCall, FALSE);
      fwdedCall->callState = OO_CALL_WAITING_ADMISSION;
   }
   else
      ret = ooH323CallAdmitted (fwdedCall);

   return OO_OK;

}

int ooH323MakeCall(char *dest, char *callToken, ooCallOptions *opts)
{
   OOCTXT *pctxt;
   OOH323CallData *call;
   int ret=0, i=0;
   char tmp[30]="\0";
   char *ip=NULL, *port = NULL;

   if(!dest)
   {
      OOTRACEERR1("ERROR:Invalid destination for new call\n");
      return OO_FAILED;
   }
   if(!callToken)
   {
      OOTRACEERR1("ERROR: Invalid callToken parameter to make call\n");
      return OO_FAILED;
   }

   call = ooCreateCall("outgoing", callToken);
   pctxt = call->pctxt;
   if(opts)
   {
      if(opts->fastStart)
         OO_SETFLAG(call->flags, OO_M_FASTSTART);
      else
         OO_CLRFLAG(call->flags, OO_M_FASTSTART);

      if(opts->tunneling)
         OO_SETFLAG(call->flags, OO_M_TUNNELING);
      else
         OO_CLRFLAG(call->flags, OO_M_TUNNELING);

      if(opts->disableGk)
         OO_SETFLAG(call->flags, OO_M_DISABLEGK);
      else
         OO_CLRFLAG(call->flags, OO_M_DISABLEGK);

      call->callMode = opts->callMode;
   }


   ret = ooParseDestination(call, dest, tmp, 30, &call->remoteAliases);
   if(ret != OO_OK)
   {
      OOTRACEERR2("Error: Failed to parse the destination string %s for "
                  "new call\n", dest);
      ooCleanCall(call);
      return OO_FAILED;
   }
   
   /* Check whether we have ip address */
   if(!ooUtilsIsStrEmpty(tmp))
   {
      ip = tmp;
      port = strchr(tmp, ':');
      *port = '\0';
      port++;
      strcpy(call->remoteIP, ip);
      call->remotePort = atoi(port);
   }

   strcpy(callToken, call->callToken);
   call->callReference = ooGenerateCallReference();
   ooGenerateCallIdentifier(&call->callIdentifier);
   call->confIdentifier.numocts = 16;
   for (i = 0; i < 16; i++)
      call->confIdentifier.data[i] = i+1;
      

   if(gH323ep.gkClient && !OO_TESTFLAG(call->flags, OO_M_DISABLEGK))
   {
     /* No need to check registration status here as it is already checked for
        MakeCall command */
      ret = ooGkClientSendAdmissionRequest(gH323ep.gkClient, call, FALSE);
      call->callState = OO_CALL_WAITING_ADMISSION;
   }
   else
      ret = ooH323CallAdmitted (call);

   return OO_OK;
}


int ooH323CallAdmitted(OOH323CallData *call)
{
   int ret=0;
      
   if(!call)
   {
      /* Call not supplied. Must locate it in list */
      OOTRACEERR1("ERROR: Invalid call parameter to ooH323CallAdmitted");
      return OO_FAILED; 
   }

   if(!strcmp(call->callType, "outgoing"))
   {
      ret = ooCreateH225Connection(call);
      if(ret != OO_OK)
      {
         OOTRACEERR3("ERROR:Failed to create H225 connection to %s:%d\n", 
                      call->remoteIP, call->remotePort);
         if(call->callState< OO_CALL_CLEAR)
         {
            call->callState = OO_CALL_CLEAR;
            call->callEndReason = OO_REASON_UNKNOWN;
         }
         return OO_FAILED;
      }
      
      ret = ooH323MakeCall_helper(call);
   } else { /* An incoming call */
      if(gH323ep.h323Callbacks.onIncomingCall)
         gH323ep.h323Callbacks.onIncomingCall(call);

      /* Check for manual ringback generation */
      if(!OO_TESTFLAG(gH323ep.flags, OO_M_MANUALRINGBACK))
      {
         ooSendAlerting(call); /* Send alerting message */

         if(OO_TESTFLAG(gH323ep.flags, OO_M_AUTOANSWER))
            ooSendConnect(call); /* Send connect message - call accepted */
      }
   }
   
   return OO_OK;
}

int ooH323MakeCall_helper(OOH323CallData *call)
{
   int ret=0,i=0, k;
   Q931Message *q931msg = NULL;
   H225Setup_UUIE *setup;

   ASN1DynOctStr *pFS=NULL;
   H225TransportAddress_ipAddress *destCallSignalIpAddress;

   H225TransportAddress_ipAddress *srcCallSignalIpAddress;
   ooH323EpCapability *epCap=NULL;
   OOCTXT *pctxt = NULL;
   H245OpenLogicalChannel *olc, printOlc;
   ASN1BOOL aligned = 1;
   ooAliases *pAlias = NULL;

   pctxt = &gH323ep.msgctxt;
     
   ret = ooCreateQ931Message(&q931msg, Q931SetupMsg);
   if(ret != OO_OK)
   {
      OOTRACEERR1("ERROR:Failed to Create Q931 SETUP Message\n ");
      return OO_FAILED;
   }

   q931msg->callReference = call->callReference;

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

   /* Set calling party number  Q931 IE */
   if(call->callingPartyNumber)
     ooQ931SetCallingPartyNumberIE(q931msg,
                            (const char*)call->callingPartyNumber, 1, 0, 1, 1);
   

   /* Set called party number Q931 ie */
   if(call->calledPartyNumber)
      ooQ931SetCalledPartyNumberIE(q931msg, 
                            (const char*)call->calledPartyNumber, 1, 0);
   else if(call->remoteAliases) {
      pAlias = call->remoteAliases;
      while(pAlias) {
         if(pAlias->type == T_H225AliasAddress_dialedDigits)
            break;
         pAlias = pAlias->next;
      }
      if(pAlias)
      {
         call->calledPartyNumber = (char*)memAlloc(call->pctxt, 
                                                   strlen(pAlias->value)+1);
         if(!call->calledPartyNumber)
         {
            OOTRACEERR3("Error:Memory - ooH323MakeCall_helper - "
                        "calledPartyNumber(%s, %s)\n", call->callType, 
                        call->callToken);
            return OO_FAILED;
         }
         strcpy(call->calledPartyNumber,