mgcpmsgtran.c

内容正如其名

        pDesData->pEncapRqnf->pQuarantineHandling
          = (QUARANTINE_HANDLING*)calloc(1, sizeof(QUARANTINE_HANDLING));

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

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

        pDesData->pEncapRqnf->pRequestedEvents
          = (REQUESTED_EVENTS*)calloc(1, 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));
          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));

        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));
          bEncapRqnt = TRUE;
        }

        pDesData->pEncapRqnf->pSignalRequests
          = (SIGNAL_REQUESTS*)calloc(1, 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_ParamConnectionParameters:
      case MGCPParameter_ParamEventStates:
      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 MDCX command!"););
        return FAIL;
      break;

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

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

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

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

        pDesData->pEncapEpcf->pBearerInfo
          = (BEARER_INFO*)calloc(1, sizeof(BEARER_INFO));

        if (pParam->u.ParamBearerInformation.BearerInformation.flag)
          FillBearerInfo(pDesData->pEncapEpcf->pBearerInfo,
           (TBearerInformation*)pParam->u.ParamBearerInformation.BearerInformation.pRuleData);
      break;
      
      case MGCPParameter_ParamCallId:
        StrClone(&pDesData->pcCallId, pParam->u.ParamCallId.CallId);
      break;
      
      case MGCPParameter_ParamConnectionId:
        if (pParam->u.ParamConnectionId.ConnectionId.flag)
        {
          /* The connection ID in MDCX 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_ParamConnectionParameters:
        pDesData->pConnecParam
          = (CONNECTION_PARAMETERS*)calloc(1, sizeof(CONNECTION_PARAMETERS));

        if (pParam->u.ParamConnectionParameters.ConnectionParameters.flag)
          FillConnectionParameters(pDesData->pConnecParam,
           (TConnectionParameters*)pParam->u.ParamConnectionParameters.ConnectionParameters.pRuleData);
      break;

      case MGCPParameter_ParamDetectEvents:
        if (!bEncapRqnt)
        {
          pDesData->pEncapRqnf
            = (ENCAPSULATED_RQNT*)calloc(1, sizeof(ENCAPSULATED_RQNT));
          bEncapRqnt = TRUE;
        }

        pDesData->pEncapRqnf->pDetectEvents
          = (DETECT_EVENTS*)calloc(1, sizeof(DETECT_EVENTS));

        if (pParam->u.ParamDetectEvents.DetectEvents.flag)
          FillDetectEvents(pDesData->pEncapRqnf->pDetectEvents,
           (TSignalRequests*)pParam->u.ParamDetectEvents.DetectEvents.pRuleData);
      break;
      
      case MGCPParameter_ParamDigitMap:
        if (!bEncapRqnt)
        {
          pDesData->pEncapRqnf
            = (ENCAPSULATED_RQNT*)calloc(1, sizeof(ENCAPSULATED_RQNT));
          bEncapRqnt = TRUE;
        }

        pDesData->pEncapRqnf->pDigitMap = (DIGIT_MAP*)calloc(1, sizeof(DIGIT_MAP));

        if (pParam->u.ParamDigitMap.DigitMap.flag)
          FillDigitMap(pDesData->pEncapRqnf->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:
        if (!bEncapRqnt)
        {
          pDesData->pEncapRqnf
            = (ENCAPSULATED_RQNT*)calloc(1, sizeof(ENCAPSULATED_RQNT));
          bEncapRqnt = TRUE;
        }

        pDesData->pEncapRqnf->pQuarantineHandling
          = (QUARANTINE_HANDLING*)calloc(1, sizeof(QUARANTINE_HANDLING));

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

      case MGCPParameter_ParamReasonCode:
        pDesData->pReasonCode = (REASON_CODE*)calloc(1, sizeof(REASON_CODE));
        FillReasonCode(pDesData->pReasonCode,
                       &pParam->u.ParamReasonCode.ReasonCode);
      break;

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

        pDesData->pEncapRqnf->pRequestedEvents
          = (REQUESTED_EVENTS*)calloc(1, 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));
          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));
        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));
          bEncapRqnt = TRUE;
        }

        pDesData->pEncapRqnf->pSignalRequests
          = (SIGNAL_REQUESTS*)calloc(1, 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);