oochannels.c

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

                     "(%s, %s)\n", call->callType, call->callToken);
         return OO_FAILED;
      }
      cbData->call = call;
      cbData->timerType = OO_CALLESTB_TIMER;
      if(!ooTimerCreate(call->pctxt, &call->timerList, &ooCallEstbTimerExpired,
                        gH323ep.callEstablishmentTimeout, cbData, FALSE))
      {
         OOTRACEERR3("Error:Unable to create call establishment timer. "
                     "(%s, %s)\n", call->callType, call->callToken);
         memFreePtr(call->pctxt, cbData);
         return OO_FAILED;
      }

      if(gH323ep.h323Callbacks.onOutgoingCall)
         gH323ep.h323Callbacks.onOutgoingCall(call);
      break;
   case OOCallProceeding:
      OOTRACEINFO3("Sent Message - CallProceeding (%s, %s)\n", call->callType,
                    call->callToken);
      break;
   case OOAlert:
      OOTRACEINFO3("Sent Message - Alerting (%s, %s) \n", call->callType,
                    call->callToken);
      if(gH323ep.h323Callbacks.onAlerting && call->callState < OO_CALL_CLEAR)
         gH323ep.h323Callbacks.onAlerting(call);
      break;
   case OOConnect:
      OOTRACEINFO3("Sent Message - Connect (%s, %s)\n", call->callType,
                    call->callToken);
      if(gH323ep.h323Callbacks.onCallEstablished)
         gH323ep.h323Callbacks.onCallEstablished(call);
      break;
   case OOReleaseComplete:
      OOTRACEINFO3("Sent Message - ReleaseComplete (%s, %s)\n", call->callType,
                    call->callToken);

      if(call->callState == OO_CALL_CLEAR_RELEASERECVD)
         call->callState = OO_CALL_CLEARED;
      else{
         call->callState = OO_CALL_CLEAR_RELEASESENT;
         if(gH323ep.gkClient && !OO_TESTFLAG(call->flags, OO_M_DISABLEGK) && 
            gH323ep.gkClient->state == GkClientRegistered){
            OOTRACEDBGA3("Sending DRQ after sending ReleaseComplete."
                         "(%s, %s)\n",   call->callType, call->callToken);
            ooGkClientSendDisengageRequest(gH323ep.gkClient, call);
         }
      }

      if(call->callState == OO_CALL_CLEAR_RELEASESENT && 
         call->h245SessionState == OO_H245SESSION_IDLE)
      {
         cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
                                                  sizeof(ooTimerCallback));
         if(!cbData)
         {
            OOTRACEERR3("Error:Unable to allocate memory for timer callback "
                        "data.(%s, %s)\n", call->callType, call->callToken);
            return OO_FAILED;
         }
         cbData->call = call;
         cbData->timerType = OO_SESSION_TIMER;
         cbData->channelNumber = 0;
         if(!ooTimerCreate(call->pctxt, &call->timerList, 
             &ooSessionTimerExpired, gH323ep.sessionTimeout, cbData, FALSE))
         {
            OOTRACEERR3("Error:Unable to create EndSession timer- "
                        "ReleaseComplete.(%s, %s)\n", call->callType, 
                        call->callToken);
            memFreePtr(call->pctxt, cbData);
            return OO_FAILED;
         }
      }

      if(call->h245SessionState == OO_H245SESSION_CLOSED)
      {
         call->callState = OO_CALL_CLEARED;
      }

      break;
   case OOFacility:
      if(tunneledMsgType == OOFacility)
      {
         OOTRACEINFO3("Sent Message - Facility. (%s, %s)\n", 
                      call->callType, call->callToken);
      }
      else{
         OOTRACEINFO4("Sent Message - Facility(%s) (%s, %s)\n", 
                      ooGetMsgTypeText(tunneledMsgType), 
		      call->callType, call->callToken);

         ooOnSendMsg(call, tunneledMsgType, 0, associatedChan);
      }

      
      break;
   case OOMasterSlaveDetermination:
     if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
        OOTRACEINFO3("Tunneled Message - MasterSlaveDetermination (%s, %s)\n", 
                      call->callType, call->callToken);
      else
         OOTRACEINFO3("Sent Message - MasterSlaveDetermination (%s, %s)\n", 
                       call->callType, call->callToken);
       /* Start MSD timer */
      cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
                                                     sizeof(ooTimerCallback));
      if(!cbData)
      {
         OOTRACEERR3("Error:Unable to allocate memory for timer callback data."
                     "(%s, %s)\n", call->callType, call->callToken);
         return OO_FAILED;
      }
      cbData->call = call;
      cbData->timerType = OO_MSD_TIMER;
      if(!ooTimerCreate(call->pctxt, &call->timerList, &ooMSDTimerExpired,
                        gH323ep.msdTimeout, cbData, FALSE))
      {
         OOTRACEERR3("Error:Unable to create MSD timer. "
                     "(%s, %s)\n", call->callType, call->callToken);
         memFreePtr(call->pctxt, cbData);
         return OO_FAILED;
      }

      break;
   case OOMasterSlaveAck:
     if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
         OOTRACEINFO3("Tunneled Message - MasterSlaveDeterminationAck (%s, %s)"
                      "\n",  call->callType, call->callToken);
     else
        OOTRACEINFO3("Sent Message - MasterSlaveDeterminationAck (%s, %s)\n", 
                    call->callType, call->callToken);
      break;
   case OOMasterSlaveReject:
     if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
        OOTRACEINFO3("Tunneled Message - MasterSlaveDeterminationReject "
                     "(%s, %s)\n", call->callType, call->callToken);
     else
        OOTRACEINFO3("Sent Message - MasterSlaveDeterminationReject(%s, %s)\n",
                    call->callType, call->callToken);
      break;
   case OOMasterSlaveRelease:
      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
         OOTRACEINFO3("Tunneled Message - MasterSlaveDeterminationRelease "
                      "(%s, %s)\n", call->callType, call->callToken);
      else
         OOTRACEINFO3("Sent Message - MasterSlaveDeterminationRelease "
                      "(%s, %s)\n", call->callType, call->callToken);
      break;
   case OOTerminalCapabilitySet:
      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)){
         /* If session isn't marked active yet, do it. possible in case of 
            tunneling */
         if(call->h245SessionState == OO_H245SESSION_IDLE)
            call->h245SessionState = OO_H245SESSION_ACTIVE;
         OOTRACEINFO3("Tunneled Message - TerminalCapabilitySet (%s, %s)\n", 
                       call->callType, call->callToken);
      }
      else
         OOTRACEINFO3("Sent Message - TerminalCapabilitySet (%s, %s)\n", 
                       call->callType, call->callToken);
      /* Start TCS timer */
      cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
                                                     sizeof(ooTimerCallback));
      if(!cbData)
      {
         OOTRACEERR3("Error:Unable to allocate memory for timer callback data."
                     "(%s, %s)\n", call->callType, call->callToken);
         return OO_FAILED;
      }
      cbData->call = call;
      cbData->timerType = OO_TCS_TIMER;
      if(!ooTimerCreate(call->pctxt, &call->timerList, &ooTCSTimerExpired,
                        gH323ep.tcsTimeout, cbData, FALSE))
      {
         OOTRACEERR3("Error:Unable to create TCS timer. "
                     "(%s, %s)\n", call->callType, call->callToken);
         memFreePtr(call->pctxt, cbData);
         return OO_FAILED;
      }

      break;
   case OOTerminalCapabilitySetAck:
      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
         OOTRACEINFO3("Tunneled Message - TerminalCapabilitySetAck (%s, %s)\n",
                       call->callType, call->callToken);
      else
         OOTRACEINFO3("Sent Message - TerminalCapabilitySetAck (%s, %s)\n", 
                       call->callType, call->callToken);
      break;
   case OOTerminalCapabilitySetReject:
      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
         OOTRACEINFO3("Tunneled Message - TerminalCapabilitySetReject "
                      "(%s, %s)\n",  call->callType, call->callToken);
      else
         OOTRACEINFO3("Sent Message - TerminalCapabilitySetReject (%s, %s)\n", 
                       call->callType, call->callToken);
      break;
   case OOOpenLogicalChannel:
      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
         OOTRACEINFO4("Tunneled Message - OpenLogicalChannel(%d). (%s, %s)\n", 
                       associatedChan, call->callType, call->callToken);
      else
         OOTRACEINFO4("Sent Message - OpenLogicalChannel(%d). (%s, %s)\n", 
                       associatedChan, call->callType, call->callToken);
      /* Start LogicalChannel timer */
      cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
                                                     sizeof(ooTimerCallback));
      if(!cbData)
      {
         OOTRACEERR3("Error:Unable to allocate memory for timer callback data."
                     "(%s, %s)\n", call->callType, call->callToken);
         return OO_FAILED;
      }
      cbData->call = call;
      cbData->timerType = OO_OLC_TIMER;
      cbData->channelNumber = associatedChan;
      if(!ooTimerCreate(call->pctxt, &call->timerList, 
          &ooOpenLogicalChannelTimerExpired, gH323ep.logicalChannelTimeout, 
          cbData, FALSE))
      {
         OOTRACEERR3("Error:Unable to create OpenLogicalChannel timer. "
                     "(%s, %s)\n", call->callType, call->callToken);
         memFreePtr(call->pctxt, cbData);
         return OO_FAILED;
      }
      
      break;
   case OOOpenLogicalChannelAck:
      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
         OOTRACEINFO4("Tunneled Message - OpenLogicalChannelAck(%d) (%s,%s)\n",
                       associatedChan, call->callType, call->callToken);
      else
         OOTRACEINFO4("Sent Message - OpenLogicalChannelAck(%d) (%s, %s)\n", 
                       associatedChan, call->callType, call->callToken);
      break;
   case OOOpenLogicalChannelReject:
      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
         OOTRACEINFO4("Tunneled Message - OpenLogicalChannelReject(%d)"
                      "(%s, %s)\n", associatedChan, call->callType, 
                      call->callToken);
      else
         OOTRACEINFO4("Sent Message - OpenLogicalChannelReject(%d) (%s, %s)\n",
                       associatedChan, call->callType, call->callToken);
      break;
   case OOEndSessionCommand:
      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
         OOTRACEINFO3("Tunneled Message - EndSessionCommand(%s, %s)\n", 
                                             call->callType, call->callToken);
      else
         OOTRACEINFO3("Sent Message - EndSessionCommand (%s, %s)\n", 
                                           call->callType, call->callToken);
      if((call->h245SessionState == OO_H245SESSION_ACTIVE))
      { 
         /* Start EndSession timer */
         call->h245SessionState = OO_H245SESSION_ENDSENT;
         cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
                                                  sizeof(ooTimerCallback));
         if(!cbData)
         {
            OOTRACEERR3("Error:Unable to allocate memory for timer callback "
                        "data.(%s, %s)\n", call->callType, call->callToken);
            return OO_FAILED;
         }
         cbData->call = call;
         cbData->timerType = OO_SESSION_TIMER;
         cbData->channelNumber = 0;
         if(!ooTimerCreate(call->pctxt, &call->timerList, 
             &ooSessionTimerExpired, gH323ep.sessionTimeout, cbData, FALSE))
         {
            OOTRACEERR3("Error:Unable to create EndSession timer. "
                        "(%s, %s)\n", call->callType, call->callToken);
            memFreePtr(call->pctxt, cbData);
            return OO_FAILED;
         }
      }else{
         ooCloseH245Connection(call);
      }
      break;
   case OOCloseLogicalChannel:
      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
         OOTRACEINFO3("Tunneled Message - CloseLogicalChannel (%s, %s)\n", 
                       call->callType, call->callToken);
      else
         OOTRACEINFO3("Sent Message - CloseLogicalChannel (%s, %s)\n", 
                       call->callType, call->callToken);
      /* Start LogicalChannel timer */
      cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
                                                     sizeof(ooTimerCallback));
      if(!cbData)
      {
         OOTRACEERR3("Error:Unable to allocate memory for timer callback data."
                     "(%s, %s)\n", call->callType, call->callToken);
         return OO_FAILED;
      }
      cbData->call = call;
      cbData->timerType = OO_CLC_TIMER;
      cbData->channelNumber = associatedChan;
      if(!ooTimerCreate(call->pctxt, &call->timerList, 
          &ooCloseLogicalChannelTimerExpired, gH323ep.logicalChannelTimeout, 
          cbData, FALSE))
      {
         OOTRACEERR3("Error:Unable to create CloseLogicalChannel timer. "
                     "(%s, %s)\n", call->callType, call->callToken);
         memFreePtr(call->pctxt, cbData);
         return OO_FAILED;
      }
      
      break;
   case OOCloseLogicalChannelAck:
      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
         OOTRACEINFO3("Tunneled Message - CloseLogicalChannelAck (%s, %s)\n", 
                       call->callType, call->callToken);
      else
         OOTRACEINFO3("Sent Message - CloseLogicalChannelAck (%s, %s)\n", 
                       call->callType, call->callToken);
      break;
   case OORequestChannelClose:
      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
         OOTRACEINFO3("Tunneled Message - RequestChannelClose (%s, %s)\n", 
                       call->callType, call->callToken);
      else
         OOTRACEINFO3("Sent Message - RequestChannelClose (%s, %s)\n", 
                       call->callType, call->callToken);
      /* Start RequestChannelClose timer */
      cbData = (ooTimerCallback*) memAlloc(call->pctxt, 
                                                     sizeof(ooTimerCallback));
      if(!cbData)
      {
         OOTRACEERR3("Error:Unable to allocate memory for timer callback data."
                     "(%s, %s)\n", call->callType, call->callToken);
         return OO_FAILED;
      }
      cbData->call = call;
      cbData->timerType = OO_RCC_TIMER;
      cbData->channelNumber = associatedChan;
      if(!ooTimerCreate(call->pctxt, &call->timerList, 
          &ooRequestChannelCloseTimerExpired, gH323ep.logicalChannelTimeout, 
          cbData, FALSE))
      {
         OOTRACEERR3("Error:Unable to create RequestChannelClose timer. "
                     "(%s, %s)\n", call->callType, call->callToken);
         memFreePtr(call->pctxt, cbData);
         return OO_FAILED;
      }
      break;
   case OORequestChannelCloseAck:
      if(OO_TESTFLAG (call->flags, OO_M_TUNNELING))
         OOTRACEINFO3("Tunneled Message - RequestChannelCloseAck (%s, %s)\n", 
                       call->callType, call->callToken);
      else
         OOTRACEINFO3("Sent Message - RequestChannelCloseAck (%s, %s)\n", 
                       call->callType, call->callToken);
      break;
   
   default:
     ;
   }
   return OO_OK;
}


