mgcpdef.h

内容正如其名

typedef struct
{
  NOTIFIED_ENTITY *pNotifiedEntity;
  REQUESTED_EVENTS *pRequestedEvents;
  char *pcRequestIdentifier;
  DIGIT_MAP *pDigitMap;
  SIGNAL_REQUESTS *pSignalRequests;
  QUARANTINE_HANDLING *pQuarantineHandling;
  DETECT_EVENTS *pDetectEvents;
                                     
  ENCAPSULATED_EPCF EncapEpcf;

  EXPERIMENTAL_PARAMS ExperiParamList;
  RESPONSE_ACK *pRspAck;            /* ResponseAck parameter */
} MGCP_RQNT_CMD;

/* To simplify process, define the bellow two structs same as the RQNT */
typedef MGCP_RQNT_CMD ENCAPSULATED_RQNT;
typedef MGCP_RQNT_CMD EMBEDDED_REQUEST;

typedef struct
{
  NOTIFIED_ENTITY *pNotifiedEntity;
  char *pcRequestIdentifier;
  OBSERVED_EVENTS *pObservedEvents;

  EXPERIMENTAL_PARAMS ExperiParamList;
  RESPONSE_ACK *pRspAck;            /* ResponseAck parameter */
} MGCP_NTFY_CMD;

typedef struct
{
  char *pcCallId;
  NOTIFIED_ENTITY *pNotifiedEntity;
  LOCAL_CONNEC_OPTS *pLocalConnecOpt;
  CONNECTION_MODE *pMode;

  CONNECTION_DESCRIPTOR *pRemConnectDescrpt;
  ENDPOINT_NAME *pSecondEndpointId;

  ENCAPSULATED_RQNT *pEncapRqnf;
  ENCAPSULATED_EPCF *pEncapEpcf;

  EXPERIMENTAL_PARAMS ExperiParamList;
  RESPONSE_ACK *pRspAck;            /* ResponseAck parameter */
} MGCP_CRCX_CMD;

typedef struct
{
  char *pcCallId;
  char *pcConnectionId;
  
  NOTIFIED_ENTITY *pNotifiedEntity;
  LOCAL_CONNEC_OPTS *pLocalConnecOpt;
  CONNECTION_MODE *pMode;

  CONNECTION_DESCRIPTOR *pRemoteConnectDescrpt;

  ENCAPSULATED_RQNT *pEncapRqnf;
  ENCAPSULATED_EPCF *pEncapEpcf;

  EXPERIMENTAL_PARAMS ExperiParamList;
  RESPONSE_ACK *pRspAck;            /* ResponseAck parameter */
} MGCP_MDCX_CMD;

typedef struct
{
  /* If NULL, delete all connections of all calls */
  char *pcCallId;

  /* If NULL, delete all connections of the call */
  char *pcConnectionId;
  
  NOTIFIED_ENTITY *pNotifiedEntity;

  ENCAPSULATED_RQNT *pEncapRqnf;
  ENCAPSULATED_EPCF *pEncapEpcf;

  /* Only used for GW to send DLCX */
  REASON_CODE *pReasonCode;

  /* Only used for GW to send DLCX */
  CONNECTION_PARAMETERS *pConnecParam;

  EXPERIMENTAL_PARAMS ExperiParamList;
  RESPONSE_ACK *pRspAck;            /* ResponseAck parameter */
} MGCP_DLCX_CMD;

typedef struct
{
  REQUESTED_INFO *pReqInfo;

  EXPERIMENTAL_PARAMS ExperiParamList;
  RESPONSE_ACK *pRspAck;            /* ResponseAck parameter */
} MGCP_AUEP_CMD;

typedef struct
{
  char *pcConnectionId;
  REQUESTED_INFO *pReqInfo;

  EXPERIMENTAL_PARAMS ExperiParamList;
  RESPONSE_ACK *pRspAck;           /* ResponseAck parameter */
} MGCP_AUCX_CMD;

typedef struct
{
  RESTART_METHOD RestartMethod;
  DWORD	*pdwRestartDelay;        /* Restart dealy parameter must not be used
                                    in "forced" and "cancel-graceful" methods */
  REASON_CODE *pReasonCode;

  EXPERIMENTAL_PARAMS ExperiParamList;
} MGCP_RSIP_CMD;

typedef struct
{
  RESPONSE_ACK *pResponseAck;
  BEARER_INFO *pBearerInformation;
  char *pcCallId;
  CONNECTION_IDS *pConnectionIds;  
  NOTIFIED_ENTITY *pNotifiedEntity;
  char *pcRequestIdentifier;
  LOCAL_CONNEC_OPTS *pLocalConnectionOptions;
  CONNECTION_MODE *pConnectionMode;
  REQUESTED_EVENTS *pRequestedEvents;
  SIGNAL_REQUESTS *pSignalRequests;
  DIGIT_MAP *pDigitMap;
  OBSERVED_EVENTS *pObservedEvents;
  CONNECTION_PARAMETERS *pConnectionParameters;
  REASON_CODE *pReasonCode;
  ENDPOINT_NAME *pSpecificEndpointID;
  ENDPOINT_NAME *pSecondEndpointID;
  char *pcSecondConnectionID;
  REQUESTED_INFO *pRequestedInfo;
  QUARANTINE_HANDLING *pQuarantineHandling;
  DETECT_EVENTS *pDetectEvents;
  RESTART_METHOD *pRestartMethod;
  DWORD *pRestartDelay;
  CAPABILITIES *pCapabilities;
  EVENT_STATES *pEventStates;
  PACKAGE_LIST *pPackageList;
  DWORD *pMaxMGCPDatagram;  
  CONNECTION_DESCRIPTOR *pLocalConnectDescriptor;
  CONNECTION_DESCRIPTOR *pRemoteConnectDescriptor;
  EXPERIMENTAL_PARAMS ExperiParamList;
} MGCP_PARAMETERS;

typedef struct
{
  char *pcCmdName;
  MGCP_PARAMETERS ParamLineList;
} MGCP_EXPR_CMD;

/******************************************************************************
 * MGCP response defination
 ******************************************************************************/
typedef struct
{
  PACKAGE_LIST *pPackageList;
  EXPERIMENTAL_PARAMS ExperiParamList;
} MGCP_EPCF_RSP;

typedef MGCP_EPCF_RSP MGCP_RQNT_RSP;
typedef MGCP_EPCF_RSP MGCP_NTFY_RSP;

typedef struct
{
  char *pcConnectionId;

  /* Only used when EndpointId in CRCX command using Any wildcard */
  ENDPOINT_NAME *pSpecificEndPointId;

  CONNECTION_DESCRIPTOR *pLocalConnectDescriptor;
  
  /* Only used when SecondEndPointId in CRCX command using Any wildcard */
  ENDPOINT_NAME *pSecondEndPointId;

  /* When a SecondEndpointId is specified, two connections are created, use this
     parameter to identify the second connection.  The second connection is
     established in "send/receive" mode */
  char *pSecondConnectionId;

  PACKAGE_LIST *pPackageList;

  EXPERIMENTAL_PARAMS ExperiParamList;
} MGCP_CRCX_RSP;

typedef struct
{
  CONNECTION_DESCRIPTOR *pLocalConnectDescriptor;
  PACKAGE_LIST *pPackageList;

  EXPERIMENTAL_PARAMS ExperiParamList;
} MGCP_MDCX_RSP;

typedef struct
{
  /* Only used when DLCX contains the ConnectionId and send by MG*/  
  CONNECTION_PARAMETERS *pConnecParam;
  
  PACKAGE_LIST *pPackageList;
  EXPERIMENTAL_PARAMS ExperiParamList;
} MGCP_DLCX_RSP;

typedef struct
{
  WORD wNum;
  ENDPOINT_NAME *pEndpntIDList;
} ENDPOINT_IDS;

typedef struct
{
  ENDPOINT_IDS *pEndPntIDs;  /* If AUEP command use wildcard, the response
                              * should only contain the endpoint IDs */
  
  REQUESTED_EVENTS *pRequestedEvents;
  QUARANTINE_HANDLING *pQuarantineHandling;
  DIGIT_MAP *pDigitMap;
  SIGNAL_REQUESTS *pSignalRequests;
  char *pcRequestIdentifier;
  NOTIFIED_ENTITY *pNotifiedEntity;

  CONNECTION_IDS *pConnectionIDs;
  DETECT_EVENTS *pDetectEvents;
  OBSERVED_EVENTS *pObservedEvents;
  EVENT_STATES *pEventStates;
  BEARER_INFO *pBearerInformation;
  RESTART_METHOD *pRestartMethod;
  DWORD *pdwRestartDelay;
  REASON_CODE *pReasonCode;
  DWORD *pdwMaxMGCPDatagram;
  PACKAGE_LIST *pPackageList;

  /* AUEP response may include multiple capabilities parameter lines */
  WORD wCapNum;
  CAPABILITIES *pCapabilities;

  EXPERIMENTAL_PARAMS ExperiParamList;
} MGCP_AUEP_RSP;

typedef struct
{
  char *pcCallId;
  NOTIFIED_ENTITY *pNotifiedEntity;
  LOCAL_CONNEC_OPTS *pLocalConnecOptions;
  CONNECTION_MODE *pMode;
  CONNECTION_DESCRIPTOR *pRemoteConnectDescriptor;
  CONNECTION_DESCRIPTOR *pLocalConnectDescriptor;  
  CONNECTION_PARAMETERS *pConnecParam;  
  PACKAGE_LIST *pPackageList;
  EXPERIMENTAL_PARAMS ExperiParamList;
} MGCP_AUCX_RSP;

typedef struct
{
  NOTIFIED_ENTITY *pNotifiedEntity;
  EXPERIMENTAL_PARAMS ExperiParamList;
} MGCP_RSIP_RSP;


/******************************************************************************
 * MGCP message defination
 ******************************************************************************/

/* MGCP command type */
typedef enum
{
  MGCP_CMD_RSIP = 1,
  MGCP_CMD_NTFY,
  MGCP_CMD_EPCF,
  MGCP_CMD_RQNT,
  MGCP_CMD_CRCX,
  MGCP_CMD_MDCX,
  MGCP_CMD_DLCX,
  MGCP_CMD_AUEP,
  MGCP_CMD_AUCX,
  MGCP_CMD_EXPR
} E_MGCP_CMD;

/* MGCP response type */
typedef enum
{
  MGCP_RSP_COMM = 0,  /* Common Mgcp response */
  MGCP_RSP_RSIP,
  MGCP_RSP_NTFY, 
  MGCP_RSP_EPCF,
  MGCP_RSP_RQNT,
  MGCP_RSP_CRCX,
  MGCP_RSP_MDCX,
  MGCP_RSP_DLCX,
  MGCP_RSP_AUEP,
  MGCP_RSP_AUCX,
  MGCP_RSP_EXPR
} E_MGCP_RSP;

/* Genreral mgcp incomingcommand struct */
typedef struct
{
  DWORD dwTransacId;                /* Transaction ID */
  ENDPOINT_NAME EndpointName;       /* Endpoint name */
  char *pcMGCPVersion;
  char *pcProfileName;              /* MGCP profile name */
  DWORD dwSrcIpAddr;                /* Source IP address of incoming command */
  WORD wSrcPort;                    /* Source UDP port of incoming command */

  E_MGCP_CMD eType;                 /* Command type */
  union                             /* Command data */
  {
    MGCP_RSIP_CMD *pRsipCmd;
    MGCP_NTFY_CMD *pNtfyCmd;
    MGCP_EPCF_CMD *pEpcfCmd;
    MGCP_RQNT_CMD *pRqntCmd;
    MGCP_CRCX_CMD *pCrcxCmd;
    MGCP_MDCX_CMD *pMdcxCmd;
    MGCP_DLCX_CMD *pDlcxCmd;
    MGCP_AUEP_CMD *pAuepCmd;
    MGCP_AUCX_CMD *pAucxCmd;
    MGCP_EXPR_CMD *pExprCmd;
  } u;
} MGCP_INCOMING_COMMAND;

/* Genreral mgcp incoming response struct */
typedef struct
{
  WORD wRspCode;                    /* Response code */
  DWORD dwTransacId;                /* Transaction ID */
  char *pcResponseString;           /* Response string */  
  MGCP_PARAMETERS ParamLineList;    /* Parameter lines */
} MGCP_INCOMING_RESPONSE;

