oogkclient.c

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

}

int ooGkClientHandleGatekeeperConfirm
   (ooGkClient *pGkClient, H225GatekeeperConfirm *pGatekeeperConfirm)
{
   int iRet=0;
   unsigned int x=0;
   DListNode *pNode = NULL;
   OOTimer *pTimer = NULL;
   H225TransportAddress_ipAddress *pRasAddress;

   if(pGkClient->discoveryComplete)
   {
      OOTRACEDBGB1("Ignoring GKConfirm as Gatekeeper has been discovered\n");
      return OO_OK;
   }

   if(pGatekeeperConfirm->m.gatekeeperIdentifierPresent) 
   {
      pGkClient->gkId.nchars = pGatekeeperConfirm->gatekeeperIdentifier.nchars;
      pGkClient->gkId.data = (ASN116BITCHAR*)memAlloc(&pGkClient->ctxt,
                              sizeof(ASN116BITCHAR)*pGkClient->gkId.nchars);
      if(!pGkClient->gkId.data)
      {
         OOTRACEERR1("Error:Failed to allocate memory for GK ID data\n");
         pGkClient->state = GkClientFailed;
         return OO_FAILED;
      }

      memcpy(pGkClient->gkId.data, 
             pGatekeeperConfirm->gatekeeperIdentifier.data,
             sizeof(ASN116BITCHAR)* pGkClient->gkId.nchars);
   }
   else{
      OOTRACEERR1("ERROR:No Gatekeeper ID present in received GKConfirmed "
                  "message\n");
      OOTRACEINFO1("Ignoring message and will retransmit GRQ after timeout\n");
      return OO_FAILED;
   }
   
   /* Extract Gatekeeper's RAS address */
   if(pGatekeeperConfirm->rasAddress.t != T_H225TransportAddress_ipAddress)
   {
      OOTRACEERR1("ERROR:Unsupported RAS address type in received Gk Confirm"
                  " message.\n");
      pGkClient->state = GkClientGkErr;
      return OO_FAILED;
   }
   pRasAddress =   pGatekeeperConfirm->rasAddress.u.ipAddress;
   sprintf(pGkClient->gkRasIP, "%d.%d.%d.%d", pRasAddress->ip.data[0],
                                              pRasAddress->ip.data[1],
                                              pRasAddress->ip.data[2], 
                                              pRasAddress->ip.data[3]);
   pGkClient->gkRasPort = pRasAddress->port;
   
   pGkClient->discoveryComplete = TRUE;
   pGkClient->state = GkClientDiscovered;
   OOTRACEINFO1("Gatekeeper Confirmed\n");


   /* Delete the corresponding GRQ timer */
   for(x=0; x<pGkClient->timerList.count; x++)
   {
      pNode =  dListFindByIndex(&pGkClient->timerList, x);
      pTimer = (OOTimer*)pNode->data;
      if(((ooGkClientTimerCb*)pTimer->cbData)->timerType & OO_GRQ_TIMER)
      {
         memFreePtr(&pGkClient->ctxt, pTimer->cbData);
         ooTimerDelete(&pGkClient->ctxt, &pGkClient->timerList, pTimer);
         OOTRACEDBGA1("Deleted GRQ Timer.\n");
         break;
      }
   }

   iRet = ooGkClientSendRRQ(pGkClient, FALSE);
   if(iRet != OO_OK)
   {
      OOTRACEERR1("Error:Failed to send initial RRQ\n");
      return OO_FAILED;
   }
   return OO_OK;
}

/**
 * Send RRQ.
 */

