mgcpmsgtran.c

来自「mgcp协议源代码和测试程序,还有一个编译器」· C语言 代码 · 共 1,868 行 · 第 1/5 页

                       &pParam->u.ParamReasonCode.ReasonCode);
      break;

      case MGCPParameter_ParamRequestedEvents:
        if (!bEncapRqnt)
        {
          pDesData->pEncapRqnf
            = (ENCAPSULATED_RQNT*)calloc(1, sizeof(ENCAPSULATED_RQNT));
			Assert(pDesData->pEncapRqnf);
		//	memset(pDesData->pEncapRqnf, 0, sizeof(ENCAPSULATED_RQNT));
          bEncapRqnt = TRUE;
        }

        pDesData->pEncapRqnf->pRequestedEvents
          = (REQUESTED_EVENTS*)calloc(1, sizeof(REQUESTED_EVENTS));
			Assert(pDesData->pEncapRqnf->pRequestedEvents);
		//	memset(pDesData->pEncapRqnf->pRequestedEvents, 0, sizeof(REQUESTED_EVENTS));
        if (pParam->u.ParamRequestedEvents.RequestedEvents.flag)
          FillRequestEvents(pDesData->pEncapRqnf->pRequestedEvents,
            (TRequestedEvents*)pParam->u.ParamRequestedEvents.RequestedEvents.pRuleData);
      break;

      case MGCPParameter_ParamRequestIdentifier:
        if (!bEncapRqnt)
        {
          pDesData->pEncapRqnf
            = (ENCAPSULATED_RQNT*)calloc(1, sizeof(ENCAPSULATED_RQNT));
			Assert(pDesData->pEncapRqnf);
		//	memset(pDesData->pEncapRqnf, 0, sizeof(ENCAPSULATED_RQNT));
          bEncapRqnt = TRUE;
        }

        if (pParam->u.ParamRequestIdentifier.RequestIdentifier.flag)
          StrClone(&pDesData->pEncapRqnf->pcRequestIdentifier,
           (char*)pParam->u.ParamRequestIdentifier.RequestIdentifier.pRuleData);
      break;
      
      case MGCPParameter_ParamResponseAck:
        pDesData->pRspAck = (RESPONSE_ACK*)calloc(1, sizeof(RESPONSE_ACK));
			Assert(pDesData->pRspAck);
		//	memset(pDesData->pRspAck, 0, sizeof(RESPONSE_ACK));
        if (pParam->u.ParamResponseAck.ResponseAck.flag)
          FillResponseAck(pDesData->pRspAck,
              (TResponseAck*)pParam->u.ParamResponseAck.ResponseAck.pRuleData);
      break;

      case MGCPParameter_ParamSignalRequests:
        if (!bEncapRqnt)
        {
          pDesData->pEncapRqnf
            = (ENCAPSULATED_RQNT*)calloc(1, sizeof(ENCAPSULATED_RQNT));
			Assert(pDesData->pEncapRqnf);
		//	memset(pDesData->pEncapRqnf, 0, sizeof(ENCAPSULATED_RQNT));
          bEncapRqnt = TRUE;
        }

        pDesData->pEncapRqnf->pSignalRequests
          = (SIGNAL_REQUESTS*)calloc(1, sizeof(SIGNAL_REQUESTS));
			Assert(pDesData->pEncapRqnf->pSignalRequests);
		//	memset(pDesData->pEncapRqnf->pSignalRequests, 0, sizeof(SIGNAL_REQUESTS));
        if (pParam->u.ParamSignalRequests.SignalRequests.flag)
          FillSignalRequests(pDesData->pEncapRqnf->pSignalRequests,
           (TSignalRequests*)pParam->u.ParamSignalRequests.SignalRequests.pRuleData);
      break;


      /* Forbidden parameters */
      case MGCPParameter_ParamCapabilities:
      case MGCPParameter_ParamConnectionMode:
      case MGCPParameter_ParamEventStates:
      case MGCPParameter_ParamLocalConnectionOptions:
      case MGCPParameter_ParamMaxMGCPDatagram:
      case MGCPParameter_ParamObservedEvents:
      case MGCPParameter_ParamPackageList:
      case MGCPParameter_ParamRequestedInfo:
      case MGCPParameter_ParamRestartDelay:
      case MGCPParameter_ParamRestartMethod:
      case MGCPParameter_ParamSecondConnectionID:
      case MGCPParameter_ParamSecondEndpointID:
      case MGCPParameter_ParamSpecificEndpointID:
        DEBUG(LogMSG(LOG_ERROR, "\nForbidden parameter line in DLCX command!"););
        return FAIL;
      break;

      case MGCPParameter_ExtendedParameter:
        FillExperimentalParameters(&pDesData->ExperiParamList,
                                   &pParam->u.ExtendedParameter);
      break;
      
      default:
        Assert(0);
        return FAIL;
    }
  }

  return OK;
}

