mgcpdef.c

mgcp协议源代码和测试程序,还有一个编译器

    {
      while (pData->wNum-- > 0)
        free(pData->ppcAlgorithmList[pData->wNum]);
  
      pData->wNum = 0;
      free(pData->ppcAlgorithmList);
      pData->ppcAlgorithmList = NULL;
    }
  }
}
/*******************************************************************************
 * Function          : ClearEncriptionData
 *
 * Description       : Clear the Encription Data
 *                     
 * Input parameters  : pData - Pointer to the data to be cleared
 *
 * Output parameters : 
 *
 * Return value      : 
 *
 * Comments          : 
 *
 * History           :
 *  2005/07/15       : Creation
 *
 * Date              : July 15 2005, Frank Zhang
 ******************************************************************************/
void ClearEncriptionData(ENCRYPTION_DATA *pData)
{
  if (pData != NULL)
  {
    if (pData->pEncryKey != NULL)
    {
      free(pData->pEncryKey);
      pData->pEncryKey = NULL;
    }

    pData->eType = 0;
  }
}
/*******************************************************************************
 * Function          : ClearLocalOptionExtension
 *
 * Description       : Clear the Local Option Extension
 *                     
 * Input parameters  : pData - Pointer to the data to be cleared
 *
 * Output parameters : 
 *
 * Return value      : 
 *
 * Comments          : 
 *
 * History           :
 *  2005/07/15       : Creation
 *
 * Date              : July 15 2005, Frank Zhang
 ******************************************************************************/
void ClearLocalOptionExtension(LOCAL_OPTION_EXTENSION *pData)
{
  if (pData != NULL)
  {
    if (pData->pcPackageName != NULL)
    {
      free(pData->pcPackageName);
      pData->pcPackageName = NULL;
    }
    
    if (pData->pcExtensionName != NULL)
    {
      free(pData->pcExtensionName);
      pData->pcExtensionName = NULL;
    }
    
    if (pData->pcExtensionValue != NULL)
    {
      free(pData->pcExtensionValue);
      pData->pcExtensionValue = NULL;
    }

    pData->eType = 0;
  }
}
/*******************************************************************************
 * Function          : ClearLocalConnectionOptions
 *
 * Description       : Clear the Local Connection Options
 *                     
 * Input parameters  : pData - Pointer to the data to be cleared
 *
 * Output parameters : 
 *
 * Return value      : 
 *
 * Comments          : 
 *
 * History           :
 *  2005/07/15       : Creation
 *
 * Date              : July 15 2005, Frank Zhang
 ******************************************************************************/
void ClearLocalConnectionOptions(LOCAL_CONNEC_OPTS *pData)
{
  if (pData != NULL)
  {
    pData->wOptNum = 0;
    
    if (pData->pPacketizationPeriod != NULL)
    {
      free(pData->pPacketizationPeriod);
      pData->pPacketizationPeriod = NULL;
    }
    
    if (pData->pCompressAlgo != NULL)
    {
      ClearCompressionAlgorithm(pData->pCompressAlgo);
      free(pData->pCompressAlgo);
      pData->pCompressAlgo = NULL;
    }

    if (pData->pBandwidthValue != NULL)
    {
      free(pData->pBandwidthValue);
      pData->pBandwidthValue = NULL;
    }
    
    if (pData->psGainControl != NULL)
    {
      free(pData->psGainControl);
      pData->psGainControl = NULL;
    }
    
    if (pData->peEchocancellation != NULL)
    {
      free(pData->peEchocancellation);
      pData->peEchocancellation = NULL;
    }
    
    if (pData->peSilenceSuppression != NULL)
    {
      free(pData->peSilenceSuppression);
      pData->peSilenceSuppression = NULL;
    }
    
    if (pData->pucTypeOfService != NULL)
    {
      free(pData->pucTypeOfService);
      pData->pucTypeOfService = NULL;
    }
    
    if (pData->peResourceReservation != NULL)
    {
      free(pData->peResourceReservation);
      pData->peResourceReservation = NULL;
    }
    
    if (pData->peTypeOfNetwork != NULL)
    {
      free(pData->peTypeOfNetwork);
      pData->peTypeOfNetwork = NULL;
    }
    
    if (pData->pEncryData != NULL)
    {
      ClearEncriptionData(pData->pEncryData);
      free(pData->pEncryData);
      pData->pEncryData = NULL;
    }
    
    if (pData->pLocalOptExtension != NULL)
    {
      ClearLocalOptionExtension(pData->pLocalOptExtension);
      free(pData->pLocalOptExtension);
      pData->pLocalOptExtension = NULL;
    }
  }
}
/*******************************************************************************
 * Function          : CopyLocalConnectionOptions
 *
 * Description       : Copy the Local Connection Options
 *                     
 * Input parameters  : pDesData - Pointer to the destination data be copied into
 *                     pSrcData - Pointer to the source data to be copied
 *
 * Output parameters : 
 *
 * Return value      : 
 *
 * Comments          : 
 *
 * History           :
 *  2005/07/15       : Creation
 *
 * Date              : July 15 2005, Frank Zhang
 ******************************************************************************/
