mgcpmsgtran.c

内容正如其名

    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));

        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));

        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));

        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));

        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));

        FillQuarantineHandling(pDesData->pQuarantineHandling,
                         &pParam->u.ParamQuarantineHandling.QuarantineHandling);
      break;

      case MGCPParameter_ParamRequestedEvents:
        pDesData->pRequestedEvents
          = (REQUESTED_EVENTS*)calloc(1, sizeof(REQUESTED_EVENTS));

        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));

        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));

        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 MGCPParameter_ParamRestartDelay:
      case MGCPParameter_ParamRestartMethod:       
      case MGCPParameter_ParamSecondConnectionID:
      case MGCPParameter_ParamSecondEndpointID:
      case MGCPParameter_ParamSpecificEndpointID:
        DEBUG(LogMSG(LOG_ERROR, "\nForbidden parameter line in RQNT command!"););
        return FAIL;
      break;

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

  if (wManParamNum != MGCP_RQNT_CMD_MAN_NUMBER)
  {
    DEBUG(LogMSG(LOG_ERROR, "\nMissing mandatory parameter line in RQNT command!"););
    return FAIL;
  }

  return OK;
} 
/*******************************************************************************
 * Function          : FillAUEPCommand
 *
 * Description       : Fill the mgcp AUEP 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 AUEP command
 *
 * Return value      : Return OK if all the parameters are valid, otherwise
 *                     return FAIL.
 *
 * Comments          : 
 *
 * History           :
 *  2005/08/19       : Creation
 *
 * Date              : Aug 19 2005, Frank ZHANG
 ******************************************************************************/
LONG FillAUEPCommand(MGCP_AUEP_CMD *pDesData, WORD wNum, TMGCPParameter *pSrcData)                                
{
  int i = 0;
  TMGCPParameter *pParam = NULL;
  
  Assert(pDesData);

  /* Fill every parameter in the list */
  for(i = 0; i < wNum; i++)
  {
    pParam = pSrcData + i;
    
    switch (pParam->iType)
    {      
      /* Optional parameters */
      case MGCPParameter_ParamRequestedInfo:
        pDesData->pReqInfo = (REQUESTED_INFO*)calloc(1, sizeof(REQUESTED_INFO));

        if (pParam->u.ParamRequestedInfo.RequestedInfo.flag)
          FillReqestedInfo(pDesData->pReqInfo,
           (TRequestedInfo*)pParam->u.ParamRequestedInfo.RequestedInfo.pRuleData);
      break;
      
      case MGCPParameter_ParamResponseAck:
        pDesData->pRspAck = (RESPONSE_ACK*)calloc(1, sizeof(RESPONSE_ACK));

        if (pParam->u.ParamResponseAck.ResponseAck.flag)
          FillResponseAck(pDesData->pRspAck,
            (TResponseAck*)pParam->u.ParamResponseAck.ResponseAck.pRuleData);
      break;

      /* Forbidden parameters */
      case MGCPParameter_ParamBearerInformation:
      case MGCPParameter_ParamCallId:     
      case MGCPParameter_ParamCapabilities:
      case MGCPParameter_ParamConnectionId:
      case MGCPParameter_ParamConnectionMode:
      case MGCPParameter_ParamConnectionParameters:
      case MGCPParameter_ParamDetectEvents:
      case MGCPParameter_ParamDigitMap:
      case MGCPParameter_ParamEventStates:
      case MGCPParameter_ParamLocalConnectionOptions:
      case MGCPParameter_ParamMaxMGCPDatagram:
      case MGCPParameter_ParamNotifiedEntity:        
      case MGCPParameter_ParamObservedEvents:
      case MGCPParameter_ParamPackageList:
      case MGCPParameter_ParamQuarantineHandling:
      case MGCPParameter_ParamReasonCode:
      case MGCPParameter_ParamRequestedEvents:
      case MGCPParameter_ParamRequestIdentifier:
      case MGCPParameter_ParamRestartDelay:
      case MGCPParameter_ParamRestartMethod:        
      case MGCPParameter_ParamSecondConnectionID:
      case MGCPParameter_ParamSecondEndpointID:
      case MGCPParameter_ParamSignalRequests:
      case MGCPParameter_ParamSpecificEndpointID:
        DEBUG(LogMSG(LOG_ERROR, "\nForbidden parameter line in AUEP command!"););
        return FAIL;
      break;

      case MGCPParameter_ExtendedParameter:
        FillExperimentalParameters(&pDesData->ExperiParamList,
                                   &pParam->u.ExtendedParameter);
      break;

      default:
        Assert(0);
        return FAIL;
    }
  }

  return OK;
}
/*******************************************************************************
 * Function          : FillAUCXCommand
 *
 * Description       : Fill the mgcp AUCX 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 AUCX command
 *
 * Return value      : Return OK if all the parameters are valid, otherwise
 *                     return FAIL.
 *
 * Comments          : 
 *
 * History           :
 *  2005/08/19       : Creation
 *
 * Date              : Aug 19 2005, Frank ZHANG
 ******************************************************************************/
LONG FillAUCXCommand(MGCP_AUCX_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_ParamConnectionId:
        wManParamNum++;

        if (pParam->u.ParamConnectionId.ConnectionId.flag)
        {
          /* The connection ID in AUCX command must be only one */
          TConnectionId *pConnectionId
            = (TConnectionId*)pParam->u.ParamConnectionId.ConnectionId.pRuleData;
          Assert(pConnectionId->ConnectionIdValue.iNum == 1);

          StrClone(&pDesData->pcConnectionId,
                   *((char**)pConnectionId->ConnectionIdValue.pNode));          
        }
        
      break;

      case MGCPParameter_ParamRequestedInfo:
        wManParamNum++;
        pDesData->pReqInfo = (REQUESTED_INFO*)calloc(1, sizeof(REQUESTED_INFO));

        if (pParam->u.ParamRequestedInfo.RequestedInfo.flag)
          FillReqestedInfo(pDesData->pReqInfo,
           (TRequestedInfo*)pParam->u.ParamRequestedInfo.RequestedInfo.pRuleData);
      break;
      
      /* Optional parameters */      
      case MGCPParameter_ParamResponseAck:
        pDesData->pRspAck = (RESPONSE_ACK*)calloc(1, sizeof(RESPONSE_ACK));

        if (pParam->u.ParamResponseAck.ResponseAck.flag)
          FillResponseAck(pDesData->pRspAck,
              (TResponseAck*)pParam->u.ParamResponseAck.ResponseAck.pRuleData);
      break;

      /* Forbidden parameters */
      case MGCPParameter_ParamBearerInformation:
      case MGCPParameter_ParamCallId:     
      case MGCPParameter_ParamCapabilities:
      case MGCPParameter_ParamConnectionMode:
      case MGCPParameter_ParamConnectionParameters:
      case MGCPParameter_ParamDetectEvents:
      case MGCPParameter_ParamDigitMap:
      case MGCPParameter_ParamEventStates:
      case MGCPParameter_ParamLocalConnectionOptions:
      case MGCPParameter_ParamMaxMGCPDatagram:
      case MGCPParameter_ParamNotifiedEntity:        
      case MGCPParameter_ParamObservedEvents:
      case MGCPParameter_ParamPackageList:
      case MGCPParameter_ParamQuarantineHandling:
      case MGCPParameter_ParamReasonCode:
      case MGCPParameter_ParamRequestedEvents:
      case MGCPParameter_ParamRequestIdentifier:
      case MGCPParameter_ParamRestartDelay:
      case MGCPParameter_ParamRestartMethod:        
      case MGCPParameter_ParamSecondConnectionID: