mgcpmsgtran.c

内容正如其名

    if (pDesParam != NULL)
    {
      FillAbnfParamConnectionIDS(pDesParam+wNum, pSrcData->pConnectionIds);     
      wNum++;
    }
  }
  
  /* Notified Entity */
  if (pSrcData->pNotifiedEntity != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamNotifiedEntity(pDesParam+wNum, pSrcData->pNotifiedEntity);
      wNum++;
    }
  }

  /* Requested ID */
  if (pSrcData->pcRequestIdentifier != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamRequestedID(pDesParam+wNum, pSrcData->pcRequestIdentifier);  
      wNum++;
    }
  }

  /* Local Connection Options */
  if (pSrcData->pLocalConnectionOptions != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamLocalConnectionOpts(pDesParam+wNum, pSrcData->pLocalConnectionOptions);  
      wNum++;
    }
  }

  /* Connection Mode */
  if (pSrcData->pConnectionMode != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamConnectionMode(pDesParam+wNum,pSrcData->pConnectionMode );
      wNum++;
    }
  }

  /* Requested Events */
  if (pSrcData->pRequestedEvents != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamRequestEvents(pDesParam+wNum, pSrcData->pRequestedEvents);
      wNum++;
    }
  }

  /* Signal Requests */
  if (pSrcData->pSignalRequests != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamSignalRequests(pDesParam+wNum, pSrcData->pSignalRequests);
      wNum++;
    }
  }

  /* Digit Map */
  if (pSrcData->pDigitMap != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamDigitMap(pDesParam+wNum, pSrcData->pDigitMap);
      wNum++;
    }
  }

  /* Observed Events */
  if (pSrcData->pObservedEvents != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamObservedEvents(pDesParam+wNum, pSrcData->pObservedEvents);
      wNum++;
    }
  }

  /* Connection Parameters */
  if (pSrcData->pConnectionParameters != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamConnectionParameters(pDesParam+wNum,
                                        pSrcData->pConnectionParameters);
      wNum++;
    }
  }

  /* Reason code */
  if (pSrcData->pReasonCode != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamReasonCode(pDesParam+wNum, pSrcData->pReasonCode);
      wNum++;
    }
  }
  
  /* Specific Endpoint ID */
  if (pSrcData->pSpecificEndpointID != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      pDesParam[wNum].iType = MGCPParameter_ParamSpecificEndpointID;
      pDesParam[wNum].u.ParamSpecificEndpointID.SpecificEndpointID.flag = 1;
      pDesParam[wNum].u.ParamSpecificEndpointID.SpecificEndpointID.pRuleData
        = calloc(1, sizeof(TEndpointName));
      FillAbnfEndpointName((TEndpointName*)pDesParam[wNum].u.ParamSpecificEndpointID.SpecificEndpointID.pRuleData,
                           pSrcData->pSpecificEndpointID);
  
      wNum++;
    }
  }

  /* Second Connection ID */
  if (pSrcData->pcSecondConnectionID != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      pDesParam[wNum].iType = MGCPParameter_ParamSecondEndpointID;
      pDesParam[wNum].u.ParamSecondConnectionID.SecondConnectionID.ConnectionIdValue.iNum = 1;
      pDesParam[wNum].u.ParamSecondConnectionID.SecondConnectionID.ConnectionIdValue.pNode
        = calloc(1, sizeof(char**));
      
      StrClone((char**)pDesParam[wNum].u.ParamSecondConnectionID.SecondConnectionID.ConnectionIdValue.pNode,
               pSrcData->pcSecondConnectionID);
  
      wNum++;
    }
  }

  /* Requested Info */
  if (pSrcData->pRequestedInfo != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamReqestedInfo(pDesParam+wNum, pSrcData->pRequestedInfo);
      wNum++;
    }
  }

  /* Quarantine Handling */
  if (pSrcData->pQuarantineHandling != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamQuarantineHandling(pDesParam+wNum, pSrcData->pQuarantineHandling);
      wNum++;
    }
  }
  
  /* Detec Events */
  if (pSrcData->pDetectEvents != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamDetectEvents(pDesParam+wNum, pSrcData->pDetectEvents);
      wNum++;
    }
  }  

  /* Restart Method */
  if (pSrcData->pRestartMethod != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamRestartMethod(pDesParam+wNum, pSrcData->pRestartMethod);
      wNum++;
    }
  }
  
  /* Restart Delay */
  if (pSrcData->pRestartDelay != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      pDesParam[wNum].iType = MGCPParameter_ParamRestartDelay;
      StrClone(&pDesParam[wNum].u.ParamRestartDelay.RestartDelay,
               Ultoa(*pSrcData->pRestartDelay));
  
      wNum++;
    }
  }
  
  /* Capabilities */
  if (pSrcData->pCapabilities != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamCapabilities(pDesParam+wNum, pSrcData->pCapabilities);
  
      wNum++;
    }
  }
  
  /* Event States */
  if (pSrcData->pEventStates != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamEventStates(pDesParam+wNum, pSrcData->pEventStates);
      wNum++;
    }
  }
  
  /* Supported Packages */
  if (pSrcData->pPackageList != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      FillAbnfParamPackageList(pDesParam+wNum, pSrcData->pPackageList);
      wNum++;
    }
  }
  
  /* Supported Maximum Datagram */
  if (pSrcData->pMaxMGCPDatagram != NULL)
  {
    pDesParam = AppendNewParameter(pDesParam, wNum);
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      pDesParam[wNum].iType = MGCPParameter_ParamMaxMGCPDatagram;
      StrClone(&pDesParam[wNum].u.ParamMaxMGCPDatagram.MaxMGCPDatagram,
               Ultoa(*pSrcData->pMaxMGCPDatagram));
      wNum++;
    }
  }  

  /* Experimental parameters */
  if (pSrcData->ExperiParamList.wNum > 0)
  {
    int i;
    pDesParam = (TMGCPParameter*)realloc(pDesParam,
                  (wNum+pSrcData->ExperiParamList.wNum)*sizeof(TMGCPParameter));
    Assert(pDesParam);

    if (pDesParam != NULL)
    {
      for (i = 0; i < pSrcData->ExperiParamList.wNum; i++)
      {
        FillAbnfExperimentalParameter(pDesParam+wNum,
                                  pSrcData->ExperiParamList.pExperiParamList+i);
        wNum++;
      }
    }
  }

  pDesData->iNum = wNum;
  pDesData->pNode = pDesParam;  
}
/*******************************************************************************
 * Function          : FillEPCFCommand
 *
 * Description       : Fill the mgcp EPCF 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 EPCF command
 *
 * Return value      : Return OK if all the parameters are valid, otherwise
 *                     return FAIL.
 *
 * Comments          : 
 *
 * History           :
 *  2005/08/17       : Creation
 *
 * Date              : Aug 17 2005, Frank ZHANG
 ******************************************************************************/