char* FindRspStringByCode(DWORD dwRspCode);
void ClearSdpConnectionField(CONNECTION_FIELD *pData);
void CopySdpConnectionField(CONNECTION_FIELD *pDesData, CONNECTION_FIELD *pSrcData);
void CopySdpMediaField(MEDIA_FIELD *pDesData, MEDIA_FIELD *pSrcData);
void ClearSdpAttributeField(ATTRIBUTE_FIELD *pData);
void CopySdpAttributeField(ATTRIBUTE_FIELD *pDesData, ATTRIBUTE_FIELD *pSrcData);
void ClearSdpMediaDescriptions(MEDIA_DESCRIPTIONS *pData);
void CopySdpMediaDescriptions(MEDIA_DESCRIPTIONS *pDesData, MEDIA_DESCRIPTIONS *pSrcData);
void ClearSdpConnectionDescriptor(CONNECTION_DESCRIPTOR *pData);
void CopySdpConnectionDescriptor(CONNECTION_DESCRIPTOR *pDesData, CONNECTION_DESCRIPTOR *pSrcData);
void ClearResponseAck(RESPONSE_ACK *pData);
void ClearBeaerAttribute(BEARER_ATTRIBUTE *pData);
void ClearBearerInfo(BEARER_INFO *pData);
void CopyBearerInfo(BEARER_INFO *pDesData, BEARER_INFO *pSrcData);
void ClearNotifiedEntity(NOTIFIED_ENTITY *pData);
void CopyNotifiedEntity(NOTIFIED_ENTITY *pDesNE, NOTIFIED_ENTITY *pSrcNE);
void ClearCompressionAlgorithm(COMPRESSION_ALGORITHM *pData);
void ClearEncriptionData(ENCRYPTION_DATA *pData);
void ClearLocalOptionExtension(LOCAL_OPTION_EXTENSION *pData);
void ClearLocalConnectionOptions(LOCAL_CONNEC_OPTS *pData);
void CopyLocalConnectionOptions(LOCAL_CONNEC_OPTS *pDesData, LOCAL_CONNEC_OPTS *pSrcData);
void ClearConnectionMode(CONNECTION_MODE *pData);
void CopyConnectionMode(CONNECTION_MODE *pDesData, CONNECTION_MODE *pSrcData);
void ClearEventName(EVENT_NAME *pData);
void CopyEventName(EVENT_NAME *pDesData, EVENT_NAME *pSrcData);
void ClearEventParameters(EVENT_PARAMETERS *pData);
void CopyEventParameters(EVENT_PARAMETERS *pDesData, EVENT_PARAMETERS *pSrcData);
void ClearEmbeddedRequest(EMBEDDED_REQUEST *pData);
void CopyEmbeddedRequest(EMBEDDED_REQUEST *pDesData, EMBEDDED_REQUEST *pSrcData);
void ClearEventAction(EVENT_ACTION *pData);
void CopyEventAction(EVENT_ACTION *pDesData, EVENT_ACTION *pSrcData);
void CopyExtensionAction(EXTENSION_ACTION *pDesData, EXTENSION_ACTION *pSrcData);
void ClearEventActions(EVENT_ACTIONS *pData);
void CopyEventActions(EVENT_ACTIONS *pDesData, EVENT_ACTIONS *pSrcData);
void ClearRequestedEvent(REQUESTED_EVENT *pData);
void CopyRequestedEvent(REQUESTED_EVENT *pDesData, REQUESTED_EVENT *pSrcData);
void ClearRequestedEvents(REQUESTED_EVENTS *pData);
void CopyRequestedEvents(REQUESTED_EVENTS *pDesData, REQUESTED_EVENTS *pSrcData);
void ClearSignalRequest(SIGNAL_REQUEST *pData);
void CopySignalRequest(SIGNAL_REQUEST *pDesData, SIGNAL_REQUEST *pSrcData);
void ClearSignalRequests(SIGNAL_REQUESTS *pData);
void CopySignalRequests(SIGNAL_REQUESTS *pDesData, SIGNAL_REQUESTS *pSrcData);
void CopyDigitMap(DIGIT_MAP *pDesData, DIGIT_MAP *pSrcData);
void ClearDigitMap(DIGIT_MAP *pData);
void ClearMgcpDigitMap(MGCP_DIGIT_MAP *pData);
void ClearConnectionParameters(CONNECTION_PARAMETERS *pData);
void CopyConnectionParameters(CONNECTION_PARAMETERS *pDesData, CONNECTION_PARAMETERS *pSrcData);
void ClearReasonCode(REASON_CODE *pData);
void ClearEndpointName(ENDPOINT_NAME *pData);
void ClearExtensionParameter(EXTENSION_PARAMETER *pData);
void ClearExperimentalParameter(EXPERIMENTAL_PARAMETER *pData);
void ClearExperimentalParameters(EXPERIMENTAL_PARAMS *pData);
void ClearRequestedInfo(REQUESTED_INFO *pData);
void ClearRestartMethod(RESTART_METHOD *pData);
void CopyRestartMethod(RESTART_METHOD *pDesData, RESTART_METHOD *pSrcData);
void ClearCapabilities(CAPABILITIES *pData);
void ClearPackageList(PACKAGE_LIST *pData);
void ClearMgcpEpcfCommand(MGCP_EPCF_CMD *pData);
void ClearEncapEpcfCommand(ENCAPSULATED_EPCF *pData);
void ClearMgcpRqntCommand(MGCP_RQNT_CMD *pData);
void ClearEncapRqntCommand(ENCAPSULATED_RQNT *pData);
void ClearMgcpNtfyCommand(MGCP_NTFY_CMD *pData);
void ClearMgcpCrcxCommand(MGCP_CRCX_CMD *pData);
void ClearMgcpMdcxCommand(MGCP_MDCX_CMD *pData);
void ClearMgcpDlcxCommand(MGCP_DLCX_CMD *pData);
void ClearMgcpAuepCommand(MGCP_AUEP_CMD *pData);
void ClearMgcpAucxCommand(MGCP_AUCX_CMD *pData);
void ClearMgcpRsipCommand(MGCP_RSIP_CMD *pData);
void ClearMgcpParameterLine(MGCP_PARAMETERS *pData);
void ClearMgcpExprimentalCommand(MGCP_EXPR_CMD *pData);
void ClearMgcpEpcfResponse(MGCP_EPCF_RSP *pData);
void ClearMgcpRqntResponse(MGCP_RQNT_RSP *pData);
void ClearMgcpNtfyResponse(MGCP_NTFY_RSP *pData);
void ClearMgcpCrcxResponse(MGCP_CRCX_RSP *pData);
void ClearMgcpMdcxResponse(MGCP_MDCX_RSP *pData);
void ClearMgcpDlcxResponse(MGCP_DLCX_RSP *pData);
void ClearConnectionIDS(CONNECTION_IDS *pData);
void ClearEndpointIDS(ENDPOINT_IDS *pData);
void ClearMgcpAuepResponse(MGCP_AUEP_RSP *pData);
void ClearMgcpAucxResponse(MGCP_AUCX_RSP *pData);
void ClearMgcpRsipResponse(MGCP_RSIP_RSP *pData);
void ClearMgcpIncomingCmd(MGCP_INCOMING_COMMAND *pData);
void ClearMgcpIncomingRsp(MGCP_INCOMING_RESPONSE *pData);
void CopyExperimentalParameters(EXPERIMENTAL_PARAMS *pDesData, EXPERIMENTAL_PARAMS *pSrcData);
void ClearMgcpEventNameList(SLIST *pData);
void ClearMgcpSignal(MGCP_SIGNAL *pData);
void ClearMgcpSignalList(SLIST *pData);
void ClearMgcpRequestedEvent(MGCP_REQUESTED_EVENT *pData);
void ClearMgcpRequestedEventList(SLIST *pData);
void ClearMgcpDetectEvent(MGCP_DETECT_EVENT *pData);
void ClearMgcpDetectEventList(SLIST *pData);
void ClearMgcpEventID(MGCP_EVENT_ID *pData);
void ClearMgcpEventName(MGCP_EVENT_NAME *pData);
void ClearMgcpEventAction(MGCP_EVENT_ACTION *pData);
void ClearMgcpEventActionList(SLIST *pData);
void CopyMgcpObservedEvent(MGCP_OBSERVED_EVENT *pDesData, MGCP_OBSERVED_EVENT *pSrcData);
void ClearMgcpObservedEventList(SLIST *pData);
BOOL IsDotDecimalAddress(char *pcAddress);

#ifdef __cplusplus
}
#endif

#endif