/*******************************************************************************
 * Function          : FillAbnfDlcxCommand
 *
 * Description       : Fill the abnf mgcp DLCX command lines from the internal
 *                     DLCX command data
 *                     
 * Input parameters  : pSrcData - Pointer to the internal MGCP DLCX command data
 *
 * Output parameters : pDesData - Pointer to the filled abnf MGCP DLCX command
 *                                parameter lines
 *                     
 *
 * Return value      : None
 *
 * Comments          : 
 *
 * History           :
 *  2005/08/18       : Creation
 *
 * Date              : Aug 18 2005, Frank Zhang
 ******************************************************************************/
void FillAbnfDlcxCommand(TList *pParamList, MGCP_DLCX_CMD *pSrcData)                                
{
  TMGCPParameter *pParam = NULL;
  WORD wParamNum = 0;

  Assert(pParamList);
  Assert(pSrcData);
  
  /* Response ack */
  if (pSrcData->pRspAck != NULL)
  {
    pParam = AppendNewParameter(pParam, wParamNum);
    Assert(pParam);

    if (pParam != NULL)
    {
      FillAbnfParamResponseAck(pParam+wParamNum, pSrcData->pRspAck);
      wParamNum++;
    }
  }

  /* Call ID */
  if (pSrcData->pcCallId != NULL)
  {
    pParam = AppendNewParameter(pParam, wParamNum);
    Assert(pParam);
    
    if (pParam != NULL)
    {
      pParam[wParamNum].iType = MGCPParameter_ParamCallId;
      StrClone(&(pParam[wParamNum].u.ParamCallId.CallId), pSrcData->pcCallId);
      wParamNum++;
    }
  }
  
  /* Connection ID */
  if (pSrcData->pcConnectionId != NULL)
  {
    pParam = AppendNewParameter(pParam, wParamNum);
    Assert(pParam);

    if (pParam != NULL)
    { 
      FillAbnfParamConnectionID(pParam+wParamNum, pSrcData->pcConnectionId);     
      wParamNum++;
    }
  }
    
  /* Reason code */
  if (pSrcData->pReasonCode != NULL)
  {
    pParam = AppendNewParameter(pParam, wParamNum);
    Assert(pParam);

    if (pParam != NULL)
    {
      FillAbnfParamReasonCode(pParam+wParamNum, pSrcData->pReasonCode);
      wParamNum++;
    }
  }
  
  /* Connection parameters */
  if (pSrcData->pConnecParam != NULL)
  {
    pParam = AppendNewParameter(pParam, wParamNum);
    Assert(pParam);

    if (pParam != NULL)
    {
      FillAbnfParamConnectionParameters(pParam+wParamNum, pSrcData->pConnecParam);
      wParamNum++;
    }
  }
  
  /* Experimental parameters */
  if (pSrcData->ExperiParamList.wNum != 0)
  {
    int i;
    pParam = (TMGCPParameter*)realloc(pParam, 
             (wParamNum+pSrcData->ExperiParamList.wNum)*sizeof(TMGCPParameter));
    Assert(pParam);

    if (pParam != NULL)
    {
      for (i = 0; i < pSrcData->ExperiParamList.wNum; i++)
      {
        FillAbnfExperimentalParameter(pParam+wParamNum,
                                  pSrcData->ExperiParamList.pExperiParamList+i);          
        wParamNum++;
      }
    }
  }
  
  pParamList->iNum = wParamNum;
  pParamList->pNode = pParam;
}
/*******************************************************************************
 * Function          : FillRQNTCommand
 *
 * Description       : Fill the mgcp RQNT command according to the MGCP abnf
 *                     parameter lines
 *                     
 * Input parameters  : wNum - Number of the parameters in the abnf parameter
 *                            line
 *                     pSrcData - Pointer to the abnf parameter lines
 *
 * Output parameters : pDesData - Pointer to the filled MGCP RQNT command
 *
 * Return value      : Return OK if all the parameters are valid, otherwise
 *                     return FAIL.
 *
 * Comments          : 
 *
 * Date              : Aug 18 2005, Frank Zhang
 ******************************************************************************/
