oochannels.c

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

/*
 * Copyright (C) 2004-2005 by Objective Systems, Inc.
 *
 * This software is furnished under an open source license and may be 
 * used and copied only in accordance with the terms of this license. 
 * The text of the license may generally be found in the root 
 * directory of this installation in the COPYING file.  It 
 * can also be viewed online at the following URL:
 *
 *   http://www.obj-sys.com/open/license.html
 *
 * Any redistributions of this file including modified versions must 
 * maintain this copyright notice.
 *
 *****************************************************************************/

#include "ooports.h" 
#include "oochannels.h"
#include "ootrace.h"
#include "ooq931.h"
#include "ooh245.h"
#include "ooh323.h"
#include "ooCalls.h"
#include "printHandler.h"
#include "ooGkClient.h"
#include "stdio.h"
#include "ooTimer.h"
#include "ooh323ep.h"
#include "ooStackCmds.h"
#include "ooCmdChannel.h"
#include "ootypes.h"

/** Global endpoint structure */
extern OOH323EndPoint gH323ep;

extern DList g_TimerList;

static OOBOOL gMonitor = FALSE;


int ooCreateH245Listener(OOH323CallData *call)
{
   int ret=0;
   OOSOCKET channelSocket=0;
   OOTRACEINFO1("Creating H245 listener\n");
   if((ret=ooSocketCreate (&channelSocket))!=ASN_OK)
   {
      OOTRACEERR3("ERROR: Failed to create socket for H245 listener "
                  "(%s, %s)\n", call->callType, call->callToken);
      return OO_FAILED;
   }
   ret = ooBindPort (OOTCP, channelSocket, call->localIP); 
   if(ret == OO_FAILED)
   {
      OOTRACEERR3("Error:Unable to bind to a TCP port - H245 listener creation"
                  " (%s, %s)\n", call->callType, call->callToken);
      return OO_FAILED;
   }
   call->h245listenport = (int*) memAlloc(call->pctxt, sizeof(int));
   *(call->h245listenport) = ret;
   call->h245listener = (OOSOCKET*)memAlloc(call->pctxt, sizeof(OOSOCKET));
   *(call->h245listener) = channelSocket;
   ret = ooSocketListen(*(call->h245listener), 20);
   if(ret != ASN_OK)
   {
      OOTRACEERR3("Error:Unable to listen on H.245 socket (%s, %s)\n", 
                   call->callType, call->callToken);
      return OO_FAILED;
   }
   
   OOTRACEINFO4("H245 listener creation - successful(port %d) (%s, %s)\n", 
                *(call->h245listenport),call->callType, call->callToken);
   return OO_OK;
}

