예제 #1
0
BOOL CHttpRequest::IsConnected()
{
	ODS(_T("XFILTER.EXE: Internet Check Connected..."));

    RASCONN			lpRasConn;
	RASCONNSTATUS	rasStatus;     
	DWORD			cbBuf = 0;     
	DWORD			cConn = 0;     
	DWORD			dwRet = 0; 
	cbBuf				= sizeof(RASCONN);
	lpRasConn.dwSize	= sizeof(RASCONN );
	dwRet = RasEnumConnections(&lpRasConn, &cbBuf, &cConn );
	if ( dwRet != 0 )   
		return FALSE;
	else
	{
		rasStatus.dwSize = sizeof(RASCONNSTATUS);
		RasGetConnectStatus(lpRasConn.hrasconn,&rasStatus);
		if (rasStatus.rasconnstate==RASCS_Connected)
			return TRUE;
		else
			return FALSE;
	}
	return TRUE;
}
예제 #2
0
void CScheduler::HangUpConnection()
{
	DWORD dwCb = sizeof( RASCONN );
	DWORD dwConnections = 0;
	RASCONN* lpRasConn = NULL;
	LPRASCONNSTATUS RasConStatus = 0;

	for (;;)
	{
		// Free the memory if necessary.
		if ( lpRasConn != NULL )
		{
			HeapFree( GetProcessHeap(), 0, lpRasConn );
			lpRasConn = NULL;
		}

		// Allocate the size needed for the RAS structure.
		lpRasConn = (RASCONN*)HeapAlloc( GetProcessHeap(), 0, dwCb );
		if ( ! lpRasConn )
			// Out of memory
			return;

		// Set the first structure size for version checking purposes.
		lpRasConn->dwSize = sizeof( RASCONN );

		// Call the RAS API 
		DWORD ret = RasEnumConnections( lpRasConn, &dwCb, &dwConnections );
		if ( ret == 0 )
			// Ok
			break;
		if ( ret == ERROR_NOT_ENOUGH_MEMORY )
			// Re-allocate more memory
			continue;
		// Error
		return;
	}

	DWORD loop = 0;
	for ( DWORD i = 0; i < dwConnections; ++i ) // Loop through all current connections
	{
		RasHangUp( lpRasConn[i].hrasconn ); // Hang up the connection
		while( ( RasGetConnectStatus( lpRasConn[i].hrasconn,RasConStatus ) || ( loop > 10 ) ) )
		{
			// Loop until the connection handle is invalid, or 3 seconds have passed
			Sleep( 300 );
			loop++;
		}
	}

	// Free the memory if necessary.
	if ( lpRasConn != NULL )
	{
		HeapFree( GetProcessHeap(), 0, lpRasConn );
		lpRasConn = NULL;
	}
}
예제 #3
0
BOOL findCurrentlyConnected(BOOL* foundOut) {
    DWORD dwCb = 0;
    DWORD dwRet = ERROR_SUCCESS;
    DWORD dwConnections = 0;
    LPRASCONN lpRasConn = NULL;

    // Call RasEnumConnections with lpRasConn = NULL. dwCb is returned with the required buffer size and
    // a return code of ERROR_BUFFER_TOO_SMALL
    dwRet = RasEnumConnections(lpRasConn, &dwCb, &dwConnections);

    if (dwRet == ERROR_BUFFER_TOO_SMALL) {
        // Allocate the memory needed for the array of RAS structure(s).
        lpRasConn = (LPRASCONN) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwCb);
        if (lpRasConn == NULL){
            fwprintf(stderr, L"HeapAlloc failed!\n");
            return FALSE;
        }
        // The first RASCONN structure in the array must contain the RASCONN structure size
        lpRasConn[0].dwSize = sizeof(RASCONN);

        // Call RasEnumConnections to enumerate active connections
        dwRet = RasEnumConnections(lpRasConn, &dwCb, &dwConnections);

        // If successful, print the names of the active connections.
        if (ERROR_SUCCESS == dwRet){
            for (DWORD i = 0; i < dwConnections; i++) {
                if (lstrcmp(ENTRY_NAME_W, lpRasConn[i].szEntryName) == 0) {
                    *foundOut = TRUE;
                    break;
                };
            }
        }

        //Deallocate memory for the connection buffer
        HeapFree(GetProcessHeap(), 0, lpRasConn);
        lpRasConn = NULL;
        return TRUE;
    }

    return TRUE;
}
예제 #4
0
// Figure out which Dial-Up or VPN connection is active; in a normal LAN connection, this should
// return NULL
LPTSTR FindActiveConnection() {
    DWORD dwCb = sizeof(RASCONN);
    DWORD dwErr = ERROR_SUCCESS;
    DWORD dwRetries = 5;
    DWORD dwConnections = 0;
    RASCONN* lpRasConn = NULL;
    RASCONNSTATUS rasconnstatus;
    rasconnstatus.dwSize = sizeof(RASCONNSTATUS);

    //
    // Loop through in case the information from RAS changes between calls.
    //
    while (dwRetries--) {
        // If the memory is allocated, free it.
        if (NULL != lpRasConn) {
            HeapFree(GetProcessHeap(), 0, lpRasConn);
            lpRasConn = NULL;
        }

        // Allocate the size needed for the RAS structure.
        lpRasConn = (RASCONN*)HeapAlloc(GetProcessHeap(), 0, dwCb);
        if (NULL == lpRasConn) {
            dwErr = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

        // Set the structure size for version checking purposes.
        lpRasConn->dwSize = sizeof(RASCONN);

        // Call the RAS API then exit the loop if we are successful or an unknown
        // error occurs.
        dwErr = RasEnumConnections(lpRasConn, &dwCb, &dwConnections);
        if (ERROR_INSUFFICIENT_BUFFER != dwErr) {
            break;
        }
    }
    //
    // In the success case, print the names of the connections.
    //
    if (ERROR_SUCCESS == dwErr) {
        DWORD i;
        for (i = 0; i < dwConnections; i++) {
            RasGetConnectStatus(lpRasConn[i].hrasconn, &rasconnstatus);
            if (rasconnstatus.rasconnstate == RASCS_Connected){
                return lpRasConn[i].szEntryName;
            }

        }
    }
    return NULL; // Couldn't find an active dial-up/VPN connection; return NULL
}
예제 #5
0
BOOL CAutoDialDlg::AutoCheck()
{
	m_csStatus = "";
	if (m_csEntryName.IsEmpty()){
		m_csStatus = "Empty EntryName!";
		return FALSE;
	}

	RASCONN		rasconn;   
	DWORD		dwConnCount(0);   
	DWORD		dwSize(0);
	DWORD		dwRet(0);   

	rasconn.dwSize	= 0x19c;//sizeof(RASCONN);   
	dwSize			= rasconn.dwSize;   
	dwRet			= RasEnumConnections(&rasconn, &dwSize, &dwConnCount);	
	if (ERROR_SUCCESS != dwRet){
		m_csStatus.Format("RasEnumConn Fail:%d", dwRet);
		return FALSE;
	}

	if (dwConnCount > 0){//有连接直接退出
		m_csStatus.Format("Connected");
		return TRUE;
		//RasHangUp(rasconn.hrasconn);   
	}

	//没有连接
	//DWORD			dwConn(0);
	//RASDIALPARAMS	stRasParam;
	//BOOL			bHasPw;
	//stRasParam.dwSize = sizeof(RASDIALPARAMS);
	//strcpy_s(stRasParam.szEntryName, RAS_MaxEntryName, m_csEntryName.GetBuffer());
	//
	//dwRet = RasGetEntryDialParams(NULL, &stRasParam, &bHasPw);
	//if (ERROR_SUCCESS != dwRet){
	//	m_csStatus.Format("GetEntry Fail:%d", dwRet);
	//	return FALSE;
	//}

	//HRASCONN hRasConn(NULL);
	//dwRet = RasDial(NULL, NULL, &stRasParam, 0, NULL, &hRasConn);
	//if (ERROR_SUCCESS != dwRet){
	//	m_csStatus.Format("RasDial Fail:%d", dwRet);
	//	return FALSE;
	//}

	WinExec(m_csCmdLine, SW_HIDE);
	
	return FALSE;
}
예제 #6
0
파일: AdvRas.cpp 프로젝트: 68a/SmartDialer
int GetCurrentConnections(BYTE (&RasConnData)[10*sizeof(RASCONN)])
{
    // Get the current list of connections

    //BYTE        RasConnData[10*sizeof(RASCONN)];
    LPRASCONN pRasConn = (LPRASCONN) RasConnData;

    pRasConn->dwSize = sizeof(RASCONN);
    DWORD Connections = 0;
    DWORD cb = sizeof(RasConnData);
    if ( RasEnumConnections(pRasConn, &cb, &Connections)) {

        return 0;
    }
    return Connections;
}
예제 #7
0
파일: watcher.c 프로젝트: samoylenko/misc
int main( int argc, char *argv )
{
	LPRASCONN lpRasConn;
	int nRet, i;
	DWORD lpcb, lpcConnections;
	HWND dw;
	HDC hdc;

	lpRasConn = ( LPRASCONN ) GlobalAlloc(GPTR, sizeof(RASCONN));
	lpRasConn->dwSize = sizeof( RASCONN );
 
	nRet = RasEnumConnections( lpRasConn, &lpcb, &lpcConnections );
	if( nRet != 0 )
	{
		printf( "RasEnumConnections failed: Error = %d", nRet );
	}
	else
	{
    		printf( "The following RAS connections are currently active\n\n" );
    		for( i = 0; i < lpcConnections; i++ )
    		{
        		printf( "Entry name: %s\n", lpRasConn->szEntryName );
        		lpRasConn++;
    		}

		if( lpcConnections < 1 )
		{
			printf( "error! no connection!" );

			dw = FindWindow( "#32769", NULL );
			hdc = GetDC( dw );

			TextOut( hdc, 15, 15, "PLEASE PLUG THE NETWORK CABLE BACK IN!", 28 );

			for( i = 0x250; i < 0x2500; i += 0x100 )
			{
				Beep( i, 10 );
			}

			ReleaseDC( dw, hdc );

		}
	
	}
	return 0;
}
예제 #8
0
파일: ocamlras.c 프로젝트: kign/inet-lab
value_t c_win32_iterate_connections (
   value_t iterator ) 
{
   RASCONN 		* lpRasConn;
   DWORD     		lpcb, lpcConnections;
   unsigned int		nRet, i;
   CAMLparam1 ( iterator );
   CAMLlocal1 ( name );
   
#ifdef WRAS_EMULATION
   lpRasConn = calloc ( 1, sizeof(RASCONN));
#else   
   lpRasConn = (LPRASCONN) GlobalAlloc(GPTR, sizeof(RASCONN));
#endif 
   lpRasConn->dwSize = sizeof(RASCONN);
   
   lpcb = sizeof(RASCONN);
   nRet = RasEnumConnections(lpRasConn, &lpcb, &lpcConnections);

   for ( i = 0; i < lpcConnections; i ++ ) 
   {      
      if ( debug_print )
	 printf ( "Processing connection %s 0x%08x\n",
		  lpRasConn[i].szEntryName,
		  (unsigned) lpRasConn[i].hrasconn );
      name = copy_string ( lpRasConn[i].szEntryName );
      
      callback3 ( iterator, name,
		  Val_int (LOWORD(lpRasConn[i].hrasconn)),
		  Val_int (HIWORD(lpRasConn[i].hrasconn)));
   }

#ifdef WRAS_EMULATION
   free ( lpRasConn );
#else   
   GlobalFree ( lpRasConn );
#endif

   CAMLreturn (Val_int ( lpcConnections ));
   return 0; /* dummy, to shut down warning */
}
bool CHttpReqSocket::IsInternetConnected ()
{
	return true;	// MCH 17.09.04 (what the heck...)

	//////////////////////////////////////////////////////////////

	DWORD dwState;
	InternetGetConnectedState (&dwState, 0);

	if (dwState & INTERNET_CONNECTION_LAN)
		return true;
	else
	{
		bool bConnected = false;
		RASCONN rasConn;
		rasConn.dwSize = sizeof (RASCONN);
		DWORD dwBufSize = sizeof (RASCONN);
		DWORD dwNumConns;
		if (RasEnumConnections (&rasConn, &dwBufSize, &dwNumConns) == 0)
		{
			// RasEnumConnections succeeded
			RASCONNSTATUS rasConnStatus;
			for (UINT i = 0; i < dwNumConns; i++)
			{
				rasConnStatus.dwSize = sizeof (RASCONNSTATUS);
				RasGetConnectStatus (rasConn.hrasconn, &rasConnStatus);
				if (rasConnStatus.rasconnstate == RASCS_Connected)
				{
					bConnected = true;
					break;
				}
			}
		}

		return bConnected;
	}
}
예제 #10
0
static DWORD ShutdownNow(BYTE shutdownType)
{
	DWORD dwErrCode = ERROR_SUCCESS;
	switch (shutdownType) {
	case SDSDT_CLOSEMIRANDA:
		if (!Miranda_Terminated()) {
			/* waiting for short until ready (but not too long...) */
			DWORD dwLastTickCount = GetTickCount();
			while (!CallService(MS_SYSTEM_OKTOEXIT, 0, 0)) {
				/* infinite loop protection (max 5 sec) */
				if (GetTickCount() - dwLastTickCount >= 5000) { /* wraparound works */
					OutputDebugStringA("Timeout (5 sec)\n"); /* tell others, all ascii */
					break;
				}
				SleepEx(1000, TRUE);
				if (Miranda_Terminated()) break; /* someone else did it */
				OutputDebugStringA("Not ready to exit. Waiting...\n"); /* tell others, all ascii */
			}
			/* shutdown service must be called from main thread anyway */
			if (!DestroyWindow(pcli->hwndContactList))
				dwErrCode = GetLastError();
		}
		break;

	case SDSDT_SETMIRANDAOFFLINE:
		/* set global status mode to offline (is remembered by Miranda on exit) */
		CallService(MS_CLIST_SETSTATUSMODE, (WPARAM)ID_STATUS_OFFLINE, 0);
		break;

	case SDSDT_STANDBY:
	case SDSDT_HIBERNATE:
		WinNT_SetPrivilege(SE_SHUTDOWN_NAME, TRUE);
		if (!SetSystemPowerState(shutdownType == SDSDT_STANDBY, TRUE))
			dwErrCode = GetLastError();
		WinNT_SetPrivilege(SE_SHUTDOWN_NAME, FALSE);
		break;

	case SDSDT_LOCKWORKSTATION:
		if (!IsWorkstationLocked())
			dwErrCode = GetLastError();
		break;

	case SDSDT_CLOSERASCONNECTIONS:
		ShutdownNow(SDSDT_SETMIRANDAOFFLINE); /* set Miranda offline */
		/* hang up all ras connections */
		{
			DWORD dwRetries;
			RASCONNSTATUS rcs;
			DWORD dw, dwLastTickCount;

			DWORD dwConnSize = sizeof(RASCONN);
			DWORD dwConnItems = 0;
			RASCONN *paConn = (RASCONN*)mir_alloc(dwConnSize);
			dwErrCode = ERROR_NOT_ENOUGH_MEMORY;
			if (paConn != NULL) {
				for (dwRetries = 5; dwRetries != 0; dwRetries--) { /* prevent infinite loop (rare) */
					memset(paConn, 0, dwConnSize);
					paConn[0].dwSize = sizeof(RASCONN);
					dwErrCode = RasEnumConnections(paConn, &dwConnSize, &dwConnItems);
					if (dwErrCode != ERROR_BUFFER_TOO_SMALL) break;
					RASCONN *paConnBuf = (RASCONN*)mir_realloc(paConn, dwConnSize);
					if (paConnBuf == NULL) {
						mir_free(paConn);
						paConn = NULL;
						dwErrCode = ERROR_NOT_ENOUGH_MEMORY;
						break;
					}
					paConn = paConnBuf;
				}
				if (dwErrCode == ERROR_SUCCESS || dwErrCode == ERROR_BUFFER_TOO_SMALL) {
					for (dw = 0; dw < dwConnItems; ++dw) {
						if (dwErrCode) {
							if (RasHangUp(paConn[dw].hrasconn))
								paConn[dw].hrasconn = NULL; /* do not wait for on error */
						}
						else {
							dwErrCode = RasHangUp(paConn[dw].hrasconn);
							if (!dwErrCode) paConn[dw].hrasconn = NULL; /* do not wait for on error */
						}
					}
					/* RAS does not allow to quit directly after HangUp (see docs) */
					dwLastTickCount = GetTickCount();
					memset(&rcs, 0, sizeof(RASCONNSTATUS));
					rcs.dwSize = sizeof(RASCONNSTATUS);
					for (dw = 0; dw < dwConnItems; ++dw) {
						if (paConn[dw].hrasconn != NULL) {
							while (RasGetConnectStatus(paConn[dw].hrasconn, &rcs) != ERROR_INVALID_HANDLE) {
								Sleep(0); /* give rest of time silce to other threads with equal priority */
								/* infinite loop protection (3000ms defined in docs) */
								dwRetries = GetTickCount();
								if (dwRetries - dwLastTickCount > 3000)
									break; /* wraparound works */
							}
						}
					}
				}
				mir_free(paConn); /* does NULL check */
			}
		}
		/* set Miranda to offline again, to remain offline with reconnection plugins */
		ShutdownNow(SDSDT_SETMIRANDAOFFLINE);
		break;

	case SDSDT_REBOOT:
	case SDSDT_SHUTDOWN:
		if (GetSystemMetrics(SM_SHUTTINGDOWN)) { /* Win2000+, 0 on error */
			dwErrCode = ERROR_SHUTDOWN_IN_PROGRESS;
			break;
		}
		/* WinNT4/2000/XP */
		{
			WinNT_SetPrivilege(SE_SHUTDOWN_NAME, TRUE);

			/* does not send out WM_ENDSESSION messages, so we do it manually to
			* give the applications the chance to save their data */
			WinNT_SetPrivilege(SE_TCB_NAME, TRUE); /* for BSM_ALLDESKTOPS */
			BroadcastEndSession(BSM_APPLICATIONS | BSM_ALLDESKTOPS, ENDSESSION_CLOSEAPP); /* app should close itself */
			WinNT_SetPrivilege(SE_TCB_NAME, FALSE);

			if (!InitiateSystemShutdownEx(NULL, TranslateT("AutoShutdown"), 0, TRUE, shutdownType == SDSDT_REBOOT, SHTDN_REASON_MAJOR_OTHER | SHTDN_REASON_MINOR_OTHER | SHTDN_REASON_FLAG_PLANNED))
				dwErrCode = GetLastError();

			/* cleanly close Miranda */
			if (!dwErrCode) ShutdownNow(SDSDT_CLOSEMIRANDA);
			break;
		}
		/* fall through for Win9x */
	case SDSDT_LOGOFF:
		{
			UINT flags;
			switch (shutdownType) {
			case SDSDT_LOGOFF: flags = EWX_LOGOFF; break;
			case SDSDT_REBOOT: flags = EWX_REBOOT; break;
			default:           flags = EWX_SHUTDOWN | EWX_POWEROFF;
			}
			if (shutdownType == SDSDT_LOGOFF && !IsWorkstationLocked())
				flags |= EWX_FORCEIFHUNG; /* only considered for WM_ENDSESSION messages */
			else
				flags |= EWX_FORCE; /* must be used when workstation locked */

			if (flags & EWX_FORCE) {
				/* EWX_FORCE does not send out WM_ENDSESSION messages, so we do it
				* manually to give the applications the chance to save their data */
				BroadcastEndSession(BSM_APPLICATIONS, (shutdownType == SDSDT_LOGOFF) ? ENDSESSION_LOGOFF : 0);

				/* Windows Me/98/95 (msdn): Because of the design of the shell,
				* calling ExitWindowsEx with EWX_FORCE fails to completely log off
				* the user (the system terminates the applications and displays the
				* Enter Windows Password dialog box, however, the user's desktop remains.)
				* To log off the user forcibly, terminate the Explorer process before calling
				* ExitWindowsEx with EWX_LOGOFF and EWX_FORCE. */
			}
			if (!ExitWindowsEx(flags, SHTDN_REASON_MAJOR_OTHER | SHTDN_REASON_MINOR_OTHER | SHTDN_REASON_FLAG_PLANNED))
				dwErrCode = GetLastError();
			/* cleanly close Miranda */
			if (!dwErrCode)
				ShutdownNow(SDSDT_CLOSEMIRANDA);
		}
		break;
	}
	return dwErrCode;
}
int __cdecl main(void)
{
	DWORD		nRet = 0;
	LPRASCONN	lpRasConn = NULL;
    LPRASCONN	lpTempRasConn = NULL;
	DWORD		cb = sizeof(RASCONN);
	DWORD		cConnections = 0;
    RAS_STATS	*lpStatistics = NULL;
    BOOL        fSuccess = FALSE;
    DWORD       i = 0;
    TCHAR       szTempBuf[256] = {0};

	// Allocate buffer with default value
	lpRasConn = (LPRASCONN)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cb);
	if (NULL == lpRasConn)
	{
		printf("HeapAlloc failed.\n");
		return ERROR_OUTOFMEMORY;
	}

	lpRasConn->dwSize = sizeof(RASCONN);

	// Call RasEnumConnections to obtain the handle of the current active RAS connection
	nRet = RasEnumConnections(lpRasConn, &cb, &cConnections);
	
    switch (nRet)
    {
    case ERROR_BUFFER_TOO_SMALL:
        if (HeapFree(GetProcessHeap(), 0, (LPVOID)lpRasConn))
        {

            lpRasConn = (LPRASCONN)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cb);
	        if (NULL == lpRasConn)
	        {
		        printf("HeapAlloc failed.\n");
		        return ERROR_OUTOFMEMORY;
	        }

	        lpRasConn->dwSize = sizeof(RASCONN);

            nRet = RasEnumConnections(lpRasConn, &cb, &cConnections);
            if (ERROR_SUCCESS == nRet)
            {
                fSuccess = TRUE;
            }
            else
            {
		        printf("RasEnumConnections failed: Error = %d\n", nRet);
                goto done;
            }
        }
        else
        {
            printf("HeapFree failed.\n");
            return GetLastError();
        }
        break;

    case ERROR_SUCCESS:
            fSuccess = TRUE;
            break;

    default:
		printf("RasEnumConnections failed: Error = %d\n", nRet);
        goto done;
        break;
    }

    if (fSuccess)
    {
	    // Allocate buffer to obtain the RAS statistics
	    lpStatistics = (RAS_STATS*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RAS_STATS));

	    if (NULL == lpStatistics)
	    {
		    printf("HeapAlloc failed.\n");
		    goto done;
	    }

        lpTempRasConn = lpRasConn;
        for (i = 0; i < cConnections; i++)
        {
            ZeroMemory(lpStatistics, sizeof(RAS_STATS));
	        lpStatistics->dwSize = sizeof(RAS_STATS);

	        // Call RasGetConnectionStatistics
	        nRet = RasGetConnectionStatistics(lpTempRasConn->hrasconn, lpStatistics);
	        if(ERROR_SUCCESS != nRet) // RasGetConnectionStatistics returned an error
	        {
		        printf("RasGetConnectionStatistics failed: Error = %d\n", nRet);
                goto done;
	        }

            
	        
            // Print the results obtained
	        StringCchPrintf(szTempBuf, CELEMS(szTempBuf), "Statistics for %s connection\n\n", lpTempRasConn->szEntryName);
            printf(szTempBuf);
            	
	        printf("Bytes Xmited\t\t\t%d\n", lpStatistics->dwBytesXmited);
	        printf("Bytes Received\t\t\t%d\n", lpStatistics->dwBytesRcved);
	        printf("Frames Xmited\t\t\t%d\n", lpStatistics->dwFramesXmited);
	        printf("Frames Received\t\t\t%d\n", lpStatistics->dwFramesRcved);
	        printf("Crc Error\t\t\t%d\n", lpStatistics->dwCrcErr);
	        printf("Timeout Error\t\t\t%d\n", lpStatistics->dwTimeoutErr);
	        printf("Alignment Error\t\t\t%d\n", lpStatistics->dwAlignmentErr);
	        printf("Hardware Overrun Error\t\t%d\n", lpStatistics->dwHardwareOverrunErr);
	        printf("Framing Error\t\t\t%d\n", lpStatistics->dwFramingErr);
	        printf("Buffer Overrun Error\t\t%d\n", lpStatistics->dwBufferOverrunErr);
	        printf("Compression Ratio [In]\t\t%d\n", lpStatistics->dwCompressionRatioIn);
	        printf("Compression Ratio [Out]\t\t%d\n", lpStatistics->dwCompressionRatioOut);
	        printf("Baud Rate [bps]\t\t\t%d\n", lpStatistics->dwBps);
	        printf("Connection Duration [mili sec]\t%d\n", lpStatistics->dwConnectDuration);
            lpTempRasConn++;
        }

        nRet = ERROR_SUCCESS;
    }

done:
	// Clean up
	if (lpRasConn)
    {
        HeapFree(GetProcessHeap(), 0, (LPVOID)lpRasConn);
    }

    if (lpStatistics)
    {
	    HeapFree(GetProcessHeap(), 0, (LPVOID)lpStatistics);
    }
	
	return (int)nRet;
}