rasconnection.cpp

这是一个完整的无线通讯工程

/********************************************************************

    filename    :   E:\myjob\WirelessDebug\RasConnection.cpp
    purpose     :   control ras conneciton and get connection status
    version     :   1.0
    author      :   DEPT Jeffrey_Zhang
    created     :	2005/11/15 10:05
    modifyinfo  :   

*********************************************************************/

//RasConnection.cpp

#include "StdAfx.h"
//#include "EDGE_Mobile.h"
#include "RasConnection.h"

CRasConnection _RasConnection;//new CRasConnection;
//extern CEDGE_MobileApp theApp;

CRasConnection::CRasConnection()
{
	m_BConnected = FALSE;
	m_strErrorInfo = _T("");
	//m_hMsghwnd = NULL;
	m_rasconn = NULL;
	m_pThread = NULL;
	if( InitializeRasInterface() )
		return;
}

void CRasConnection::Destroy()
{
	if( m_BConnected )
		RasHangUpEx();
	FreeLibrary(m_hDLLib);
}

CRasConnection::~CRasConnection()
{
	if( m_BConnected )
		RasHangUpEx();
	FreeLibrary(m_hDLLib);
}

BOOL CRasConnection::InitializeRasInterface()
{
	m_hDLLib= LoadLibrary(_T("rasapi32"));
	if(!m_hDLLib)
	{
		::MessageBox(0,"Error in Loading rasapi32.lib file.",
					"Internet Connection Status",MB_ICONERROR);
		return FALSE;
	}
	
	lpfnDllFuncConnstat = (lpfnDllFuncRGCS)GetProcAddress(m_hDLLib,
								"RasGetConnectionStatistics");
	if(!lpfnDllFuncConnstat )
	{
		::MessageBox(0,"Error in Loading RasGetConnectionStatistics funciton.",
					"Internet Connection Status",MB_ICONERROR);
		return FALSE;
	}

	lpfnDllFuncEnumConn = (lpfnDllFuncRENCS)GetProcAddress(m_hDLLib,
								"RasEnumConnectionsA");
	if(!lpfnDllFuncEnumConn )
	{
		::MessageBox(0,"Error in Loading RasEnumConnectionsA funciton.",
					"Internet Connection Status",
					MB_ICONERROR);
		return FALSE;
	}
	return TRUE;
}

BOOL CRasConnection::RasDialupEx(const char* pchLinkName, 
								 const char* pchModemID, 
								 const char* pchSevNomber, /* = _T("#777") */
								 const char* pchUserName,  /* = _T("card") */
								 const char* pchPassWord   /* = _T("card") */ )
{
	DWORD	dwSize = -2;
	DWORD	dwError = -2;

	m_strLinkName = pchLinkName;
	
	if( dwError = RasGetEntryProperties(NULL,NULL,NULL,&dwSize,NULL,NULL) )
	{
		if(dwError != ERROR_BUFFER_TOO_SMALL )
			return FALSE;
	}

	LPRASENTRY	lpRasEntry = (LPRASENTRY)new char[dwSize];
	memset(lpRasEntry,0,dwSize);
	lpRasEntry->dwSize = dwSize;
	strcpy(lpRasEntry->szDeviceType,"modem");			//szDeviceType
	strcpy(lpRasEntry->szDeviceName,pchModemID);			//szDeviceName
	_tcscpy(lpRasEntry->szLocalPhoneNumber, pchSevNomber); //szLocalPhoneNumber 
	//dwfOptions 
	lpRasEntry->dwfOptions = 0x4000000 | RASEO_ModemLights |
							 RASEO_RemoteDefaultGateway |
							 RASEO_SwCompression |
							 RASEO_IpHeaderCompression;

	lpRasEntry->dwFramingProtocol = RASFP_Ppp;
	lpRasEntry->dwfNetProtocols = RASNP_Ip;

	if( dwError = RasSetEntryProperties(NULL,pchLinkName,lpRasEntry,dwSize,NULL,0))
	{
		delete [] lpRasEntry;
		CString	str;
		str.Format("RasSetEntryProperties [%d]\n",dwError);
	//	ADDLOG(str);
		//::MessageBox(0, str, _T("Internet Connection Status"), MB_ICONERROR);
		return FALSE;
	}
	delete [] lpRasEntry;
	
	//Set Dialup parameter
	RASDIALPARAMS	RasDialParams;
	memset (&RasDialParams, 0, sizeof (RASDIALPARAMS));
	RasDialParams.dwSize = sizeof (RASDIALPARAMS);
	_tcscpy (RasDialParams.szEntryName, pchLinkName);
	strcpy(RasDialParams.szUserName, pchUserName);
	strcpy(RasDialParams.szPassword, pchPassWord);

	// Change the connection data.
	if( dwError = RasSetEntryDialParams (NULL, &RasDialParams, FALSE) )
	{
		CString	str;
		str.Format("RasSetEntryDialParams failure [%s][size = %d][%d]", 
					pchLinkName, RasDialParams.dwSize,dwError);
//		ADDLOG(str);
		//::MessageBox(0, str, _T("Internet Connection Status"), MB_ICONERROR);
		return FALSE;
	}

	RASDIALPARAMS	rasparam;
	memset(&rasparam,0,sizeof(RASDIALPARAMS));
	rasparam.dwSize = sizeof(RASDIALPARAMS);
	strcpy(rasparam.szEntryName, pchLinkName);
	strcpy(rasparam.szPhoneNumber, pchSevNomber);
	strcpy(rasparam.szUserName, pchUserName);
	strcpy(rasparam.szPassword, pchPassWord);

	if(	dwError = RasDial( NULL, NULL, &rasparam, 0, RasDialFunc, &m_rasconn ) )
	{
		RasHangUpEx();
		char	szBuf[256];
		memset(szBuf,0,256);
		RasGetErrorString((UINT)dwError,szBuf,256);

		CString	str;
		str.Format("[%d]",dwError);
		str += szBuf;
//		ADDLOG(str);
		//::MessageBox(0, str, _T("Internet Connection Status"), MB_ICONERROR);
		return FALSE;
	}

	m_BConnected = TRUE;
	return TRUE;
}

VOID WINAPI CRasConnection::RasDialFunc(UINT unMsg, 
										RASCONNSTATE rasconnstate,
										DWORD dwError)
{
	//CRasConnection* pRas;
	if(dwError)
	{
		//m_rasconn = NULL;
		char	szBuf[256];
		memset(szBuf,0,256);
		RasGetErrorString((UINT)dwError,szBuf,256);
 		_RasConnection.m_strErrorInfo.Format("[%d]", dwError);
		_RasConnection.m_strErrorInfo += szBuf;
		_RasConnection.RasHangUpEx();
		::SendMessage(_RasConnection.m_hMsghwnd, WM_RAS_ERROR, 0, 0);
		return ;
	}
	int iMsg=0;
	switch(rasconnstate) 
	{
	case RASCS_OpenPort:
		iMsg =  WM_RAS_OPEN;
		break;
	case RASCS_PortOpened:
		iMsg =  WM_RAS_OPENED;
		break;
	case RASCS_ConnectDevice:
		iMsg =  WM_RAS_CONNECT;
		break;
	case RASCS_DeviceConnected:
		iMsg =  WM_RAS_CONNECTED;
		break;
	case RASCS_AllDevicesConnected:
		break;
	case RASCS_Authenticate:
		iMsg =  WM_RAS_AUTHNOTIFY;
		break;
	case RASCS_AuthNotify:
		break;
	case RASCS_AuthRetry:
		break;
	case RASCS_AuthCallback:
		break;
	case RASCS_AuthChangePassword:
		break;
	case RASCS_AuthProject:
		//strcpy(szConnStatus,"认证");
		break;
	case RASCS_AuthLinkSpeed:
		break;
	case RASCS_AuthAck:
		break;
	case RASCS_ReAuthenticate:
		break;
	case RASCS_Authenticated:
		iMsg =  WM_RAS_PASS;		
			//_strErrorInfo.Format("%s", _T("通过"));
			//m_BConnected = TRUE;
			//::SendMessage(_hMsgHwnd, WM_CONNECTINFO, 1, 0);
		break;
	case RASCS_PrepareForCallback:
		break;
	case RASCS_WaitForModemReset:
		break;
	case RASCS_WaitForCallback:
		break;
	case RASCS_Projected:
		break;
	case 8192:
		iMsg = WM_RAS_OK;
		break;
	default:
		break;
	}
	::SendMessage(_RasConnection.m_hMsghwnd, iMsg, 0, 0);
}

UINT CRasConnection::ThreadHangup(LPVOID lpvoid)
{
	CRasConnection *pRas=(CRasConnection*)lpvoid;
	RasHangUp(pRas->m_rasconn);
	pRas->m_BConnected = FALSE;
	pRas->m_rasconn=NULL;

	return 0;
}

BOOL CRasConnection::RasHangUpEx()
{
	m_pThread = AfxBeginThread(ThreadHangup, this);
	WaitForSingleObject(m_pThread->m_hThread, INFINITE);
	RasDeleteEntry(NULL, m_strLinkName);
	m_pThread = NULL;
	return TRUE;
}


BOOL CRasConnection::GetRasStatus(RAS_STATUS* prasStatus, 
								  const char* szModeName/* = NULL */)
{
	try
	{		
		DWORD     lpcb;
		DWORD     lpcConnections;
		RASCONN * pRasConn;
		pRasConn = (LPRASCONN) GlobalAlloc(GPTR, sizeof(RASCONN));
		pRasConn->dwSize = sizeof(RASCONN);
		lpcb = sizeof(RASCONN);
 
		DWORD nRet = lpfnDllFuncEnumConn(pRasConn, &lpcb, &lpcConnections);	

		if( strcmp(pRasConn->szDeviceName, szModeName) != 0 )
			return FALSE;

		if (nRet != 0)
		{
			return FALSE;
		}
		else
		{
			RAS_STATS *lpStatistics;
			lpStatistics= (RAS_STATS *)GlobalAlloc(GPTR, sizeof(RAS_STATS));
			lpStatistics->dwSize=sizeof(RAS_STATS);	
			if(pRasConn->hrasconn)
			{
				prasStatus->strLinkName.Format("%s", pRasConn->szEntryName);
			
				DWORD nR=lpfnDllFuncConnstat(pRasConn->hrasconn,lpStatistics);
				if(nR == ERROR_SUCCESS)
				{
					int iMbs = lpStatistics->dwBytesRcved/(1000*1000);
					int iKbs = (lpStatistics->dwBytesRcved-(1000*1000)*iMbs)/1000;
					int iByte = lpStatistics->dwBytesRcved-(1000*1000)*iMbs-1000*iKbs;					
					prasStatus->strRevBytes.Format("%.3d,%.3d,%.3d", iMbs, iKbs, iByte);

					iMbs = lpStatistics->dwBytesXmited/(1000*1000);
					iKbs = (lpStatistics->dwBytesXmited-(1000*1000)*iMbs)/1000;
					iByte = lpStatistics->dwBytesXmited-(1000*1000)*iMbs-1000*iKbs;
					prasStatus->strSendBytes.Format("%.3d,%.3d,%.3d", iMbs, iKbs, iByte);

					while(prasStatus->strRevBytes[0] == '0' || 
							prasStatus->strRevBytes[0] == ',')
					{
						prasStatus->strRevBytes.Delete(0,1);
						if( prasStatus->strRevBytes.IsEmpty() )
							break;
					}

					while(prasStatus->strSendBytes[0] == '0' || 
							prasStatus->strSendBytes[0] == ',')
					{
						prasStatus->strSendBytes.Delete(0,1);
						if( prasStatus->strSendBytes.IsEmpty() )
							break;
					}

					prasStatus->strSpeed.Format("%d kbps",lpStatistics->dwBps);

					prasStatus->dwDuration = lpStatistics->dwConnectDuration;
					prasStatus->dwRevBytes = lpStatistics->dwBytesRcved;
					prasStatus->dwSendBytes = lpStatistics->dwBytesXmited;

					CString strsec;
					int nSec = lpStatistics->dwConnectDuration/1000;
					nSec %=  60;
					int nMin = lpStatistics->dwConnectDuration/60000;
					nMin %= 60;
					int nHour =lpStatistics->dwConnectDuration/(60000*60);
					nHour %= 24;
					prasStatus->strDuration.Format("%.2d: %.2d: %.2d",nHour,nMin,nSec);

					prasStatus->strRevComp.Format("%d%%",lpStatistics->dwCompressionRatioIn);
					prasStatus->strSendComp .Format("%d%%",lpStatistics->dwCompressionRatioOut);

					prasStatus->strRevFrames.Format("%d",lpStatistics->dwFramesRcved);
					prasStatus->strSendFrames.Format("%d",lpStatistics->dwFramesXmited);
					return TRUE;
				}
				else
				{
					return FALSE;
				}
			}
			else
			{
				return FALSE;
			}
		}
	}
	catch(CException* theException1)
	{
		theException1->Delete();
	}
	return TRUE;
}

BOOL CRasConnection::CheckConnectionStatus()
{
	RASCONNSTATUS	rasstatus;
	ZeroMemory(&rasstatus,sizeof(RASCONNSTATUS));
	rasstatus.dwSize = sizeof(RASCONNSTATUS);
	DWORD	dwret = RasGetConnectStatus(m_rasconn,&rasstatus);
	
	if(6 == dwret || ERROR_PORT_NOT_CONNECTED == dwret || rasstatus.rasconnstate == RASCS_Disconnected)
	{
		return FALSE;
	}
	return TRUE;
}

void CRasConnection::Test()
{
	//::SendMessage(_RasConnection.m_hMsghwnd, WM_RAS_PASS, 0, 0);
}