mgcpdef.h

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

	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;

typedef void (*SIGEV_NOTIFY_FUNCTION)(union sigval);

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