int ooGkClientSendRRQ(ooGkClient *pGkClient, ASN1BOOL keepAlive)
{
   int iRet;
   H225RasMessage *pRasMsg=NULL;
   H225RegistrationRequest *pRegReq=NULL;
   OOCTXT *pctxt=NULL;
   H225TransportAddress *pTransportAddress=NULL;
   H225TransportAddress_ipAddress *pIpAddress=NULL;
   ooGkClientTimerCb *cbData =NULL;

   pctxt = &pGkClient->msgCtxt;

   pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage));
   if(!pRasMsg)
   {
      OOTRACEERR1("Error: Memory allocation for RRQ RAS message failed\n");
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }

   pRegReq = (H225RegistrationRequest*)memAlloc(pctxt, 
                                          sizeof(H225RegistrationRequest));
   if(!pRegReq)
   {
      OOTRACEERR1("Error:Memory allocation for RRQ failed\n");
      memReset(pctxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   memset(pRegReq, 0, sizeof(H225RegistrationRequest));
   pRasMsg->t = T_H225RasMessage_registrationRequest;
   pRasMsg->u.registrationRequest = pRegReq;
   
   pRegReq->protocolIdentifier = gProtocolID;
   pRegReq->m.nonStandardDataPresent=0;
   /* Populate CallSignal Address List*/
   pTransportAddress = (H225TransportAddress*) memAlloc(pctxt, 
                                                 sizeof(H225TransportAddress));
   pIpAddress = (H225TransportAddress_ipAddress*) memAlloc(pctxt,
                                       sizeof(H225TransportAddress_ipAddress));
   if(!pTransportAddress || !pIpAddress)
   {
      OOTRACEERR1("Error:Failed to allocate memory for signalling address of "
                  "RRQ message\n");
      memReset(pctxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   pTransportAddress->t = T_H225TransportAddress_ipAddress;
   pTransportAddress->u.ipAddress = pIpAddress;
   ooSocketConvertIpToNwAddr(pGkClient->localRASIP, pIpAddress->ip.data);
   pIpAddress->ip.numocts = 4;
   pIpAddress->port = gH323ep.listenPort;
   
   dListInit(&pRegReq->callSignalAddress);
   dListAppend(pctxt, &pRegReq->callSignalAddress, 
                                       (void*)pTransportAddress);

   /* Populate RAS Address List*/
   pTransportAddress = NULL;
   pIpAddress = NULL;
   pTransportAddress = (H225TransportAddress*) memAlloc(pctxt, 
                                                 sizeof(H225TransportAddress));
   pIpAddress = (H225TransportAddress_ipAddress*) memAlloc(pctxt,
                                       sizeof(H225TransportAddress_ipAddress));
   if(!pTransportAddress || !pIpAddress)
   {
      OOTRACEERR1("Error:Failed to allocate memory for RAS address of "
                  "RRQ message\n");
      memReset(pctxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }

   pTransportAddress->t = T_H225TransportAddress_ipAddress;
   pTransportAddress->u.ipAddress = pIpAddress;
   
   ooSocketConvertIpToNwAddr(pGkClient->localRASIP, pIpAddress->ip.data);

   pIpAddress->ip.numocts = 4;
   pIpAddress->port = pGkClient->localRASPort;
   
   dListInit(&pRegReq->rasAddress);
   dListAppend(pctxt, &pRegReq->rasAddress, 
                                       (void*)pTransportAddress);
   
   /* Pose as gateway or terminal as per config */
   if(gH323ep.isGateway)
      pRegReq->terminalType.m.gatewayPresent = TRUE;
   else
      pRegReq->terminalType.m.terminalPresent = TRUE;

   pRegReq->terminalType.m.vendorPresent=TRUE;
   ooGkClientFillVendor(pGkClient, &pRegReq->terminalType.vendor );
  
   pRegReq->m.terminalAliasPresent=TRUE;
   if(OO_OK != ooPopulateAliasList(pctxt, gH323ep.aliases, 
                                      &pRegReq->terminalAlias))
   {
      OOTRACEERR1("Error filling alias for RRQ\n");
      memReset(pctxt); 
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   
   pRegReq->m.gatekeeperIdentifierPresent=TRUE;
   pRegReq->gatekeeperIdentifier.nchars = pGkClient->gkId.nchars;
   pRegReq->gatekeeperIdentifier.data = (ASN116BITCHAR*)memAlloc
                         (pctxt, pGkClient->gkId.nchars*sizeof(ASN116BITCHAR));
   if(!pRegReq->gatekeeperIdentifier.data)
   {
      OOTRACEERR1("Error: Failed to allocate memory for GKIdentifier in RRQ "
                   "message.\n");
      memReset(pctxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   memcpy(pRegReq->gatekeeperIdentifier.data, pGkClient->gkId.data, 
                                pGkClient->gkId.nchars*sizeof(ASN116BITCHAR));
   
   ooGkClientFillVendor(pGkClient, &pRegReq->endpointVendor);
   
   pRegReq->m.willSupplyUUIEsPresent=TRUE;
   pRegReq->willSupplyUUIEs=FALSE;

   pRegReq->requestSeqNum = pGkClient->requestSeqNum++;
   if(!pRegReq->requestSeqNum)
      pRegReq->requestSeqNum = pGkClient->requestSeqNum++;
   
   pRegReq->discoveryComplete= pGkClient->discoveryComplete;
   pRegReq->m.keepAlivePresent=TRUE;
   pRegReq->keepAlive= keepAlive;
   pRegReq->m.timeToLivePresent = TRUE;
   pRegReq->timeToLive = pGkClient->regTimeout;

   iRet = ooGkClientSendMsg(pGkClient, pRasMsg);
   if(iRet != OO_OK)
   {
      OOTRACEERR1("Error: Failed to send RRQ message\n");
      memReset(pctxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   OOTRACEINFO1("Sent RRQ message \n");
   /* Start RRQ Timer */
   cbData = (ooGkClientTimerCb*) memAlloc
                            (&pGkClient->ctxt, sizeof(ooGkClientTimerCb));
   if(!cbData)
   {
      OOTRACEERR1("Error:Failed to allocate memory to RRQ timer callback\n");
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   cbData->timerType = OO_RRQ_TIMER;
   cbData->pGkClient = pGkClient;
   if(!ooTimerCreate(&pGkClient->ctxt, &pGkClient->timerList, 
                     &ooGkClientRRQTimerExpired, pGkClient->rrqTimeout, 
                     cbData, FALSE))      
   {
      OOTRACEERR1("Error:Unable to create GRQ timer.\n ");
      memFreePtr(&pGkClient->ctxt, cbData);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   
   return OO_OK;
}



/**
 * Manage incoming RCF message.
 */

int ooGkClientHandleRegistrationConfirm
   (ooGkClient *pGkClient, H225RegistrationConfirm *pRegistrationConfirm)
{
   int i=0;
   unsigned int x=0;
   OOTimer *pTimer = NULL;
   DListNode *pNode = NULL;
   H225TransportAddress *pCallSigAddr=NULL;
   ooGkClientTimerCb *cbData;
   ASN1UINT regTTL=0;
   /* Extract Endpoint Id */
   pGkClient->endpointId.nchars = 
                              pRegistrationConfirm->endpointIdentifier.nchars;
   pGkClient->endpointId.data = (ASN116BITCHAR*)memAlloc(&pGkClient->ctxt,
                          sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars);
   if(!pGkClient->endpointId.data)
   {
      OOTRACEERR1("Error:Failed to allocate memory for endpoint Id.\n");
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   
   memcpy(pGkClient->endpointId.data, 
          pRegistrationConfirm->endpointIdentifier.data,
          sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars);
   
   /* Extract CallSignalling Address */
   for(i=0; i<(int)pRegistrationConfirm->callSignalAddress.count; i++)
   {
      pNode = dListFindByIndex(&pRegistrationConfirm->callSignalAddress, i);
      if(!pNode)
      {
         OOTRACEERR1("Error:Invalid Registration confirmed message\n");
         OOTRACEINFO1("Ignoring RCF, will retransmit RRQ after timeout\n");
         return OO_FAILED; 
      }
      pCallSigAddr = (H225TransportAddress*)pNode->data;
      if(pCallSigAddr->t != T_H225TransportAddress_ipAddress)
         continue;
      sprintf(pGkClient->gkCallSignallingIP, "%d.%d.%d.%d", 
                            pCallSigAddr->u.ipAddress->ip.data[0],
                            pCallSigAddr->u.ipAddress->ip.data[1],
                            pCallSigAddr->u.ipAddress->ip.data[2],
                            pCallSigAddr->u.ipAddress->ip.data[3]);
      pGkClient->gkCallSignallingPort = pCallSigAddr->u.ipAddress->port;
   }
   
   /* Update list of registered aliases*/
   if(pRegistrationConfirm->m.terminalAliasPresent)
   {
      ooGkClientUpdateRegisteredAliases(pGkClient, 
                                   &pRegistrationConfirm->terminalAlias, TRUE);
   }else{/* Everything registered*/
     ooGkClientUpdateRegisteredAliases(pGkClient, NULL, TRUE);
   }

   /* Is keepAlive supported */
   if(pRegistrationConfirm->m.timeToLivePresent)
   {
      pGkClient->regTimeout = pRegistrationConfirm->timeToLive;
      OOTRACEINFO2("Gatekeeper supports KeepAlive, Registration TTL is %d\n",
                    pRegistrationConfirm->timeToLive);

      if(pGkClient->regTimeout > DEFAULT_TTL_OFFSET)
         regTTL = pGkClient->regTimeout - DEFAULT_TTL_OFFSET;
      else
         regTTL = pGkClient->regTimeout;

      cbData = (ooGkClientTimerCb*) memAlloc
                                (&pGkClient->ctxt, sizeof(ooGkClientTimerCb));
      if(!cbData)
      {
         OOTRACEERR1("Error:Failed to allocate memory for Regisration timer."
                     "\n");
         pGkClient->state = GkClientFailed;
         return OO_FAILED;
      }
      cbData->timerType = OO_REG_TIMER;
      cbData->pGkClient = pGkClient;
      if(!ooTimerCreate(&pGkClient->ctxt, &pGkClient->timerList, 
                     &ooGkClientREGTimerExpired, regTTL, 
                     cbData, FALSE))
      {
         OOTRACEERR1("Error:Unable to create REG timer.\n ");
         memFreePtr(&pGkClient->ctxt, cbData);
         pGkClient->state = GkClientFailed;
         return OO_FAILED;
      }    
      
   }else{
      pGkClient->regTimeout = 0;
      OOTRACEINFO1("Gatekeeper does not support KeepAlive.\n");
   }
   /* Extract Pre-Granted ARQ */
   if(pRegistrationConfirm->m.preGrantedARQPresent)
   {
      memcpy(&pGkClient->gkInfo.preGrantedARQ, 
             &pRegistrationConfirm->preGrantedARQ,
             sizeof(H225RegistrationConfirm_preGrantedARQ));
   }


   /* First delete the corresponding RRQ timer */
   pNode = NULL;
   for(x=0; x<pGkClient->timerList.count; x++)
   {
      pNode =  dListFindByIndex(&pGkClient->timerList, x);
      pTimer = (OOTimer*)pNode->data;
      if(((ooGkClientTimerCb*)pTimer->cbData)->timerType & OO_RRQ_TIMER)
      {
         memFreePtr(&pGkClient->ctxt, pTimer->cbData);
         ooTimerDelete(&pGkClient->ctxt, &pGkClient->timerList, pTimer);
         OOTRACEDBGA1("Deleted RRQ Timer.\n");
         break;
      }
   }
   pGkClient->state = GkClientRegistered;
   if(pGkClient->callbacks.onReceivedRegistrationConfirm)