LONG FillRQNTCommand(MGCP_RQNT_CMD *pDesData, WORD wNum, TMGCPParameter *pSrcData)                                
{
	int i = 0;
	TMGCPParameter *pParam = NULL;

	/* Mandatory parameter number */
	WORD wManParamNum = 0;

	Assert(pDesData);

	/* Fill every parameter in the list */
	for(i = 0; i < wNum; i++)
	{
		pParam = pSrcData + i;
		switch (pParam->iType)
		{
			/* Mandatory parameters */
			case MGCPParameter_ParamRequestIdentifier:
			{
				wManParamNum++;
				if (pParam->u.ParamRequestIdentifier.RequestIdentifier.flag)
				{
					StrClone(&pDesData->pcRequestIdentifier,
							 (char*)pParam->u.ParamRequestIdentifier.RequestIdentifier.pRuleData);
				}
				break;
			}
			/* Optional parameters */
			case MGCPParameter_ParamBearerInformation:
			{
				pDesData->EncapEpcf.pBearerInfo = (BEARER_INFO*)calloc(1, sizeof(BEARER_INFO));
				Assert(pDesData->EncapEpcf.pBearerInfo);
				if (pParam->u.ParamBearerInformation.BearerInformation.flag)
				{
					FillBearerInfo(pDesData->EncapEpcf.pBearerInfo,
								   (TBearerInformation*)pParam->u.ParamBearerInformation.BearerInformation.pRuleData);
				}
				break;
			}
			case MGCPParameter_ParamDetectEvents:
			{
				pDesData->pDetectEvents = (DETECT_EVENTS*)calloc(1, sizeof(DETECT_EVENTS));
				Assert(pDesData->pDetectEvents);
				
				if (pParam->u.ParamDetectEvents.DetectEvents.flag)
				{
					FillDetectEvents(pDesData->pDetectEvents,
									 (TSignalRequests*)pParam->u.ParamDetectEvents.DetectEvents.pRuleData);
				}
				break;
			}
			case MGCPParameter_ParamDigitMap:
			{
				pDesData->pDigitMap= (DIGIT_MAP*)calloc(1, sizeof(DIGIT_MAP));
				Assert(pDesData->pDigitMap);
				
				if (pParam->u.ParamDigitMap.DigitMap.flag)
				{
					FillDigitMap(pDesData->pDigitMap,
								 (TDigitMap*)pParam->u.ParamDigitMap.DigitMap.pRuleData);
				}
				break;
			}
			case MGCPParameter_ParamNotifiedEntity:
			{
				pDesData->pNotifiedEntity
					= (NOTIFIED_ENTITY*)calloc(1, sizeof(NOTIFIED_ENTITY));
				Assert(pDesData->pNotifiedEntity);
				
				if (pParam->u.ParamNotifiedEntity.NotifiedEntity.flag)
				{
					FillNotifiedEntity(pDesData->pNotifiedEntity,
									   (TNotifiedEntity*)pParam->u.ParamNotifiedEntity.NotifiedEntity.pRuleData);
				}
				break;
			}
			case MGCPParameter_ParamQuarantineHandling:
			{
				pDesData->pQuarantineHandling
					= (QUARANTINE_HANDLING*)calloc(1, sizeof(QUARANTINE_HANDLING));
				Assert(pDesData->pQuarantineHandling);
				
				FillQuarantineHandling(pDesData->pQuarantineHandling,
									   &pParam->u.ParamQuarantineHandling.QuarantineHandling);
				break;
			}
			case MGCPParameter_ParamRequestedEvents:
			{
				pDesData->pRequestedEvents
				= (REQUESTED_EVENTS*)calloc(1, sizeof(REQUESTED_EVENTS));
				Assert(pDesData->pRequestedEvents);
				
				if (pParam->u.ParamRequestedEvents.RequestedEvents.flag)
				{
					FillRequestEvents(pDesData->pRequestedEvents,
									  (TRequestedEvents*)pParam->u.ParamRequestedEvents.RequestedEvents.pRuleData);
				}
				break;
			}
			case MGCPParameter_ParamResponseAck:
			{
				pDesData->pRspAck = (RESPONSE_ACK*)calloc(1, sizeof(RESPONSE_ACK));
				Assert(pDesData->pRspAck);
				
				if (pParam->u.ParamResponseAck.ResponseAck.flag)
				{
					FillResponseAck(pDesData->pRspAck,
									(TResponseAck*)pParam->u.ParamResponseAck.ResponseAck.pRuleData);
				}
				break;
			}
			case MGCPParameter_ParamSignalRequests:
			{
				pDesData->pSignalRequests
					= (SIGNAL_REQUESTS*)calloc(1, sizeof(SIGNAL_REQUESTS));
				Assert(pDesData->pSignalRequests);
				
				if (pParam->u.ParamSignalRequests.SignalRequests.flag)
				{
					FillSignalRequests(pDesData->pSignalRequests,
									   (TSignalRequests*)pParam->u.ParamSignalRequests.SignalRequests.pRuleData);
				}
				break;
			}
			/* Forbidden parameters */
			case MGCPParameter_ParamCallId:     
			case MGCPParameter_ParamCapabilities:
			case MGCPParameter_ParamConnectionId:
			case MGCPParameter_ParamConnectionMode:
			case MGCPParameter_ParamConnectionParameters:
			case MGCPParameter_ParamEventStates:
			case MGCPParameter_ParamLocalConnectionOptions:
			case MGCPParameter_ParamMaxMGCPDatagram:
			case MGCPParameter_ParamObservedEvents:
			case MGCPParameter_ParamPackageList:
			case MGCPParameter_ParamReasonCode:
			case MGCPParameter_ParamRequestedInfo:
			case MGCPParame