void CopyLocalConnectionOptions(LOCAL_CONNEC_OPTS *pDesData,
                                LOCAL_CONNEC_OPTS *pSrcData)
{
  Assert(pDesData);

  if (pSrcData != NULL)
  {
    pDesData->wOptNum = pSrcData->wOptNum;

    /* Packetization Period */
    if (pSrcData->pPacketizationPeriod != NULL)
    {
      pDesData->pPacketizationPeriod
        = (PACKETIZATION_PERIOD*)calloc(1, sizeof(PACKETIZATION_PERIOD));
	  Assert(pDesData->pPacketizationPeriod);
      memcpy(pDesData->pPacketizationPeriod, pSrcData->pPacketizationPeriod,
             sizeof(PACKETIZATION_PERIOD));
    }

    /* Packetization Period */
    if (pSrcData->pCompressAlgo != NULL)
    {
      WORD i = 0;
      
      pDesData->pCompressAlgo
        = (COMPRESSION_ALGORITHM*)calloc(1, sizeof(COMPRESSION_ALGORITHM));
	  Assert(pDesData->pCompressAlgo);
//	  memset(pDesData->pCompressAlgo, 0, sizeof(COMPRESSION_ALGORITHM));
      pDesData->pCompressAlgo->wNum = pSrcData->pCompressAlgo->wNum;
      if (pDesData->pCompressAlgo->wNum > 0)
      {
        pDesData->pCompressAlgo->ppcAlgorithmList
          = (char**)calloc(pDesData->pCompressAlgo->wNum, sizeof(char*));
		Assert(pDesData->pCompressAlgo->ppcAlgorithmList);
//		memset(pDesData->pCompressAlgo->ppcAlgorithmList, 0, pDesData->pCompressAlgo->wNum * sizeof(char*));
        for (i= 0; i < pDesData->pCompressAlgo->wNum; i++)
        {
          StrClone(pDesData->pCompressAlgo->ppcAlgorithmList+i,
                   pSrcData->pCompressAlgo->ppcAlgorithmList[i]);
        }
      }
    }

    /* Packetization Period */
    if (pSrcData->pBandwidthValue != NULL)
    {
      pDesData->pBandwidthValue = (BANDWIDTH*)calloc(1, sizeof(BANDWIDTH));
	  Assert(pDesData->pBandwidthValue);
      memcpy(pDesData->pBandwidthValue, pSrcData->pBandwidthValue,
             sizeof(BANDWIDTH));
    }

    /* Packetization Period */
    if (pSrcData->psGainControl != NULL)
    {
      pDesData->psGainControl = (SHORT*)calloc(1, sizeof(SHORT));
	  Assert(pDesData->psGainControl);
      *pDesData->psGainControl = *pSrcData->psGainControl;
    }

    /* Packetization Period */
    if (pSrcData->peEchocancellation != NULL)
    {
      pDesData->peEchocancellation = (E_ON_OFF*)calloc(1, sizeof(E_ON_OFF));
	  Assert(pDesData->peEchocancellation);
      *pDesData->peEchocancellation = *pSrcData->peEchocancellation;
    }

    /* Silence Suppression */
    if (pSrcData->peSilenceSuppression != NULL)
    {
      pDesData->peSilenceSuppression = (E_ON_OFF*)calloc(1, sizeof(E_ON_OFF));
	  Assert(pDesData->peSilenceSuppression);
      *pDesData->peSilenceSuppression = *pSrcData->peSilenceSuppression;
    }

    /* Type Of Service */
    if (pSrcData->pucTypeOfService != NULL)
    {
      pDesData->pucTypeOfService = (BYTE*)calloc(1, sizeof(BYTE));
	  Assert(pDesData->pucTypeOfService);
      *pDesData->pucTypeOfService = *pSrcData->pucTypeOfService;
    }

    /* Resource Reservation */
    if (pSrcData->peResourceReservation != NULL)
    {
      pDesData->peResourceReservation
        = (E_RESOURCE_RESERVATION*)calloc(1, sizeof(E_RESOURCE_RESERVATION));
	  Assert(pDesData->peResourceReservation);
      *pDesData->peResourceReservation = *pSrcData->peResourceReservation;
    }


    /* Type Of Network */
    if (pSrcData->peTypeOfNetwork != NULL)
    {
      pDesData->peTypeOfNetwork
        = (E_NETWOR_TYPE*)calloc(1, sizeof(E_NETWOR_TYPE));
	  Assert(pDesData->peTypeOfNetwork);
      *pDesData->peTypeOfNetwork = *pSrcData->peTypeOfNetwork;
    }

    /* Encry Data */
    if (pSrcData->pEncryData != NULL)
    {
      pDesData->pEncryData = (ENCRYPTION_DATA*)calloc(1, sizeof(ENCRYPTION_DATA));
	  Assert(pDesData->pEncryData);
      *pDesData->pEncryData = *pSrcData->pEncryData;
    }

    /* Local Option Extension */
    if (pSrcData->pLocalOptExtension != NULL)
    {
      pDesData->pLocalOptExtension
        = (LOCAL_OPTION_EXTENSION*)calloc(1, sizeof(LOCAL_OPTION_EXTENSION));
	  Assert(pDesData->pLocalOptExtension);
//	  memset(pDesData->pLocalOptExtension, 0, sizeof(LOCAL_OPTION_EXTENSION));
      pDesData->pLocalOptExtension->eType = pSrcData->pLocalOptExtension->eType;
      StrClone(&pDesData->pLocalOptExtension->pcPackageName,
                pSrcData->pLocalOptExtension->pcPackageName);
      StrClone(&pDesData->pLocalOptExtension->pcExtensionName,
                pSrcData->pLocalOptExtension->pcExtensionName);
      StrClone(&pDesData->pLocalOptExtension->pcExtensionValue,
                pSrcData->pLocalOptExtension->pcExtensionValue);
    }
  }
}
/*******************************************************************************
 * Function          : ClearConnectionMode
 *
 * Description       : Clear the Connection Mode
 *                     
 * Input parameters  : pData - Pointer to the data to be cleared
 *
 * Output parameters : 
 *
 * Return value      : 
 *
 * Comments          : 
 *
 * History           :
 *  2005/07/16       : Creation
 *
 * Date              : July 16 2005, Frank Zhang
 ******************************************************************************/
void ClearConnectionMode(CONNECTION_MODE *pData)
{
  if ((pData != NULL) && (pData->pExtenMode != NULL))
  {
    if (pData->pExtenMode->pcExtenPackageName != NULL)
      free(pData->pExtenMode->pcExtenPackageName);
    
    if (pData->pExtenMode->pcExtenModeName != NULL)
      free(pData->pExtenMode->pcExtenModeName);

    free(pData->pExtenMode);
    pData->pExtenMode = NULL;
    pData->eMode = 0;
  } 
}
/*******************************************************************************
 * Function          : CopyConnectionMode
 *
 * Description       : Copy the Connection Mode
 *                     
 * Input parameters  : pDesData - Pointer to the destination data be copied into
 *                     pSrcData - Pointer to the source data to be copied
 *
 * Output parameters : 
 *
 * Return value      : 
 *
 * Comments          : 
 *
 * History           :
 *  2005/07/16       : Creation
 *
 * Date              : July 16 2005, Frank Zhang
 ******************************************************************************/
void CopyConnectionMode(CONNECTION_MODE *pDesData, CONNECTION_MODE *pSrcData)
{
  Assert(pDesData);

  if (pSrcData)
  {
    pDesData->eMode = pSrcData->eMode;

    if (pSrcData->eMode == CONNECTION_MODE_EXTENSION_MODE)
    {
      pDesData->pExtenMode = (EXTENSION_CONNECTION_MODE*)calloc(1, sizeof(EXTENSION_CONNECTION_MODE));
	  Assert(pDesData->pExtenMode);
//	  memset(pDesData->pExtenMode, 0, sizeof(EXTENSION_CONNECTION_MODE));
      StrClone(&pDesData->pExtenMode->pcExtenPackageName,
                pSrcData->pExtenMode->pcExtenPackageName);
      StrClone(&pDesData->pExtenMode->pcExtenModeName,
                pSrcData->pExtenMode->pcExtenModeName);
    }
  }
}
/*******************************************************************************
 * Function          : ClearEventName
 *
 * Description       : Clear the Event Name
 *                     
 * Input parameters  : pData - Pointer to the data to be cleared
 *
 * Output parameters : 
 *
 * Return value      : 
 *
 * Comments          : 
 *
 * History           :
 *  2005/07/16       : Creation
 *