LONG FillEPCFCommand(MGCP_EPCF_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 */
      /* Response ack */
      case MGCPParameter_ParamResponseAck:
        pDesData->pRspAck = (RESPONSE_ACK*)calloc(1, sizeof(RESPONSE_ACK));

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

      /* Bearer info */
      case MGCPParameter_ParamBearerInformation:
        pDesData->pBearerInfo = (BEARER_INFO*)calloc(1, sizeof(BEARER_INFO));

        if (pParam->u.ParamBearerInformation.BearerInformation.flag)
          FillBearerInfo(pDesData->pBearerInfo,
           (TBearerInformation*)pParam->u.ParamBearerInformation.BearerInformation.pRuleData);
      break;
  
      /* Forbidden parameters */
      case MGCPParameter_ParamCallId:
      case MGCPParameter_ParamConnectionId:
      case MGCPParameter_ParamNotifiedEntity:
      case MGCPParameter_ParamRequestIdentifier:
      case MGCPParameter_ParamLocalConnectionOptions:
      case MGCPParameter_ParamConnectionMode:
      case MGCPParameter_ParamRequestedEvents:
      case MGCPParameter_ParamSignalRequests:
      case MGCPParameter_ParamDigitMap:
      case MGCPParameter_ParamObservedEvents:
      case MGCPParameter_ParamConnectionParameters:
      case MGCPParameter_ParamReasonCode:
      case MGCPParameter_ParamSpecificEndpointID:
      case MGCPParameter_ParamSecondEndpointID: