rvwp_api.c

基于h323协议的软phone

				{ 
					fprintf(fp,"Configuration problem\n");
					ReleaseSemaphore(fileSem,1,NULL);
				}*/
				break;
			case -13: 
			/*	if(WaitForSingleObject(fileSem,INFINITE) == WAIT_OBJECT_0) 
				{ 
					fprintf(fp,"Network problem\n");
					ReleaseSemaphore(fileSem,1,NULL);
				}*/
				break;
			default: 
			/*	if(WaitForSingleObject(fileSem,INFINITE) == WAIT_OBJECT_0) 
				{ 
					fprintf(fp,"Unknown problem = %d\n", status);
					ReleaseSemaphore(fileSem,1,NULL);
				}*/
				break;
		}
		return status;
	}
/*	endConfig();*/

#if 1
#ifdef INCLUDE_RV_RTP

	status = rtpInit();
	if (status < 0)
	{
	/*	TRACE("rtpInit error:%d\n", status);*/
		return status;
	}
#if 1

	status = rtcpInit();
	if (status < 0)
	{
	/*	TRACE("rtcpInit error:%d\n", status);*/
		return status;
	}
#endif
	/*rtp_start_time = timerGetTimeInSeconds();*/
#endif
#endif
    /* Initialize supserv (does nothing if not h450 enabled) 
    status = H450_init((char *)CONFIG_FILE,hApp);
    if (status < 0) return status*/;

    /* Initialize OSP (does nothing if not OSP enabled)
    status = OSP_TestInit(hApp);
    if (status < 0) return status */;

    /* Initialize rtp/rtcp (does nothing if not enabled) 
    RTP_TestInit()*/;

    /* Initialize security (does nothing if not security enabled)
    SEC_init(hApp); */

    /* Initialize MIB support 
    SNMP_init();*/
 
    memset(&cmEvent, 0, sizeof(SCMEVENT));
    cmEvent.cmEvNewCall     = cmEvNewCall;
    UNUSED_HANDLE(cmEvent.cmEvRegEvent);
    cmSetGenEventHandler(hApp,&cmEvent,sizeof(SCMEVENT));

    memset (&cmCallEvent,0,sizeof(SCMCALLEVENT));
    cmCallEvent.cmCallNonStandardParam      = NULL; /*Obsolete. Stack never calls it */
    UNUSED_HANDLE(cmCallEvent.cmEvCallAdditionalAddress);
    cmCallEvent.cmEvCallFacility            = wpcmEvCallFacility;
    UNUSED_HANDLE(cmCallEvent.cmEvCallFastStart);
    /*cmCallEvent.cmEvCallFastStartSetup      = cmEvCallFastStartSetup;*/
/*#ifdef USE_H450
    cmCallEvent.cmEvCallH450SupplServ       = cmEvCallH450SupplServ;
#endif*/
    UNUSED_HANDLE(cmCallEvent.cmEvCallIncompleteAddress);
    /*cmCallEvent.cmEvCallInfo                = cmEvCallInfo;*/
    UNUSED_HANDLE(cmCallEvent.cmEvCallNewAnnexLMessage);
    UNUSED_HANDLE(cmCallEvent.cmEvCallNewAnnexMMessage);
    UNUSED_HANDLE(cmCallEvent.cmEvCallNewRate);
    /*cmCallEvent.cmEvCallNotify              = cmEvCallNotify;*/
    cmCallEvent.cmEvCallProgress            = cmEvCallProgress;
    cmCallEvent.cmEvCallRecvMessage         = cmEvCallRecvMessage;
    cmCallEvent.cmEvCallSendMessage         = cmEvCallSendMessage;
    cmCallEvent.cmEvCallStateChanged        = cmEvCallStateChanged;
   /* cmCallEvent.cmEvCallStatus              = cmEvCallStatus;
    cmCallEvent.cmEvCallTunnNewMessage      = cmEvCallTunnNewMessage;*/
    cmCallEvent.cmEvCallFastStart		= cmEvCallFastStart;
/*    cmCallEvent.cmEvCallUserInfo            = cmEvCallUserInfo;*/
    cmSetCallEventHandler(hApp,&cmCallEvent,sizeof(SCMCALLEVENT));

    memset (&cmChanEvent,0,sizeof(SCMCHANEVENT));
    cmChanEvent.cmEvChannelStateChanged             = cmEvChannelStateChanged;
	cmChanEvent.cmEvChannelSetAddress               = cmEvChannelSetAddress;
	cmChanEvent.cmEvChannelParameters               = cmEvChannelParameters;
/*	cmChanEvent.cmEvChannelReplace                  = cmEvChannelReplace;
    cmChanEvent.cmEvChannelStateChanged             = cmEvChannelStateChanged;
    cmChanEvent.cmEvChannelNewRate                  = cmEvChannelNewRate;
    cmChanEvent.cmEvChannelMaxSkew                  = cmEvChannelMaxSkew;
    cmChanEvent.cmEvChannelSetAddress               = cmEvChannelSetAddress;
    cmChanEvent.cmEvChannelSetRTCPAddress           = cmEvChannelSetRTCPAddress;
    cmChanEvent.cmEvChannelParameters               = cmEvChannelParameters;
    cmChanEvent.cmEvChannelRTPDynamicPayloadType    = cmEvChannelRTPDynamicPayloadType;
    cmChanEvent.cmEvChannelVideoFastUpdatePicture   = cmEvChannelVideoFastUpdatePicture;
    cmChanEvent.cmEvChannelVideoFastUpdateGOB       = cmEvChannelVideoFastUpdateGOB;
    cmChanEvent.cmEvChannelVideoFastUpdateMB        = cmEvChannelVideoFastUpdateMB;
    cmChanEvent.cmEvChannelHandle                   = cmEvChannelHandle;
    cmChanEvent.cmEvChannelGetRTCPAddress           = cmEvChannelGetRTCPAddress;
    cmChanEvent.cmEvChannelRequestCloseStatus       = cmEvChannelRequestCloseStatus;
    cmChanEvent.cmEvChannelTSTO                     = cmEvChannelTSTO;
    cmChanEvent.cmEvChannelMediaLoopStatus          = cmEvChannelMediaLoopStatus;
    cmChanEvent.cmEvChannelReplace                  = cmEvChannelReplace;
    cmChanEvent.cmEvChannelFlowControlToZero        = cmEvChannelFlowControlToZero;
    cmChanEvent.cmEvChannelMiscCommand              = cmEvChannelMiscCommand;
    cmChanEvent.cmEvChannelTransportCapInd          = cmEvChannelTransportCapInd;
    cmChanEvent.cmEvChannelSetNSAPAddress           = cmEvChannelSetNSAPAddress;
    cmChanEvent.cmEvChannelSetATMVC                 = cmEvChannelSetATMVC;*/
    cmSetChannelEventHandler(hApp,&cmChanEvent,sizeof(SCMCHANEVENT));

    memset (&cmControlEvent,0,sizeof(SCMCONTROLEVENT));
    cmControlEvent.cmEvCallNewChannel               = cmEvCallNewChannel;
    /*cmControlEvent.cmEvCallUserInput                = cmEvCallUserInput;*/
    cmControlEvent.cmEvCallCapabilities             = cmEvCallCapabilities;
/*    cmControlEvent.cmEvCallCapabilities             = cmEvCallCapabilities;
    cmControlEvent.cmEvCallCapabilitiesExt          = cmEvCallCapabilitiesExt;
    cmControlEvent.cmEvCallNewChannel               = cmEvCallNewChannel;
    cmControlEvent.cmEvCallCapabilitiesResponse     = cmEvCallCapabilitiesResponse;
    cmControlEvent.cmEvCallMasterSlaveStatus        = cmEvCallMasterSlaveStatus;
    cmControlEvent.cmEvCallRoundTripDelay           = cmEvCallRoundTripDelay;
    cmControlEvent.cmEvCallUserInput                = cmEvCallUserInput;
    cmControlEvent.cmEvCallRequestMode              = cmEvCallRequestMode;
    cmControlEvent.cmEvCallMiscStatus               = cmEvCallMiscStatus;
    cmControlEvent.cmEvCallControlStateChanged      = cmEvCallControlStateChanged;
    cmControlEvent.cmEvCallMasterSlave              = cmEvCallMasterSlave;
    cmControlEvent.cmEvCallControlMessage           = cmEvCallControlMessage;*/
    cmSetControlEventHandler(hApp,&cmControlEvent,sizeof(SCMCONTROLEVENT));

    memset (&cmProtocolEvent,0,sizeof(SCMPROTOCOLEVENT));
    cmProtocolEvent.hookRecvFrom    = wphookRecvFrom;
    cmProtocolEvent.hookSendTo      = wphookSendTo;
    cmSetProtocolEventHandler(hApp,&cmProtocolEvent,sizeof(SCMPROTOCOLEVENT));

    memset(&cmRasEvent, 0, sizeof(SCMRASEVENT));
    UNUSED_HANDLE(cmRasEvent.cmEvRASConfirm);
    UNUSED_HANDLE(cmRasEvent.cmEvRASReject);
    UNUSED_HANDLE(cmRasEvent.cmEvRASRequest);
    UNUSED_HANDLE(cmRasEvent.cmEvRASTimeout);
    cmRASSetEventHandler(hApp, &cmRasEvent, sizeof(SCMRASEVENT));

    memset(&cmAutoRasEvent, 0, sizeof(SCMAUTORASEVENT));
    UNUSED_HANDLE(cmAutoRasEvent.cmEvAutoRASRequest);
    cmAutoRasEvent.cmEvAutoRASConfirm   = wpcmEvAutoRASConfirm;
    cmAutoRasEvent.cmEvAutoRASReject    = wpcmEvAutoRASReject;
    cmAutoRasEvent.cmEvAutoRASTimeout   = wpcmEvAutoRASTimeout;
    cmAutoRASSetEventHandler(hApp, &cmAutoRasEvent, sizeof(SCMAUTORASEVENT));
/*    ReInitrvwp();*//*make sure there is no msg send to protocol stack*/
    return 0;
}
RVAPI int RVCALLCONV WpSendMessage
(
	unsigned int	msgId,
	unsigned char	callIndex,
	unsigned int	remoteAddr,		/* Remote network address */
	char*		remoteNumber,	/* Remote phone number */
	char*		display,			/* Local display string */
	char*		localNumber		/* Local E.164 number */
)
{
	WrapperMsg	wpmsg;
	WNDCLASS wc;	
	RvInt8		callId = 0;
	memset(&wc,0,sizeof(WNDCLASS));
/*	if(WaitForSingleObject(fileSem,INFINITE) == WAIT_OBJECT_0) 
	{ 
		fprintf(fp,"WpSendMessage()\n");
		ReleaseSemaphore(fileSem,1,NULL);
	}*/
	wc.lpfnWndProc    = wpHandleMsg;
    wc.hInstance      = NULL;
    wc.lpszClassName  = "h323MsgWin";
	RegisterClass(&wc);
    hSWnd = CreateWindow("h323MsgWin", NULL,WS_OVERLAPPED | WS_MINIMIZE,
        0, 0, 0, 0, NULL, NULL, NULL, NULL);

	memset(&wpmsg, 0 ,sizeof(WrapperMsg));
	wpmsg.msgId = msgId;
	switch (msgId)
	{
		case WP_SEND_QUERY_AVA:
			callId = wPGetCallIndex(0);
			if (callId == -1)	/* No call buffer */
			{
				return -1;	
			}
			wpmsg.baseInfo.callIndex = callId;
			wpmsg.baseInfo.remoteIpAddr = remoteAddr;
			strncpy(wpmsg.baseInfo.remoteE164Num, remoteNumber, MAX_E164NUM_LENGTH);
			wpmsg.baseInfo.remoteE164Num[MAX_E164NUM_LENGTH] = '\0';
			strncpy(wpmsg.baseInfo.localE164Num, localNumber, MAX_E164NUM_LENGTH);
			wpmsg.baseInfo.localE164Num[MAX_E164NUM_LENGTH] = '\0';
			strncpy(wpmsg.baseInfo.display, display, MAX_DISPLAY_LENGTH);
			wpmsg.baseInfo.display[MAX_DISPLAY_LENGTH] = '\0';
			break;
			
		case WP_SEND_CONN:
			wpmsg.baseInfo.callIndex = callIndex;
			wpmsg.baseInfo.remoteIpAddr = remoteAddr;
			strncpy(wpmsg.baseInfo.localE164Num, localNumber, MAX_E164NUM_LENGTH);
			wpmsg.baseInfo.localE164Num[MAX_E164NUM_LENGTH] = '\0';
			strncpy(wpmsg.baseInfo.display, display, MAX_DISPLAY_LENGTH);
			wpmsg.baseInfo.display[MAX_DISPLAY_LENGTH] = '\0';
			break;
			
		case WP_SEND_TERM:
			wpmsg.baseInfo.callIndex = callIndex;
			break;
			
		case WP_SEND_AVA:
			wpmsg.baseInfo.callIndex = callIndex;
			break;
			
		case WP_SEND_NOTAVA:
			wpmsg.baseInfo.callIndex = callIndex;
			break;
			
		case WP_SEND_REGISTER:
		case WP_SEND_UNREGISTER:
			break;
			
		case WP_INITIATE_CALL_TRANSFER:
			wpmsg.baseInfo.callIndex = callIndex;
		/*	TRACE("remoteAddr:%x!\n", remoteAddr);*/
			if (remoteAddr)
			{
				sprintf(wpmsg.d.CallTransferInfo.transferToNumber, "%d.%d.%d.%d:%d",
					remoteAddr >> 24, 
					(remoteAddr >> 16) & 0xff,
					(remoteAddr >> 8) & 0xff,
					remoteAddr & 0xff,
					1720);
		/*		TRACE("remoteAddr:%s!\n", wpmsg.d.CallTransferInfo.transferToNumber);*/
			}
			else
			{
				strncpy(wpmsg.d.CallTransferInfo.transferToNumber, remoteNumber, MAX_E164NUM_LENGTH);
			}
			strncpy(wpmsg.baseInfo.localE164Num, localNumber, MAX_E164NUM_LENGTH);
			wpmsg.baseInfo.localE164Num[MAX_E164NUM_LENGTH] = '\0';
			strncpy(wpmsg.baseInfo.display, display, MAX_DISPLAY_LENGTH);
			wpmsg.baseInfo.display[MAX_DISPLAY_LENGTH] = '\0';
			break;
		case WP_SEND_CALL_TRANSFER_SETUP:
			
		case WP_SEND_CALL_FORWARD:
		{
			char tmpIPAddr[40];
			
			wpmsg.baseInfo.callIndex = callIndex;
			if (remoteAddr != 0)
			{
			/*	TRACE("RemoteAddr = %x\n", remoteAddr);*/
				ConvertInt2CharNum(tmpIPAddr,  remoteAddr, 2);
				sprintf(wpmsg.d.CallForwardInfo.ForwardToNumber,
					"TA:%s:%d", tmpIPAddr, H245_SEND_PORT);				
			}
			else
			{
			/*	TRACE("Remote e164 = %s\n", remoteNumber);*/
				sprintf(wpmsg.d.CallForwardInfo.ForwardToNumber,
					"TEL:%s", remoteNumber);
			}
			break;
		}
		
		case WP_SEND_USERINPUT:
			break;
			
		default:
			return -1;
	}
/*	if(WaitForSingleObject(fileSem,INFINITE) == WAIT_OBJECT_0) 
	{ 
		fprintf(fp,"rvwpSend(&wpmsg);--------\n");
		ReleaseSemaphore(fileSem,1,NULL);
	}*/
/*deleted by mxd 2005.1.18 for windows*/
//	rvwpSend(&wpmsg);
	SendMessage(hSWnd,WM_WPMSG,(WPARAM)0,(LPARAM)&wpmsg);
	return callId;
}
 int  wpCallConnectH245Control(unsigned char callIndex)
{
	HCALL hsCall;
	RvInt32 isTunneling = RV_FALSE;

	hsCall = wpCallInfo[callIndex].hsCall;

	cmCallGetParam(hsCall, cmParamH245Tunneling, 0, &isTunneling, NULL);

	/* No 245 connection and tunneling*/
	if (cmCallHasControlSession(hsCall) == 0 && !isTunneling)
	{
	/*	TRACE("No 245 connections and no tunneling\n");*/
		if (cmCallConnectControl(hsCall) < 0)
			return RV_FALSE;
		else
		{
			Sleep(100);	
		/*	TRACE("Connect an H245 control channel ok\n");*/
		}
	}
	return RV_TRUE;
}
RVAPI int RVCALLCONV wpSendUserInputId(unsigned char callIndex, char userInputId)