oogkclient.c

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

         return OO_OK;
      }
   }

   if(ASN_OK != setPERBuffer (pctxt, recvBuf, recvLen, TRUE ) )
   {
      OOTRACEERR1("Error:Failed to set PER buffer for RAS message decoding\n");
      memReset(pctxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }      
   pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage));
   if(!pRasMsg)
   {
      OOTRACEERR1("Error: Failed to allocate memory for RAS message\n");
      memReset(pctxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
#ifndef _COMPACT
   initializePrintHandler(&printHandler, "Received RAS Message");
   /* Add event handler to list */
   setEventHandler (pctxt, &printHandler);
#endif
   if(ASN_OK == asn1PD_H225RasMessage(pctxt, pRasMsg))
   {
#ifndef _COMPACT
      finishPrint();
      removeEventHandler(pctxt);
#endif
      iRet=ooGkClientHandleRASMessage( pGkClient, pRasMsg );
      if(iRet != OO_OK)
      {
         OOTRACEERR1("Error: Failed to handle received RAS message\n");
	 //pGkClient->state = GkClientFailed;
      }
      memReset(pctxt);
   }
   else{
      OOTRACEERR1("ERROR:Failed to decode received RAS message- ignoring"
                  "received message.\n");
#ifndef _COMPACT
      removeEventHandler(pctxt);
#endif
      memReset(pctxt);
      return OO_FAILED;
   }
   return iRet;
}




/**
 * Manage incoming RAS message.
 */

int ooGkClientHandleRASMessage(ooGkClient *pGkClient, H225RasMessage *pRasMsg)
{
   int iRet = OO_OK;   
   switch( pRasMsg->t)
   {
   case T_H225RasMessage_gatekeeperConfirm:
      OOTRACEINFO1("Gatekeeper Confirmed (GCF) message received.\n");
      iRet = ooGkClientHandleGatekeeperConfirm(pGkClient, 
                                          pRasMsg->u.gatekeeperConfirm);
      break;
   case T_H225RasMessage_gatekeeperReject: 
      OOTRACEINFO1("Gatekeeper Reject (GRJ) message received\n");
      iRet = ooGkClientHandleGatekeeperReject(pGkClient, 
                                              pRasMsg->u.gatekeeperReject);
      break;
   case T_H225RasMessage_registrationConfirm:   
      OOTRACEINFO1("Registration Confirm (RCF) message received\n");
      iRet = ooGkClientHandleRegistrationConfirm(pGkClient,  
                                              pRasMsg->u.registrationConfirm );
      break;
   case T_H225RasMessage_registrationReject:
      OOTRACEINFO1("Registration Reject (RRJ) message received.\n");
      iRet = ooGkClientHandleRegistrationReject(pGkClient, 
                                                pRasMsg->u.registrationReject);
      break;
   case T_H225RasMessage_infoRequest:  
      //ooRasSendIRR( psRasMsg->sMessage.u.infoRequest->requestSeqNum );
      break;
   case T_H225RasMessage_admissionConfirm:
      OOTRACEINFO1("Admission Confirm (ACF) message received\n");
      iRet = ooGkClientHandleAdmissionConfirm(pGkClient, 
                                              pRasMsg->u.admissionConfirm);
      break;
   case T_H225RasMessage_unregistrationRequest:
      OOTRACEINFO1("UnRegistration Request (URQ) message received.\n");
      iRet = ooGkClientHandleUnregistrationRequest(pGkClient, 
                                            pRasMsg->u.unregistrationRequest);
      break;
   case T_H225RasMessage_unregistrationConfirm:
      OOTRACEINFO1("UnRegistration Confirm (UCF) message received.\n");
      break;
   case T_H225RasMessage_unregistrationReject:
      OOTRACEINFO1("UnRegistration Reject (URJ) message received.\n");
      break;
   case T_H225RasMessage_admissionReject:
      OOTRACEINFO1("Admission Reject (ARJ) message received.\n");
      iRet = ooGkClientHandleAdmissionReject(pGkClient, 
                                                   pRasMsg->u.admissionReject);
      break;
   case T_H225RasMessage_disengageConfirm:
      iRet = ooGkClientHandleDisengageConfirm(pGkClient, 
                                              pRasMsg->u.disengageConfirm);
      break;
   case T_H225RasMessage_disengageReject:
   case T_H225RasMessage_bandwidthConfirm:
   case T_H225RasMessage_bandwidthReject:
   case T_H225RasMessage_locationRequest:
   case T_H225RasMessage_locationConfirm:
   case T_H225RasMessage_locationReject:
   case T_H225RasMessage_infoRequestResponse:
   case T_H225RasMessage_nonStandardMessage:
   case T_H225RasMessage_unknownMessageResponse:
   case T_H225RasMessage_requestInProgress:
   case T_H225RasMessage_resourcesAvailableIndicate:
   case T_H225RasMessage_resourcesAvailableConfirm:
   case T_H225RasMessage_infoRequestAck:
   case T_H225RasMessage_infoRequestNak:
   case T_H225RasMessage_serviceControlIndication:
   case T_H225RasMessage_serviceControlResponse:
   case T_H225RasMessage_admissionConfirmSequence:
   default:
      /* Unhandled RAS message */
      iRet= OO_OK;
   }

   return iRet;
}

#ifndef _COMPACT
void ooGkClientPrintMessage
   (ooGkClient *pGkClient, ASN1OCTET *msg, ASN1UINT len)
{
   OOCTXT ctxt;
   H225RasMessage rasMsg;
   int ret; 

   initContext(&ctxt);
   setPERBuffer(&ctxt, msg, len, TRUE);
   initializePrintHandler(&printHandler, "Sending RAS Message");
   setEventHandler(&ctxt, &printHandler);

   ret = asn1PD_H225RasMessage(&ctxt, &rasMsg);
   if(ret != ASN_OK)
   {
      OOTRACEERR1("Error: Failed to decode RAS message\n");
   }
   finishPrint();
   freeContext(&ctxt);
}
#endif
/**
 * Encode and send RAS message.
 */

int ooGkClientSendMsg(ooGkClient *pGkClient, H225RasMessage *pRasMsg)
{
   ASN1OCTET msgBuf[MAXMSGLEN];
   ASN1OCTET *msgPtr=NULL;
   int  iLen;
   OOCTXT *pctxt = &pGkClient->msgCtxt;

   setPERBuffer( pctxt, msgBuf, MAXMSGLEN, TRUE );
   if ( ASN_OK == asn1PE_H225RasMessage(pctxt, pRasMsg) )
   {
      OOTRACEDBGC1("Ras message encoding - successful\n");
   }
   else {
      OOTRACEERR1("Error: RAS message encoding failed\n");
      return OO_FAILED;
   }

   msgPtr = encodeGetMsgPtr( pctxt, &iLen );
   /* If gatekeeper specified or have been discovered */
   if(pGkClient->gkMode == RasUseSpecificGatekeeper || 
      pGkClient->discoveryComplete)
   {
      if(ASN_OK != ooSocketSendTo( pGkClient->rasSocket, msgPtr, iLen, 
                                   pGkClient->gkRasIP, pGkClient->gkRasPort))
      {
         OOTRACEERR1("Error sending RAS message\n");
         return OO_FAILED;
      }
   }else if(pGkClient->gkMode == RasDiscoverGatekeeper && 
            !pGkClient->discoveryComplete)
   { 
      if(ASN_OK != ooSocketSendTo(pGkClient->rasSocket, msgPtr, iLen, 
                                       MULTICAST_GKADDRESS, MULTICAST_GKPORT))
      {
         OOTRACEERR1("Error sending multicast RAS message\n" );
         return OO_FAILED;
      }
   }else {/* should never go here */ 
      OOTRACEERR1("Error: GkClient in invalid state.\n");
      return OO_FAILED;
   }
#ifndef _COMPACT
   ooGkClientPrintMessage(pGkClient, msgPtr, iLen);
#endif
   return OO_OK;
}



int ooGkClientSendGRQ(ooGkClient *pGkClient)
{
   int iRet;
   H225RasMessage *pRasMsg=NULL;
   H225GatekeeperRequest *pGkReq=NULL;
   H225TransportAddress_ipAddress *pRasAddress;
   OOCTXT *pctxt = &pGkClient->msgCtxt;
   ooGkClientTimerCb *cbData=NULL;

   

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

   pGkReq = (H225GatekeeperRequest*)memAlloc(pctxt, 
                                                sizeof(H225GatekeeperRequest));
   if(!pGkReq)
   {
      OOTRACEERR1("Error:Memory allocation for GRQ failed\n");
      memReset(pctxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   memset(pGkReq, 0, sizeof(H225GatekeeperRequest));
   pRasMsg->t = T_H225RasMessage_gatekeeperRequest;
   pRasMsg->u.gatekeeperRequest = pGkReq;

   /* Populate message structure */
   pGkReq->requestSeqNum = pGkClient->requestSeqNum++;
   if ( !pGkReq->requestSeqNum )
      pGkReq->requestSeqNum = pGkClient->requestSeqNum++;

   pGkReq->protocolIdentifier = gProtocolID;
   pGkReq->m.nonStandardDataPresent=0;
   pGkReq->rasAddress.t=T_H225TransportAddress_ipAddress; /* IPv4 address */
   pRasAddress = (H225TransportAddress_ipAddress*)memAlloc(pctxt, 
                                      sizeof(H225TransportAddress_ipAddress));
   if(!pRasAddress)
   {
      OOTRACEERR1("Error: Memory allocation for Ras Address of GRQ message "
                  "failed\n");
      memReset(&pGkClient->msgCtxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }

 
   ooSocketConvertIpToNwAddr(pGkClient->localRASIP, pRasAddress->ip.data);

   pRasAddress->ip.numocts = 4;
   pRasAddress->port = pGkClient->localRASPort;
   pGkReq->rasAddress.u.ipAddress = pRasAddress;

   /* Pose as gateway or terminal as per config */
   if(gH323ep.isGateway)
      pGkReq->endpointType.m.gatewayPresent = TRUE;
   else
      pGkReq->endpointType.m.terminalPresent = TRUE;

   pGkReq->endpointType.m.nonStandardDataPresent=0;
   pGkReq->endpointType.m.vendorPresent=1;

   ooGkClientFillVendor(pGkClient, &pGkReq->endpointType.vendor);


   pGkReq->m.endpointAliasPresent=TRUE;
   if(OO_OK != ooPopulateAliasList(&pGkClient->msgCtxt, gH323ep.aliases, 
                                      &pGkReq->endpointAlias))
   {
      OOTRACEERR1("Error Failed to fill alias information for GRQ message\n");
      memReset(&pGkClient->msgCtxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   iRet = ooGkClientSendMsg(pGkClient, pRasMsg);
   if(iRet != OO_OK)
   {
      OOTRACEERR1("Error: Failed to send GRQ message\n");
      memReset(&pGkClient->msgCtxt);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   OOTRACEINFO1("Sent GRQ message\n");
   cbData = (ooGkClientTimerCb*) memAlloc
                               (&pGkClient->ctxt, sizeof(ooGkClientTimerCb));
   if(!cbData)
   {
      OOTRACEERR1("Error:Failed to allocate memory to GRQ timer callback\n");
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   cbData->timerType = OO_GRQ_TIMER;
   cbData->pGkClient = pGkClient;
   if(!ooTimerCreate(&pGkClient->ctxt, &pGkClient->timerList, 
                     &ooGkClientGRQTimerExpired, pGkClient->grqTimeout, 
                     cbData, FALSE))      
   {
      OOTRACEERR1("Error:Unable to create GRQ timer.\n ");
      memFreePtr(&pGkClient->ctxt, cbData);
      pGkClient->state = GkClientFailed;
      return OO_FAILED;
   }
   return OO_OK;
}

int ooGkClientHandleGatekeeperReject
   (ooGkClient *pGkClient, H225GatekeeperReject *pGatekeeperReject)
{
   unsigned int x=0;
   DListNode *pNode = NULL;
   OOTimer *pTimer = NULL;

   if(pGkClient->gkMode == RasUseSpecificGatekeeper)
   {
      /* 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;
         }
      }
 
      pGkClient->state = GkClientGkErr;
      switch(pGatekeeperReject->rejectReason.t)
      {
      case T_H225GatekeeperRejectReason_resourceUnavailable:
         OOTRACEERR1("Error: Gatekeeper Reject - Resource Unavailable\n");
         break;
      case T_H225GatekeeperRejectReason_terminalExcluded:
         OOTRACEERR1("Error: Gatekeeper Reject - Terminal Excluded\n");
         break;
      case T_H225GatekeeperRejectReason_invalidRevision:
         OOTRACEERR1("Error: Gatekeeper Reject - Invalid Revision\n");
         break;
      case T_H225GatekeeperRejectReason_undefinedReason:
         OOTRACEERR1("Error: Gatekeeper Reject - Undefined Reason\n");
         break;
      case T_H225GatekeeperRejectReason_securityDenial:
         OOTRACEERR1("Error: Gatekeeper Reject - Security Denial\n");
         break;
      case T_H225GatekeeperRejectReason_genericDataReason:
         OOTRACEERR1("Error: Gatekeeper Reject - Generic Data Reason\n");
         break;
      case T_H225GatekeeperRejectReason_neededFeatureNotSupported:
         OOTRACEERR1("Error: Gatekeeper Reject - Needed Feature Not "
                     "Supported\n");
         break;
      case T_H225GatekeeperRejectReason_securityError:
         OOTRACEERR1("Error:Gatekeeper Reject - Security Error\n");
         break;
      default:
         OOTRACEERR1("Error: Gatekeeper Reject - Invalid reason\n");
      }
      return OO_OK;
   }
   OOTRACEDBGB1("Gatekeeper Reject response received for multicast GRQ "
                "request\n");
   return OO_OK;