int ooCreateH245Connection(OOH323CallData *call)
{
   int ret=0;
   OOSOCKET channelSocket=0;
   ooTimerCallback *cbData=NULL;

   OOTRACEINFO1("Creating H245 Connection\n");
   if((ret=ooSocketCreate (&channelSocket))!=ASN_OK)
   {
      OOTRACEERR3("ERROR:Failed to create socket for H245 connection "
                  "(%s, %s)\n", call->callType, call->callToken);
      return OO_FAILED;
   }
   else
   {
      if (0 == call->pH245Channel) {
         call->pH245Channel = 
	    (OOH323Channel*) memAllocZ (call->pctxt, sizeof(OOH323Channel));
      }

      /*
         bind socket to a port before connecting. Thus avoiding
         implicit bind done by a connect call.
      */
      ret = ooBindPort(OOTCP, channelSocket, call->localIP); 
      if(ret == OO_FAILED)
      {
         OOTRACEERR3("Error:Unable to bind to a TCP port - h245 connection "
                     "(%s, %s)\n", call->callType, call->callToken);
         return OO_FAILED;
      }
      call->pH245Channel->port = ret;
      OOTRACEDBGC4("Local H.245 port is %d (%s, %s)\n", 
		   call->pH245Channel->port,
                   call->callType, call->callToken);
      OOTRACEINFO5("Trying to connect to remote endpoint to setup H245 "
                   "connection %s:%d(%s, %s)\n", call->remoteIP, 
                    call->remoteH245Port, call->callType, call->callToken);
              
      if((ret=ooSocketConnect(channelSocket, call->remoteIP,
                              call->remoteH245Port))==ASN_OK)
      {
         call->pH245Channel->sock = channelSocket;
         call->h245SessionState = OO_H245SESSION_ACTIVE;

         OOTRACEINFO3("H245 connection creation succesful (%s, %s)\n",
                      call->callType, call->callToken);

         /*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;
         }
      }
      else
      {
	 if(call->h245ConnectionAttempts >= 3)
         {
            OOTRACEERR3("Error:Failed to setup an H245 connection with remote "
                        "destination. (%s, %s)\n", call->callType, 
                         call->callToken);
            if(call->callState < OO_CALL_CLEAR)
            {
               call->callEndReason = OO_REASON_TRANSPORTFAILURE;
               call->callState = OO_CALL_CLEAR;
            }
            return OO_FAILED;
	 }
         else{
            OOTRACEWARN4("Warn:Failed to connect to remote destination for "
                         "H245 connection - will retry after %d seconds"
                         "(%s, %s)\n", DEFAULT_H245CONNECTION_RETRYTIMEOUT,
                         call->callType, call->callToken);

            cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
                                                     sizeof(ooTimerCallback));
            if(!cbData)
            {
               OOTRACEERR3("Error:Unable to allocate memory for timer "
                           "callback.(%s, %s)\n", call->callType, 
                            call->callToken);
               return OO_FAILED;
            }
            cbData->call = call;
            cbData->timerType = OO_H245CONNECT_TIMER;
            if(!ooTimerCreate(call->pctxt, &call->timerList, 
                              &ooCallH245ConnectionRetryTimerExpired, 
                              DEFAULT_H245CONNECTION_RETRYTIMEOUT, cbData, 
                              FALSE))
            {
               OOTRACEERR3("Error:Unable to create H245 connection retry timer"
                           "(%s, %s)\n", call->callType, call->callToken);
               memFreePtr(call->pctxt, cbData);
               return OO_FAILED;
            }
            return OO_OK;
         }
      }
   }
   return OO_OK;
}

int ooSendH225Msg(OOH323CallData *call, Q931Message *msg)
{
   int iRet=0;
   ASN1OCTET * encodebuf;
   if(!call)
      return OO_FAILED;

   encodebuf = (ASN1OCTET*) memAlloc (call->pctxt, MAXMSGLEN);
   if(!encodebuf)
   {
      OOTRACEERR3("Error:Failed to allocate memory for encoding H225 "
                  "message(%s, %s)\n", call->callType, call->callToken);
      return OO_FAILED;
   }
   iRet = ooEncodeH225Message(call, msg, encodebuf, MAXMSGLEN);
   if(iRet != OO_OK)
   {
      OOTRACEERR3("Error:Failed to encode H225 message. (%s, %s)\n", 
		  call->callType, call->callToken);
      memFreePtr (call->pctxt, encodebuf);
      return OO_FAILED;
   }

   /* If high priority messages, send immediately.*/
   if(encodebuf[0] == OOReleaseComplete || 
      (encodebuf[0]==OOFacility && encodebuf[1]==OOEndSessionCommand))
   {
      dListFreeAll(call->pctxt, &call->pH225Channel->outQueue);
      dListAppend (call->pctxt, &call->pH225Channel->outQueue, encodebuf);
      // ooSendMsg(call, OOQ931MSG);
   }else{

      dListAppend (call->pctxt, &call->pH225Channel->outQueue, encodebuf);
 
      OOTRACEDBGC4("Queued H225 messages %d. (%s, %s)\n", 
                                     call->pH225Channel->outQueue.count, 
                                     call->callType, call->callToken);  
   }
   return OO_OK;
}

int ooCreateH225Connection(OOH323CallData *call)
{
   int ret=0;
   OOSOCKET channelSocket=0;
   if((ret=ooSocketCreate (&channelSocket))!=ASN_OK)
   {
      OOTRACEERR3("Failed to create socket for transmit H2250 channel (%s, %s)"
                  "\n", call->callType, call->callToken);
      if(call->callState < OO_CALL_CLEAR)
      {
         call->callState = OO_CALL_CLEAR;
         call->callEndReason = OO_REASON_TRANSPORTFAILURE;
      }
      return OO_FAILED;
   }
   else
   {
      /*
         bind socket to a port before connecting. Thus avoiding
         implicit bind done by a connect call. Avoided on windows as 
         windows sockets have problem in reusing the addresses even after
         setting SO_REUSEADDR, hence in windows we just allow os to bind
         to any random port.
      */
#ifndef _WIN32
      ret = ooBindPort(OOTCP,channelSocket, call->localIP); 
#else
      ret = ooBindOSAllocatedPort(channelSocket, call->localIP);
#endif
      
      if(ret == OO_FAILED)
      {
         OOTRACEERR3("Error:Unable to bind to a TCP port (%s, %s)\n", 
         call->callType, call->callToken);
         if(call->callState < OO_CALL_CLEAR)
         {
            call->callState = OO_CALL_CLEAR;
            call->callEndReason = OO_REASON_TRANSPORTFAILURE;
         }
         return OO_FAILED;
      }

      if (0 == call->pH225Channel) {
	 call->pH225Channel = 
	    (OOH323Channel*) memAllocZ (call->pctxt, sizeof(OOH323Channel));
      }
      call->pH225Channel->port = ret;

      OOTRACEINFO5("Trying to connect to remote endpoint(%s:%d) to setup "
                   "H2250 channel (%s, %s)\n", call->remoteIP, 
                   call->remotePort, call->callType, call->callToken);

      if((ret=ooSocketConnect(channelSocket, call->remoteIP,
                              call->remotePort))==ASN_OK)
      {
         call->pH225Channel->sock = channelSocket;

         OOTRACEINFO3("H2250 transmiter channel creation - succesful "
                      "(%s, %s)\n", call->callType, call->callToken);

         /* If multihomed, get ip from socket */
         if(!strcmp(call->localIP, "0.0.0.0"))
         {
            OOTRACEDBGA3("Determining ip address for outgoing call in "
                         "multihomed mode. (%s, %s)\n", call->callType, 
                          call->callToken);
            ret = ooSocketGetIpAndPort(channelSocket, call->localIP, 20, 
                                       &call->pH225Channel->port);
            if(ret != ASN_OK)
            {
               OOTRACEERR3("Error:Failed to retrieve local ip and port from "
                           "socket for multihomed mode.(%s, %s)\n", 
                            call->callType, call->callToken);
               if(call->callState < OO_CALL_CLEAR)
               {  /* transport failure */
                  call->callState = OO_CALL_CLEAR;
                  call->callEndReason = OO_REASON_TRANSPORTFAILURE;
               }
               return OO_FAILED;
            }
            OOTRACEDBGA4("Using local ip %s for outgoing call(multihomedMode)."
                         " (%s, %s)\n", call->localIP, call->callType, 
                         call->callToken);
         }
         return OO_OK;
      }
      else
      {
         OOTRACEERR3("ERROR:Failed to connect to remote destination for "
                    "transmit H2250 channel(%s, %s)\n",call->callType,
                     call->callToken);
         if(call->callState < OO_CALL_CLEAR)
         {  /* No one is listening at remote end */
            call->callState = OO_CALL_CLEAR;
            call->callEndReason = OO_REASON_NOUSER;
         }
         return OO_FAILED;
      }

      return OO_FAILED;
   }
}

int ooCloseH225Connection (OOH323CallData *call)
{
   if (0 != call->pH225Channel)
   {
      if(call->pH225Channel->sock != 0)
         ooSocketClose (call->pH225Channel->sock);
      if (call->pH225Channel->outQueue.count > 0)
      {
         dListFreeAll (call->pctxt, &(call->pH225Channel->outQueue));
      }
      memFreePtr (call->pctxt, call->pH225Channel);
      call->pH225Channel = NULL;
   }
   return OO_OK;
}

int ooCreateH323Listener()
{
   int ret=0;
   OOSOCKET channelSocket=0;
   OOIPADDR ipaddrs;

    /* Create socket */
   if((ret=ooSocketCreate (&channelSocket))!=ASN_OK)
   {
      OOTRACEERR1("Failed to create socket for H323 Listener\n");
      return OO_FAILED;
   }
   ret= ooSocketStrToAddr (gH323ep.signallingIP, &ipaddrs);
   if((ret=ooSocketBind (channelSocket, ipaddrs, 
                         gH323ep.listenPort))==ASN_OK) 
   {
      gH323ep.listener = (OOSOCKET*)memAlloc(&gH323ep.ctxt,sizeof(OOSOCKET));
      *(gH323ep.listener) = channelSocket;
          
      ooSocketListen(channelSocket,20); /*listen on socket*/
      OOTRACEINFO1("H323 listener creation - successful\n");
      return OO_OK;
   }
   else
   {
      OOTRACEERR1("ERROR:Failed to create H323 listener\n");
      return OO_FAILED;
   }
}



int ooAcceptH225Connection()    
{
   OOH323CallData * call;
   int ret;
   char callToken[20];
   OOSOCKET h225Channel=0;
   ret = ooSocketAccept (*(gH323ep.listener), &h225Channel, 
                         NULL, NULL);
   if(ret != ASN_OK)
   {
      OOTRACEERR1("Error:Accepting h225 connection\n");
      return OO_FAILED;
   }
   ooGenerateCallToken(callToken, sizeof(callToken));

   call = ooCreateCall("incoming", callToken);
   if(!call)
   {
      OOTRACEERR1("ERROR:Failed to create an incoming call\n");
      return OO_FAILED;
   }

   call->pH225Channel = (OOH323Channel*) 
      memAllocZ (call->pctxt, sizeof(OOH323Channel));

   call->pH225Channel->sock = h225Channel;

   /* If multihomed, get ip from socket */
   if(!strcmp(call->localIP, "0.0.0.0"))
   {
      OOTRACEDBGA3("Determining IP address for incoming call in multihomed "
                   "mode (%s, %s)\n", call->callType, call->callToken);

      ret = ooSocketGetIpAndPort(h225Channel, call->localIP, 20, 
                                       &call->pH225Channel->port);
      if(ret != ASN_OK)
      {
         OOTRACEERR3("Error:Failed to retrieve local ip and port from "
                     "socket for multihomed mode.(%s, %s)\n", 
                      call->callType, call->callToken);
         if(call->callState < OO_CALL_CLEAR)
         {  /* transport failure */
            call->callState = OO_CALL_CLEAR;
            call->callEndReason = OO_REASON_TRANSPORTFAILURE;
         }
         return OO_FAILED;
      }
      OOTRACEDBGA4("Using Local IP address %s for incoming call in multihomed "
                   "mode. (%s, %s)\n", call->localIP, call->callType, 
                    call->callToken);
   }

   return OO_OK;
}

int ooAcceptH245Connection(OOH323CallData *call)
{
   int ret;
   OOSOCKET h245Channel=0;
   ret = ooSocketAccept (*(call->h245listener), &h245Channel, 
                         NULL, NULL);
   if(ret != ASN_OK)
   {
      OOTRACEERR1("Error:Accepting h245 connection\n");
      return OO_FAILED;