int ooStopMonitorCalls()
{
   OOH323CallData * call;
   if(gMonitor)
   {
      OOTRACEINFO1("Doing ooStopMonitorCalls\n");
      if(gH323ep.cmdSock)
      {
         ooCloseCmdConnection();
      }

      if(gH323ep.callList)
      {
         OOTRACEWARN1("Warn:Abruptly ending calls as stack going down\n");
         call = gH323ep.callList;
         while(call)
         {
            OOTRACEWARN3("Clearing call (%s, %s)\n", call->callType, 
                          call->callToken);
            call->callEndReason = OO_REASON_LOCAL_CLEARED;
            ooCleanCall(call);
            call = NULL;
            call = gH323ep.callList;
         }
         gH323ep.callList = NULL;
      }
      OOTRACEINFO1("Stopping listener for incoming calls\n");   
      if(gH323ep.listener)
      {
         ooSocketClose(*(gH323ep.listener));
         memFreePtr(&gH323ep.ctxt, gH323ep.listener);
         gH323ep.listener = NULL;
      }

      gMonitor = FALSE;
      OOTRACEINFO1("Done ooStopMonitorCalls\n");
   }
   return OO_OK;
}

OOBOOL ooChannelsIsConnectionOK(OOH323CallData *call, OOSOCKET sock)
{
   struct timeval to;
   fd_set readfds;
   int ret = 0, nfds=0; 

   to.tv_sec = 0;
   to.tv_usec = 500;
   FD_ZERO(&readfds);

   FD_SET(sock, &readfds);
   if(nfds < (int)sock)
      nfds = (int)sock;

   nfds++;

   ret = ooSocketSelect(nfds, &readfds, NULL, NULL, &to);
      
   if(ret == -1)
   {
      OOTRACEERR3("Error in select ...broken pipe check(%s, %s)\n",
                   call->callType, call->callToken );
      return FALSE;
   }

   if(FD_ISSET(sock, &readfds))
   {
      char buf[2];      
      if(ooSocketRecvPeek(sock, buf, 2) == 0)
      {
         OOTRACEWARN3("Broken pipe detected. (%s, %s)", call->callType, 
                       call->callToken);
         if(call->callState < OO_CALL_CLEAR)
            call->callEndReason = OO_REASON_TRANSPORTFAILURE;
         call->callState = OO_CALL_CLEARED;
         return FALSE;
      }
   }
   return TRUE;
}