cm.h

RVGatekeeper SIP SDK

			cmAutoChannelsStruct  *autoChannels);
#endif

typedef int 
    (CALLCONV * cmEvCallTunnNewMessageT)(
					 IN	HAPPCALL haCall, 
					 IN	HCALL hsCall,
					 IN     int vtNodeId,
					 IN     int vtAddNodeId,
					 OUT    BOOL *wait);

typedef  struct 
{
    cmEvCallStateChangedT   cmEvCallStateChanged;
    cmEvCallNewRateT        cmEvCallNewRate;
    cmEvCallInfoT           cmEvCallInfo;  
    cmCallNonStandardParamT cmCallNonStandardParam;
    cmEvCallFacilityT	    cmEvCallFacility;
    cmEvCallFastStartSetupT cmEvCallFastStartSetup;
    cmEvCallStatusT	    cmEvCallStatus;
    cmEvCallUserInfoT	    cmEvCallUserInfo;
    cmEvCallH450SupplServT	cmEvCallH450SupplServ;
    cmEvCallIncompleteAddressT	cmEvCallIncompleteAddress;
    cmEvCallAdditionalAddressT	cmEvCallAdditionalAddress;

  cmEvCallTunnNewMessageT cmEvCallTunnNewMessage;

#ifdef AUTOCHAN
    cmEvCallAutoChannelsUpdateT	cmEvCallAutoChannelsUpdate;
#endif


} SCMCALLEVENT,*CMCALLEVENT;
    

RVAPI
int CALLCONV cmInitialize(char * name,LPHAPP lphApp);

RVAPI
HAPP CALLCONV cmInit(
		IN      char*               appName);

RVAPI
int CALLCONV cmEnd(
		IN      HAPP                hApp);


RVAPI
int CALLCONV cmStart(
		IN	HAPP		hApp);

RVAPI
int CALLCONV cmStop(
		IN	HAPP		hApp);

RVAPI
int CALLCONV cmRegister(
		IN	HAPP		hApp);

RVAPI
int CALLCONV cmUnregister(
		IN	HAPP		hApp);

RVAPI 
int CALLCONV cmSendNonStandardMessage(
               IN      HAPP                hApp,
	       IN      cmNonStandardParam* param);
RVAPI
char* CALLCONV cmGetVersion(void);

RVAPI
int CALLCONV cmGetVersionName(
		IN	char*		buff,
		IN	int		length);


RVAPI
int CALLCONV
cmSetPreCallbackEvent(
		IN      HAPP                hApp,
		IN      cmNewCallbackEH     newCallback
		);

RVAPI
int CALLCONV cmSetGenEventHandler(
		IN      HAPP                hApp,
		IN      CMEVENT             cmEvent,
		IN      int                 size);

RVAPI
int CALLCONV cmGetGenEventHandler(
		IN      HAPP                hApp,
		IN      CMEVENT             cmEvent,
		IN      int                 size);


RVAPI
int CALLCONV cmSetCallEventHandler(
		IN      HAPP                hApp,
		IN      CMCALLEVENT         cmCallEvent,
		IN      int                 size);
RVAPI
int CALLCONV cmGetCallEventHandler(
		IN      HAPP                hApp,
		OUT      CMCALLEVENT         cmCallEvent,
		INOUT      int                 size);


RVAPI 
int CALLCONV cmCallNew(
		IN    HAPP                  hApp,
		IN    HAPPCALL              haCall,
		OUT   LPHCALL               lphsCall);

RVAPI
int CALLCONV cmCallDial(
		IN    HCALL                 hsCall);


RVAPI
int CALLCONV cmCallMake(
		IN      HCALL               hsCall,
		IN      UINT32              maxRate,
		IN      UINT32              minRate,
		IN      char*               destAddress,
		IN      char*               srcAddress,
		IN      char*               display,
		IN      char*               userUser,
                IN      int                 userUserSize);


RVAPI
int CALLCONV cmCallFacility(
	       IN HCALL		hsCall,
	       IN int		handle);

RVAPI
int CALLCONV cmSetCallHandle(
		IN HCALL                    hsCall,
		IN HAPPCALL                 haCall);


RVAPI
int CALLCONV cmCallGetDisplayInfo(
		IN 	HCALL		    hsCall,
                IN      char*               display,
                IN      int                 displaySize);

RVAPI
int CALLCONV cmCallGetUserUserInfo(
		IN 	HCALL		    hsCall,
                IN      char*               userUser,
                IN      int                 userUserSize);

RVAPI
int CALLCONV cmCallAnswerExt(
		IN 	HCALL		    hsCall,
                IN      char*               display,
                IN      char*               userUser,
                IN      int                 userUserSize);

RVAPI
int CALLCONV cmCallAnswerDisplay(
		IN 	HCALL		    hsCall,
                IN      char*               display);

RVAPI
int CALLCONV cmCallAnswer(
		IN      HCALL               hsCall);


RVAPI
int CALLCONV cmCallAccept(
		IN 	HCALL	 	    hsCall);

RVAPI
int CALLCONV cmCallDrop(
		IN      HCALL               hsCall);


RVAPI
int CALLCONV cmCallDropParam(
		IN 	HCALL	 	    hsCall,
                IN      cmReasonType        cmReason);
RVAPI
int CALLCONV cmCallClose(
		IN      HCALL               hsCall);

RVAPI
int CALLCONV cmCallGetCallingPartyId(
		IN      HCALL               hsCall,
		OUT     char*               callerId,
		IN      int                 size);

#define cmCallGetCallerId cmCallGetCallingPartyId

RVAPI
int CALLCONV cmCallGetCalledPartyId(
		IN      HCALL               hsCall,
		OUT     char*               calledPartyId,
		IN      int                 size);

RVAPI
int CALLCONV cmCallGetRate(
		IN      HCALL               hsCall,
		OUT     UINT32*             rate);

RVAPI
int CALLCONV cmCallGetOrigin(
		IN      HCALL               hsCall,
		OUT     BOOL*               origin);

RVAPI
int CALLCONV cmCallSetRate(
		IN      HCALL               hsCall,
		IN      UINT32              rate);


RVAPI
int CALLCONV cmCallForward(
		IN 	HCALL	 	hsCall,
		IN 	char* 		destAddress);


RVAPI
int CALLCONV cmCallGetParam(
		IN      HCALL               hsCall,
		IN      cmCallParam         param,
		IN      int                 index,
		IN      INT32*              value,
		IN      char *              svalue);

RVAPI
int CALLCONV cmCallSetParam(
		IN      HCALL               hsCall,
		IN      cmCallParam         param,
		IN      int                 index,
		IN      INT32               value,
		IN      char *              svalue);

RVAPI 
HPVT CALLCONV cmGetValTree(
                IN	HAPP		     hApp);



RVAPI
int CALLCONV cmCallGetNumOfParams(
		IN      HCALL               hsCall,
		IN      cmCallParam         param);


RVAPI 
HPST CALLCONV cmGetSynTreeByRootName(
                IN	HAPP		    hApp,
                IN      char*               name);

RVAPI 
INT32 CALLCONV cmGetQ931ConfigurationHandle(
                IN	HAPP		    hApp);


RVAPI
int CALLCONV cmCallJoin(
                IN      HCALL               hsCall,
                IN      HCALL               hsSameConferenceCall);

RVAPI
int CALLCONV cmCallInvite(
                IN      HCALL               hsCall,
                IN      HCALL               hsSameConferenceCall);

RVAPI
int CALLCONV cmCallIsSameConference(
		IN 	HCALL		    hsCall,
                IN 	HCALL		    hsAnotherCall);

RVAPI char* CALLCONV 
cmGetProtocolMessageName(
                IN      HAPP                hApp,
                IN      int                 msg);



RVAPI
int CALLCONV cmCallGetRemoteEndpointInfoHandle(
		IN 	HCALL		hsCall);

RVAPI
int CALLCONV cmCallGetLocalEndpointInfoHandle(
		IN 	HCALL		hsCall);

RVAPI
int CALLCONV cmGetEndpointInfoHandle(
		IN 	HAPP		hApp);



RVAPI
int CALLCONV cmGetParam(
		IN HAPP 		hApp,
		IN cmParam		param,
		IN int			index,
		IN INT32*		value,
		IN char *		svalue);


RVAPI int CALLCONV 
cmSetHandle(
	    IN      HAPP                hApp,
	    IN	    HAPPAPP		haApp);

RVAPI int CALLCONV 
cmGetHandle(
	    IN      HAPP                hApp,
	    IN	    HAPPAPP*		haApp);

/* nonStandard handling_______________________________________________________________*/

RVAPI int CALLCONV /* TRUE or ERROR */
cmNonStandardParameterCreate(
			     /* Create NonStandardParameter tree */
			     IN  HPVT hVal,
			     IN  int rootId, /* nonStandardData */

			     IN  cmNonStandardIdentifier *identifier,
			     IN  char *data,
			     IN  int dataLength /* in bytes */
			     );

RVAPI int CALLCONV /* TRUE or ERROR */
cmNonStandardParameterGet(
			  /* Convert NonStandardParameter tree to C structures */
			  IN  HPVT hVal,
			  IN  int rootId, /* nonStandardData */
			  
			  OUT cmNonStandardIdentifier *identifier,
			  OUT char *data,
			  INOUT INT32 *dataLength /* (in bytes) IN: data allocation. OUT: correct size */
			  );
RVAPI
int CALLCONV cmCallConnectControl(
                IN      HCALL               hsCall
                );

RVAPI
int CALLCONV 
cmCallSw2SeparateH245(IN      HCALL               hsCall);

RVAPI
int CALLCONV cmCallSetIndependentSupplementaryService(
                IN      HCALL               hsCall
                );

RVAPI
int CALLCONV cmCallSendSupplementaryService(
                IN      HCALL               hsCall,
		IN      void*		    buffer,
		IN	int		    bufferSize,
		IN      BOOL                force
		);
RVAPI 
int CALLCONV cmEmEncode( 
                IN      HPVT                valH,
	        IN      int	            vNodeId,
	        IN      BYTE*               buffer,
	        IN      int	            length,
	        OUT     int*                encoded);

RVAPI 
int CALLCONV cmEmDecode(
	        IN      HPVT                valH,
        	IN      int	            vNodeId,
	        OUT     BYTE*               buffer,
	        IN      int	            length,
	        OUT     int*                decoded);


RVAPI 
int CALLCONV cmAlias2Vt(
                IN      HPVT                valH,
	        IN      cmAlias*            alias,
	        IN      int                 nodeId);



RVAPI 
INT32 CALLCONV cmGetLocalCallSignalAddress(
                IN	HAPP		     hApp,
                OUT     cmTransportAddress*  tr);

RVAPI 
INT32 CALLCONV cmGetLocalRASAddress(
                IN	HAPP		     hApp,
                OUT     cmTransportAddress*  tr);

RVAPI 
INT32 CALLCONV cmGetGKCallSignalAddress(
                IN	HAPP		     hApp,
                OUT     cmTransportAddress*  tr);

RVAPI 
INT32 CALLCONV cmGetGKRASAddress(
                IN	HAPP		     hApp,
                OUT     cmTransportAddress*  tr);

RVAPI 
HPROTCONN CALLCONV cmGetRASConnectionHandle(
                IN	HAPP		     hApp);

RVAPI int CALLCONV cmVt2Alias(IN  HPVT       hVal,
	        IN      cmAlias*             alias,
	        IN      int                  nodeId);

RVAPI int CALLCONV cmGetProperty( 
                IN      HPROTOCOL	     hsProtocol);

RVAPI HAPP CALLCONV cmGetAHandle(
                IN      HPROTOCOL            hsProtocol);

RVAPI
int CALLCONV cmCallStatusEnquiry(
					IN 	HCALL	 	hsCall,
					UINT8 * display);


/* 
cmGetH225RemoteVersion
return H225 version number of remote side via OUT parameter
version.
version is user allocated string*/
								 
RVAPI
int CALLCONV cmGetH225RemoteVersion(IN HCALL		hsCall,OUT char * version);

/*
cmCallUserInformationCreate
create root of information message .Build all must parameters.
Add display and nonstandard parameter if they are and return root id to user to
do changes if it need
*/
RVAPI
int CALLCONV cmCallUserInformationCreate(IN HCALL hsCall,char * display,cmNonStandardParam* param);

/*
cmCallUserInformationSend
send user information message
*/
RVAPI
int CALLCONV cmCallUserInformationSend(IN HCALL hsCall,int nodeId);

/*
cmCallUserInformationGet
Get rootId of the user information message and retrieve display and nonStandard parameter
Root Id of incoming user information message is passed to callback function of  cmEvCallUserInfoT type 
if it is set by user.   
*/
RVAPI
int CALLCONV cmCallUserInformationGet(IN HAPP hApp,IN int nodeId,
				      OUT char *display,IN int displaySize,
				      OUT cmNonStandardParam* param);
/*
cmCallForwardCallProcMsg
Forward callProceeding message.Get it from call property.So to forward it ,message must be copied 
to property.
*/

RVAPI
int CALLCONV cmCallSendCallProceeding(	IN HCALL hsCall);

/* delete pvt of connect,setup,alerting and callProceeding from call property  to reduce memory
 can be run only in connected state.All information from this messages will be lost after runing
this function.*/

RVAPI
int CALLCONV cmFreeProperty(	IN HCALL hsCall);


RVAPI 
int CALLCONV cmCallOverlapSending(IN HCALL hsCall,char * address);



RVAPI
HPROTCONN CALLCONV cmGetTpktChanHandle(	IN HCALL hsCall,cmTpktChanHandleType  tpktChanHandleType);

RVAPI
HPROTCONN CALLCONV cmGetUdpChanHandle(	IN HCALL hsCall,cmUdpChanHandleType  udpChanHandleType);


RVAPI
int CALLCONV cmSetUdpChanApplHandle(	IN HPROTCONN hCon,HAPPCONN hAppConn);

RVAPI
int CALLCONV cmSetTpktChanApplHandle(	IN HPROTCONN hCon,HAPPCONN hAppConn);

RVAPI
int CALLCONV cmGetUdpChanApplHandle(	IN HPROTCONN hCon,HAPPCONN * hAppConn);

RVAPI
int CALLCONV cmGetTpktChanApplHandle(	IN HPROTCONN hCon,HAPPCONN * hAppConn);

RVAPI
int CALLCONV cmCallIncompleteAddress(IN HCALL hsCall);


RVAPI
int CALLCONV cmCallAddressComplete(IN HCALL hsCall);

RVAPI 
int CALLCONV cmCallOverlapSendingExt(IN HCALL hsCall,char * address,BOOL sendingComplete);

RVAPI int CALLCONV
cmSendRAI(
       IN      HAPP                hApp,
       IN      BOOL 	almostOutOfResources);

#define cmCallSetHandle cmSetCallHandle 
RVAPI
int CALLCONV cmSetCallHandle(IN HCALL hsCall, IN HAPPCALL haCall);

RVAPI
int CALLCONV cmCallGetHandle(IN HCALL hsCall, OUT HAPPCALL* haCall);

#include <ci.h>
/* cmGetConfiguration()

   Gives access to the session's configuration context.
   The returned HCFG should be considered read-only, and should never be
   destroyed. */
RVAPI 
HCFG CALLCONV cmGetConfiguration(IN HAPP hApp);


#endif

#ifdef __cplusplus
}              
#endif