oogkclient.c

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

      pGkClient->callbacks.onReceivedRegistrationConfirm(pRegistrationConfirm,
                                                              gH323ep.aliases);
   return OO_OK;
}

int ooGkClientHandleRegistrationReject
   (ooGkClient *pGkClient, H225RegistrationReject *pRegistrationReject)
{
   int iRet=0;
   unsigned int x=0;
   DListNode *pNode = NULL;
   OOTimer *pTimer = NULL;
   /* First delete the corresponding RRQ timer */
   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;
      }
   }

   switch(pRegistrationReject->rejectReason.t)
   {
   case T_H225RegistrationRejectReason_discoveryRequired:
      OOTRACEINFO1("RRQ Rejected - Discovery Required\n");

      pGkClient->discoveryComplete = FALSE;
      pGkClient->state = GkClientIdle;
      pGkClient->rrqRetries = 0;
      pGkClient->grqRetries = 0;
      if(OO_OK != ooGkClientSendGRQ(pGkClient))
      {
         OOTRACEERR1("Error:Failed to send GRQ message\n");
         return OO_FAILED;
      }
      return OO_OK;
   case T_H225RegistrationRejectReason_invalidRevision:
      OOTRACEERR1("RRQ Rejected - Invalid Revision\n");
      break;
   case T_H225RegistrationRejectReason_invalidCallSignalAddress:
      OOTRACEERR1("RRQ Rejected - Invalid CallSignalAddress\n");
      break;
   case T_H225RegistrationRejectReason_invalidRASAddress:
      OOTRACEERR1("RRQ Rejected - Invalid RAS Address\n");
      break;
   case T_H225RegistrationRejectReason_duplicateAlias:
      OOTRACEERR1("RRQ Rejected - Duplicate Alias\n");
      break;
   case T_H225RegistrationRejectReason_invalidTerminalType:
      OOTRACEERR1("RRQ Rejected - Invalid Terminal Type\n");
      break;
   case T_H225RegistrationRejectReason_undefinedReason:
      OOTRACEERR1("RRQ Rejected - Undefined Reason\n");
      break;
   case T_H225RegistrationRejectReason_transportNotSupported:
      OOTRACEERR1("RRQ Rejected - Transport Not supported\n");
      break;
   case T_H225RegistrationRejectReason_transportQOSNotSupported:
      OOTRACEERR1("RRQ Rejected - Transport QOS Not Supported\n");
      break;
   case T_H225RegistrationRejectReason_resourceUnavailable:
      OOTRACEERR1("RRQ Rejected - Resource Unavailable\n");
      break;
   case T_H225RegistrationRejectReason_invalidAlias:
      OOTRACEERR1("RRQ Rejected - Invalid Alias\n");
      break;
   case T_H225RegistrationRejectReason_securityDenial:
      OOTRACEERR1("RRQ Rejected - Security Denial\n");
      break;
   case T_H225RegistrationRejectReason_fullRegistrationRequired:
      OOTRACEINFO1("RRQ Rejected - Full Registration Required\n");
      pGkClient->state = GkClientDiscovered;
      pGkClient->rrqRetries = 0;
      iRet = ooGkClientSendRRQ(pGkClient, 0); /* No keepAlive */
      if(iRet != OO_OK){
         OOTRACEERR1("\nError: Full Registration transmission failed\n");
         return OO_FAILED;
      }
      return OO_OK;
   case T_H225RegistrationRejectReason_additiveRegistrationNotSupported:
      OOTRACEERR1("RRQ Rejected - Additive Registration Not Supported\n");
      break;
   case T_H225RegistrationRejectReason_invalidTerminalAliases:
      OOTRACEERR1("RRQ Rejected - Invalid Terminal Aliases\n");
      break;
   case T_H225RegistrationRejectReason_genericDataReason:
      OOTRACEERR1("RRQ Rejected - Generic Data Reason\n");
      break;
   case T_H225RegistrationRejectReason_neededFeatureNotSupported:
      OOTRACEERR1("RRQ Rejected - Needed Feature Not Supported\n");
      break;
   case T_H225RegistrationRejectReason_securityError:
      OOTRACEERR1("RRQ Rejected - Security Error\n");
      break;
   default:
      OOTRACEINFO1("RRQ Rejected - Invalid Reason\n");
   }
   pGkClient->state = GkClientGkErr;
   return OO_OK;
}


int ooGkClientSendURQ(ooGkClient *pGkClient, ooAliases *aliases)
{
   int iRet;
   H225RasMessage *pRasMsg=NULL;
   H225UnregistrationRequest *pUnregReq=NULL;
   OOCTXT *pctxt=NULL;
   H225TransportAddress *pTransportAddress=NULL;
   H225TransportAddress_ipAddress *pIpAddress=NULL;

   pctxt = &pGkClient->msgCtxt;

   OOTRACEDBGA1("Building Unregistration Request message\n");

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

   pUnregReq = (H225UnregistrationRequest*)memAlloc(pctxt, 
                                          sizeof(H225UnregistrationRequest));
   if(!pUnregReq)
   {
      OOTRACEERR1("Error:Memory allocation for URQ failed\n");
      memReset(pctxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   memset(pUnregReq, 0, sizeof(H225UnregistrationRequest));
   pRasMsg->t = T_H225RasMessage_unregistrationRequest;
   pRasMsg->u.unregistrationRequest = pUnregReq;

   pUnregReq->requestSeqNum = pGkClient->requestSeqNum++;
   if(!pUnregReq->requestSeqNum)
      pUnregReq->requestSeqNum = pGkClient->requestSeqNum++;

   

 /* 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(&pUnregReq->callSignalAddress);
   dListAppend(pctxt, &pUnregReq->callSignalAddress, 
                                       (void*)pTransportAddress);

   /* Populate Endpoint Identifier */
   pUnregReq->m.endpointIdentifierPresent = TRUE;
   pUnregReq->endpointIdentifier.nchars = pGkClient->endpointId.nchars;
   pUnregReq->endpointIdentifier.data = (ASN116BITCHAR*)memAlloc(pctxt,
                           sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars);
   if(!pUnregReq->endpointIdentifier.data)
   {
      OOTRACEERR1("Error: Failed to allocate memory for EndPoint Id in URQ "
                  "message.\n");
      memReset(pctxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   memcpy((void*)pUnregReq->endpointIdentifier.data, 
          (void*)pGkClient->endpointId.data,
          sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars);

   /* Populate gatekeeper identifier */
   pUnregReq->m.gatekeeperIdentifierPresent = TRUE;
   pUnregReq->gatekeeperIdentifier.nchars = pGkClient->gkId.nchars;
   pUnregReq->gatekeeperIdentifier.data = (ASN116BITCHAR*)memAlloc(pctxt,
                                 sizeof(ASN116BITCHAR)*pGkClient->gkId.nchars);
   if(!pUnregReq->gatekeeperIdentifier.data)
   {
      OOTRACEERR1("Error:Failed to allocate memory for GKID of URQ message\n");
      memReset(pctxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   memcpy((void*)pUnregReq->gatekeeperIdentifier.data, 
          (void*)pGkClient->gkId.data, 
          sizeof(ASN116BITCHAR)*pGkClient->gkId.nchars);   

   /* Check whether specific aliases are to be unregistered*/
   if(aliases)
   {
      pUnregReq->m.endpointAliasPresent = TRUE;
      ooPopulateAliasList(pctxt, aliases, &pUnregReq->endpointAlias);
   }

  
   iRet = ooGkClientSendMsg(pGkClient, pRasMsg);
   if(iRet != OO_OK)
   {
      OOTRACEERR1("Error:Failed to send UnregistrationRequest message\n");
      memReset(pctxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   pGkClient->state = GkClientUnregistered;
   OOTRACEINFO1("Unregistration Request message sent.\n");

   return OO_OK;
}               



int ooGkClientHandleUnregistrationRequest
   (ooGkClient *pGkClient, H225UnregistrationRequest * punregistrationRequest)
{
   int iRet=0;

   /* Lets first send unregistration confirm message back to gatekeeper*/
   ooGkClientSendUnregistrationConfirm(pGkClient, 
                                      punregistrationRequest->requestSeqNum);

   if(punregistrationRequest->m.endpointAliasPresent)
   {
      OOTRACEINFO1("Gatekeeper requested a list of aliases be unregistered\n");
      ooGkClientUpdateRegisteredAliases(pGkClient, 
                                &punregistrationRequest->endpointAlias, FALSE);
   }else{

      OOTRACEINFO1("Gatekeeper requested a all aliases to be unregistered\n");
      ooGkClientUpdateRegisteredAliases(pGkClient, NULL, FALSE);
      /* Send a fresh Registration request and if that fails, go back to
         Gatekeeper discovery.
      */
      OOTRACEINFO1("Sending fresh RRQ - as unregistration request received\n");
      pGkClient->rrqRetries = 0;
      pGkClient->state = GkClientDiscovered;

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


   if(pGkClient->callbacks.onReceivedUnregistrationRequest)
      pGkClient->callbacks.onReceivedUnregistrationRequest(
                                      punregistrationRequest, gH323ep.aliases);
   return OO_OK;
}

int ooGkClientSendUnregistrationConfirm(ooGkClient *pGkClient, unsigned reqNo)
{
   int iRet = OO_OK;
   OOCTXT *pctxt = &pGkClient->msgCtxt;   
   H225RasMessage *pRasMsg=NULL;
   H225UnregistrationConfirm *pUCF=NULL;

   pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage));
   pUCF = (H225UnregistrationConfirm*)memAlloc(pctxt, 
                                           sizeof(H225UnregistrationConfirm));
   if(!pRasMsg || !pUCF)
   {
      OOTRACEERR1("Error: Memory allocation for UCF RAS message failed\n");
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   pRasMsg->t = T_H225RasMessage_unregistrationConfirm;
   pRasMsg->u.unregistrationConfirm = pUCF;
   memset(pUCF, 0, sizeof(H225UnregistrationConfirm));
   
   pUCF->requestSeqNum = reqNo;
   
   iRet = ooGkClientSendMsg(pGkClient, pRasMsg);
   if(iRet != OO_OK)
   {
      OOTRACEERR1("Error:Failed to send UnregistrationConfirm message\n");
      memReset(pctxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   OOTRACEINFO1("Unregistration Confirm message sent for \n");
   memReset(pctxt);

   return OO_OK;
}




int ooGkClientSendAdmissionRequest
   (ooGkClient *pGkClient, OOH323CallData *call, ASN1BOOL retransmit)
{
   int iRet = 0;
   unsigned int x;
   DListNode *pNode;
   ooGkClientTimerCb *cbData=NULL;
   H225RasMessage *pRasMsg=NULL;
   OOCTXT* pctxt;
   H225AdmissionRequest *pAdmReq=NULL;
   H225TransportAddress_ipAddress *pIpAddressLocal =NULL, *pIpAddressRemote=NULL;
   ooAliases *destAliases = NULL, *srcAliases=NULL;
   RasCallAdmissionInfo *pCallAdmInfo=NULL;
   pctxt = &pGkClient->msgCtxt;

   OOTRACEDBGA3("Building Admission Request for call (%s, %s)\n", 
                 call->callType, call->callToken);   
   pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage));
   if(!pRasMsg)
   {
      OOTRACEERR3("Error:Memory - ooGkClientSendAdmissionRequest - "
                  "pRasMsg(%s, %s)\n", call->callType, call->callToken);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   pRasMsg->t = T_H225RasMessage_admissionRequest;
   pAdmReq = (H225AdmissionRequest*) memAlloc(pctxt, 
                                                 sizeof(H225AdmissionRequest));
   if(!pAdmReq)
   {
      OOTRACEERR3("Error:Memory - ooGkClientSendAdmissionRequest - "
                  "pAdmReq(%s, %s)\n", call->callType, call->callToken);
      memReset(pctxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   memset(pAdmReq, 0, sizeof(H225AdmissionRequest));
   pRasMsg->u.admissionRequest = pAdmReq;
   
   /* Populate call signalling addresses */
   pIpAddressLocal = (H225TransportAddress_ipAddress*)memAlloc(pctxt, 
                                     sizeof(H225TransportAddress_ipAddress));
   if(!ooUtilsIsStrEmpty(call->remoteIP))
      pIpAddressRemote = (H225TransportAddress_ipAddress*)memAlloc(pctxt, 
                                      sizeof(H225TransportAddress_ipAddress));

   if(!pIpAddressLocal || (!ooUtilsIsStrEmpty(call->remoteIP) && (!pIpAddressRemote)))
   {
      OOTRACEERR1("Error:Failed to allocate memory for Call Signalling "
                  "Addresses of ARQ message\n");
      memReset(pctxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   ooSocketConvertIpToNwAddr(pGkClient->localRASIP, pIpAddressLocal->ip.data);

   pIpAddressLocal->ip.numocts = 4;
   pIpAddressLocal->port = gH323ep.listenPort;

   if(!ooUtilsIsStrEmpty(call->remoteIP))
   {
      ooSocketConvertIpToNwAddr(call->remoteIP, pIpAddressRemote->ip.data);
      pIpAddressRemote->ip.numocts = 4;
      pIpAddressRemote->port = call->remotePort;
   }

   if(!strcmp(call->callType, "incoming"))
   {
      pAdmReq->m.destCallSignalAddressPresent = TRUE;
      pAdmReq->destCallSignalAddress.t = T_H225TransportAddress_ipAddress;
      pAdmReq->destCallSignalAddress.u.ipAddress = pIpAddressLocal;
      if(!ooUtilsIsStrEmpty(call->remoteIP))
      {
         pAdmReq->m.srcCallSignalAddressPresent = TRUE;