/*****************************************************************************/ /** Microsoft LAN Manager **/ /** Copyright (C) Microsoft Corp., 1992 **/ /*****************************************************************************/ //*** // File Name: util.c // // Function: miscellaneous supervisor support procedures // // History: // // 05/21/92 Stefan Solomon - Original Version 1.0 //*** #include "ddm.h" #include "util.h" #include "isdn.h" #include "objects.h" #include "rasmanif.h" #include "handlers.h" #include #include #include #include #include #define INCL_HOSTWIRE #include #include "rassrvr.h" #include "raserror.h" #include "winsock2.h" #include "rtinfo.h" #define net_long(x) (((((unsigned long)(x))&0xffL)<<24) | \ ((((unsigned long)(x))&0xff00L)<<8) | \ ((((unsigned long)(x))&0xff0000L)>>8) | \ ((((unsigned long)(x))&0xff000000L)>>24)) //** // // Call: ConvertStringToIpxAddress // // Returns: None // // Description: // VOID ConvertStringToIpxAddress( IN WCHAR* pwchIpxAddress, OUT BYTE * bIpxAddress ) { DWORD i; WCHAR wChar[3]; for(i=0; i<4; i++) { wChar[0] = pwchIpxAddress[i*2]; wChar[1] = pwchIpxAddress[(i*2)+1]; wChar[2] = (WCHAR)NULL; bIpxAddress[i] = (BYTE)wcstol( wChar, NULL, 16 ); } // // Skip over the . // for(i=4; i<10; i++) { wChar[0] = pwchIpxAddress[(i*2)+1]; wChar[1] = pwchIpxAddress[(i*2)+2]; wChar[2] = (WCHAR)NULL; bIpxAddress[i] = (BYTE)wcstol( wChar, NULL, 16 ); } } //** // // Call: ConvertStringToIpAddress // // Returns: None // // Description: Convert caller's a.b.c.d IP address string to the // big-endian (Motorola format) numeric equivalent. // VOID ConvertStringToIpAddress( IN WCHAR * pwchIpAddress, OUT DWORD * lpdwIpAddress ) { INT i; LONG lResult = 0; WCHAR* pwch = pwchIpAddress; *lpdwIpAddress = 0; for (i = 1; i <= 4; ++i) { LONG lField = _wtol( pwch ); if (lField > 255) return; lResult = (lResult << 8) + lField; while (*pwch >= L'0' && *pwch <= L'9') pwch++; if (i < 4 && *pwch != L'.') return; pwch++; } *lpdwIpAddress = net_long(lResult); } //** // // Call: ConvertIpAddressToString // // Returns: None // // Description: Converts 'ipaddr' to a string in the a.b.c.d form and // returns same in caller's 'pwszIpAddress' buffer. // The buffer should be at least 16 wide characters long. // VOID ConvertIpAddressToString( IN DWORD dwIpAddress, IN LPWSTR pwszIpAddress ) { WCHAR wszBuf[ 3 + 1 ]; LONG lNetIpaddr = net_long( dwIpAddress ); LONG lA = (lNetIpaddr & 0xFF000000) >> 24; LONG lB = (lNetIpaddr & 0x00FF0000) >> 16; LONG lC = (lNetIpaddr & 0x0000FF00) >> 8; LONG lD = (lNetIpaddr & 0x000000FF); _ltow( lA, wszBuf, 10 ); wcscpy( pwszIpAddress, wszBuf ); wcscat( pwszIpAddress, L"." ); _ltow( lB, wszBuf, 10 ); wcscat( pwszIpAddress, wszBuf ); wcscat( pwszIpAddress, L"." ); _ltow( lC, wszBuf, 10 ); wcscat( pwszIpAddress, wszBuf ); wcscat( pwszIpAddress, L"." ); _ltow( lD, wszBuf, 10 ); wcscat( pwszIpAddress, wszBuf ); } //** // // Call: ConvertIpxAddressToString // // Returns: None // // Description: // VOID ConvertIpxAddressToString( IN PBYTE bIpxAddress, IN LPWSTR pwszIpxAddress ) { wsprintf( pwszIpxAddress, TEXT("%2.2X%2.2X%2.2X%2.2X.%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X"), bIpxAddress[0],bIpxAddress[1],bIpxAddress[2],bIpxAddress[3], bIpxAddress[4],bIpxAddress[5],bIpxAddress[6],bIpxAddress[7], bIpxAddress[8],bIpxAddress[9] ); } //** // // Call: ConvertAtAddressToString // // Returns: NO_ERROR - Success // Non-zero returns - Failure // // Description: // VOID ConvertAtAddressToString( IN DWORD dwAtAddress, IN LPWSTR pwszAtAddress ) { WCHAR wszBuf[ 5 + 1 ]; LONG lA = (dwAtAddress & 0xFFFF0000) >> 16; LONG lB = (dwAtAddress & 0x0000FFFF); _ltow( lA, wszBuf, 10 ); wcscpy( pwszAtAddress, wszBuf ); wcscat( pwszAtAddress, L"." ); _ltow( lB, wszBuf, 10 ); wcscat( pwszAtAddress, wszBuf ); return; } //** // // Call: GetRasConnection0Data // // Returns: NO_ERROR - Success // Non-zero returns - Failure // // Description: Given a pointer to a CONNECTION_OBJECT structure will extract // all relevent information and insert it into a RAS_CONNECTION_0 // structure. // DWORD GetRasiConnection0Data( IN PCONNECTION_OBJECT pConnObj, OUT PRASI_CONNECTION_0 pRasConnection0 ) { pRasConnection0->dwConnection = PtrToUlong(pConnObj->hConnection); pRasConnection0->dwInterface = PtrToUlong(pConnObj->hDIMInterface); pRasConnection0->dwInterfaceType = pConnObj->InterfaceType; wcscpy( pRasConnection0->wszInterfaceName, pConnObj->wchInterfaceName ); wcscpy( pRasConnection0->wszUserName, pConnObj->wchUserName ); wcscpy( pRasConnection0->wszLogonDomain, pConnObj->wchDomainName ); MultiByteToWideChar( CP_ACP, 0, pConnObj->bComputerName, -1, pRasConnection0->wszRemoteComputer, NETBIOS_NAME_LEN+1 ); pRasConnection0->dwConnectDuration = GetActiveTimeInSeconds( &(pConnObj->qwActiveTime) ); pRasConnection0->dwConnectionFlags = ( pConnObj->fFlags & CONN_OBJ_MESSENGER_PRESENT ) ? RAS_FLAGS_MESSENGER_PRESENT : 0; if ( pConnObj->fFlags & CONN_OBJ_IS_PPP ) { pRasConnection0->dwConnectionFlags |= RAS_FLAGS_PPP_CONNECTION; } if(pConnObj->fFlags & CONN_OBJ_QUARANTINE_PRESENT) { pRasConnection0->dwConnectionFlags |= RAS_FLAGS_QUARANTINE_PRESENT; } return( NO_ERROR ); } //** // // Call: GetRasConnection1Data // // Returns: NO_ERROR - Success // Non-zero returns - Failure // // Description: Given a pointer to a CONNECTION_OBJECT structure will extract // all relevent information and insert it into a RAS_CONNECTION_1 // structure. // DWORD GetRasiConnection1Data( IN PCONNECTION_OBJECT pConnObj, OUT PRASI_CONNECTION_1 pRasConnection1 ) { BYTE buffer[sizeof(RAS_STATISTICS) + (MAX_STATISTICS_EX * sizeof (ULONG))]; RAS_STATISTICS *pStats = (RAS_STATISTICS *)buffer; DWORD dwSize = sizeof (buffer); DWORD dwRetCode; pRasConnection1->dwConnection = PtrToUlong(pConnObj->hConnection); pRasConnection1->dwInterface = PtrToUlong(pConnObj->hDIMInterface); dwRetCode = RasBundleGetStatisticsEx(NULL, (HPORT)pConnObj->hPort, (PBYTE)pStats, &dwSize ); if ( dwRetCode != NO_ERROR ) { return( dwRetCode ); } pRasConnection1->PppInfo.nbf.dwError = pConnObj->PppProjectionResult.nbf.dwError; if ( pRasConnection1->PppInfo.nbf.dwError == NO_ERROR ) { wcscpy( pRasConnection1->PppInfo.nbf.wszWksta, pConnObj->PppProjectionResult.nbf.wszWksta ); } else { pRasConnection1->PppInfo.nbf.wszWksta[0] = (WCHAR)NULL; } pRasConnection1->PppInfo.ip.dwError = pConnObj->PppProjectionResult.ip.dwError; if ( pRasConnection1->PppInfo.ip.dwError == NO_ERROR ) { ConvertIpAddressToString( pConnObj->PppProjectionResult.ip.dwLocalAddress, pRasConnection1->PppInfo.ip.wszAddress ); ConvertIpAddressToString( pConnObj->PppProjectionResult.ip.dwRemoteAddress, pRasConnection1->PppInfo.ip.wszRemoteAddress ); } else { pRasConnection1->PppInfo.ip.wszAddress[0] = (WCHAR)NULL; pRasConnection1->PppInfo.ip.wszRemoteAddress[0] = (WCHAR)NULL; } pRasConnection1->PppInfo.ipx.dwError = pConnObj->PppProjectionResult.ipx.dwError; if ( pRasConnection1->PppInfo.ipx.dwError == NO_ERROR ) { ConvertIpxAddressToString( ( pConnObj->InterfaceType == ROUTER_IF_TYPE_CLIENT ) ? pConnObj->PppProjectionResult.ipx.bRemoteAddress : pConnObj->PppProjectionResult.ipx.bLocalAddress, pRasConnection1->PppInfo.ipx.wszAddress ); } else { pRasConnection1->PppInfo.ipx.wszAddress[0] = (WCHAR)NULL; } pRasConnection1->PppInfo.at.dwError = pConnObj->PppProjectionResult.at.dwError; if ( pRasConnection1->PppInfo.at.dwError == NO_ERROR ) { ConvertAtAddressToString( ( pConnObj->InterfaceType == ROUTER_IF_TYPE_CLIENT ) ? pConnObj->PppProjectionResult.at.dwRemoteAddress : pConnObj->PppProjectionResult.at.dwLocalAddress, pRasConnection1->PppInfo.at.wszAddress ); } else { pRasConnection1->PppInfo.at.wszAddress[0] = (WCHAR)NULL; } pRasConnection1->dwBytesXmited = pStats->S_Statistics[BYTES_XMITED]; pRasConnection1->dwBytesRcved = pStats->S_Statistics[BYTES_RCVED]; pRasConnection1->dwFramesXmited = pStats->S_Statistics[FRAMES_XMITED]; pRasConnection1->dwFramesRcved = pStats->S_Statistics[FRAMES_RCVED]; pRasConnection1->dwCrcErr = pStats->S_Statistics[CRC_ERR]; pRasConnection1->dwTimeoutErr = pStats->S_Statistics[TIMEOUT_ERR]; pRasConnection1->dwAlignmentErr = pStats->S_Statistics[ALIGNMENT_ERR]; pRasConnection1->dwFramingErr = pStats->S_Statistics[FRAMING_ERR]; pRasConnection1->dwHardwareOverrunErr = pStats->S_Statistics[HARDWARE_OVERRUN_ERR]; pRasConnection1->dwBufferOverrunErr = pStats->S_Statistics[BUFFER_OVERRUN_ERR]; pRasConnection1->dwCompressionRatioIn = pStats->S_Statistics[COMPRESSION_RATIO_IN]; pRasConnection1->dwCompressionRatioOut = pStats->S_Statistics[COMPRESSION_RATIO_OUT]; return( NO_ERROR ); } //** // // Call: GetRasConnection2Data // // Returns: NO_ERROR - Success // Non-zero returns - Failure // // Description: Given a pointer to a CONNECTION_OBJECT structure will extract // all relevent information and insert it into a RAS_CONNECTION_2 // structure. // DWORD GetRasiConnection2Data( IN PCONNECTION_OBJECT pConnObj, OUT PRASI_CONNECTION_2 pRasConnection2 ) { pRasConnection2->dwConnection = PtrToUlong(pConnObj->hConnection); pRasConnection2->guid = pConnObj->guid; pRasConnection2->dwInterfaceType = pConnObj->InterfaceType; wcscpy( pRasConnection2->wszUserName, pConnObj->wchUserName ); pRasConnection2->PppInfo2.nbf.dwError = pConnObj->PppProjectionResult.nbf.dwError; if ( pRasConnection2->PppInfo2.nbf.dwError == NO_ERROR ) { wcscpy( pRasConnection2->PppInfo2.nbf.wszWksta, pConnObj->PppProjectionResult.nbf.wszWksta ); } else { pRasConnection2->PppInfo2.nbf.wszWksta[0] = (WCHAR)NULL; } pRasConnection2->PppInfo2.ip.dwError = pConnObj->PppProjectionResult.ip.dwError; if ( pRasConnection2->PppInfo2.ip.dwError == NO_ERROR ) { ConvertIpAddressToString( pConnObj->PppProjectionResult.ip.dwLocalAddress, pRasConnection2->PppInfo2.ip.wszAddress ); ConvertIpAddressToString( pConnObj->PppProjectionResult.ip.dwRemoteAddress, pRasConnection2->PppInfo2.ip.wszRemoteAddress ); pRasConnection2->PppInfo2.ip.dwOptions = 0; pRasConnection2->PppInfo2.ip.dwRemoteOptions = 0; if ( pConnObj->PppProjectionResult.ip.fSendVJHCompression ) { pRasConnection2->PppInfo2.ip.dwOptions |= PPP_IPCP_VJ; } if ( pConnObj->PppProjectionResult.ip.fReceiveVJHCompression ) { pRasConnection2->PppInfo2.ip.dwRemoteOptions |= PPP_IPCP_VJ; } } else { pRasConnection2->PppInfo2.ip.wszAddress[0] = (WCHAR)NULL; pRasConnection2->PppInfo2.ip.wszRemoteAddress[0] = (WCHAR)NULL; } pRasConnection2->PppInfo2.ipx.dwError = pConnObj->PppProjectionResult.ipx.dwError; if ( pRasConnection2->PppInfo2.ipx.dwError == NO_ERROR ) { ConvertIpxAddressToString( ( pConnObj->InterfaceType == ROUTER_IF_TYPE_CLIENT ) ? pConnObj->PppProjectionResult.ipx.bRemoteAddress : pConnObj->PppProjectionResult.ipx.bLocalAddress, pRasConnection2->PppInfo2.ipx.wszAddress ); } else { pRasConnection2->PppInfo2.ipx.wszAddress[0] = (WCHAR)NULL; } pRasConnection2->PppInfo2.at.dwError = pConnObj->PppProjectionResult.at.dwError; if ( pRasConnection2->PppInfo2.at.dwError == NO_ERROR ) { ConvertAtAddressToString( ( pConnObj->InterfaceType == ROUTER_IF_TYPE_CLIENT ) ? pConnObj->PppProjectionResult.at.dwRemoteAddress : pConnObj->PppProjectionResult.at.dwLocalAddress, pRasConnection2->PppInfo2.at.wszAddress ); } else { pRasConnection2->PppInfo2.at.wszAddress[0] = (WCHAR)NULL; } pRasConnection2->PppInfo2.ccp.dwError = pConnObj->PppProjectionResult.ccp.dwError; if ( pRasConnection2->PppInfo2.ccp.dwError == NO_ERROR ) { pRasConnection2->PppInfo2.ccp.dwCompressionAlgorithm = 0; if ( pConnObj->PppProjectionResult.ccp.dwSendProtocol == 0x12 ) { pRasConnection2->PppInfo2.ccp.dwCompressionAlgorithm = RASCCPCA_MPPC; } pRasConnection2->PppInfo2.ccp.dwOptions = pConnObj->PppProjectionResult.ccp.dwSendProtocolData; pRasConnection2->PppInfo2.ccp.dwRemoteCompressionAlgorithm = 0; if ( pConnObj->PppProjectionResult.ccp.dwReceiveProtocol == 0x12 ) { pRasConnection2->PppInfo2.ccp.dwRemoteCompressionAlgorithm = RASCCPCA_MPPC; } pRasConnection2->PppInfo2.ccp.dwRemoteOptions = pConnObj->PppProjectionResult.ccp.dwReceiveProtocolData; } pRasConnection2->PppInfo2.lcp.dwError = NO_ERROR; pRasConnection2->PppInfo2.lcp.dwAuthenticationProtocol = pConnObj->PppProjectionResult.lcp.dwLocalAuthProtocol; pRasConnection2->PppInfo2.lcp.dwAuthenticationData = pConnObj->PppProjectionResult.lcp.dwLocalAuthProtocolData; pRasConnection2->PppInfo2.lcp.dwEapTypeId = pConnObj->PppProjectionResult.lcp.dwLocalEapTypeId; pRasConnection2->PppInfo2.lcp.dwTerminateReason = NO_ERROR; pRasConnection2->PppInfo2.lcp.dwOptions = 0; if ( pConnObj->PppProjectionResult.lcp.dwLocalFramingType & PPP_MULTILINK_FRAMING ) { pRasConnection2->PppInfo2.lcp.dwOptions |= PPP_LCP_MULTILINK_FRAMING; } if ( pConnObj->PppProjectionResult.lcp.dwLocalOptions & PPPLCPO_PFC ) { pRasConnection2->PppInfo2.lcp.dwOptions |= PPP_LCP_PFC; } if ( pConnObj->PppProjectionResult.lcp.dwLocalOptions & PPPLCPO_ACFC ) { pRasConnection2->PppInfo2.lcp.dwOptions |= PPP_LCP_ACFC; } if ( pConnObj->PppProjectionResult.lcp.dwLocalOptions & PPPLCPO_SSHF ) { pRasConnection2->PppInfo2.lcp.dwOptions |= PPP_LCP_SSHF; } if ( pConnObj->PppProjectionResult.lcp.dwLocalOptions & PPPLCPO_DES_56 ) { pRasConnection2->PppInfo2.lcp.dwOptions |= PPP_LCP_DES_56; } if ( pConnObj->PppProjectionResult.lcp.dwLocalOptions & PPPLCPO_3_DES ) { pRasConnection2->PppInfo2.lcp.dwOptions |= PPP_LCP_3_DES; } pRasConnection2->PppInfo2.lcp.dwRemoteAuthenticationProtocol = pConnObj->PppProjectionResult.lcp.dwRemoteAuthProtocol; pRasConnection2->PppInfo2.lcp.dwRemoteAuthenticationData = pConnObj->PppProjectionResult.lcp.dwRemoteAuthProtocolData; pRasConnection2->PppInfo2.lcp.dwRemoteEapTypeId = pConnObj->PppProjectionResult.lcp.dwRemoteEapTypeId; pRasConnection2->PppInfo2.lcp.dwRemoteTerminateReason = NO_ERROR; pRasConnection2->PppInfo2.lcp.dwRemoteOptions = 0; if ( pConnObj->PppProjectionResult.lcp.dwRemoteFramingType & PPP_MULTILINK_FRAMING ) { pRasConnection2->PppInfo2.lcp.dwRemoteOptions |= PPP_LCP_MULTILINK_FRAMING; } if ( pConnObj->PppProjectionResult.lcp.dwRemoteOptions & PPPLCPO_PFC ) { pRasConnection2->PppInfo2.lcp.dwRemoteOptions |= PPP_LCP_PFC; } if ( pConnObj->PppProjectionResult.lcp.dwRemoteOptions & PPPLCPO_ACFC ) { pRasConnection2->PppInfo2.lcp.dwRemoteOptions |= PPP_LCP_ACFC; } if ( pConnObj->PppProjectionResult.lcp.dwRemoteOptions & PPPLCPO_SSHF ) { pRasConnection2->PppInfo2.lcp.dwRemoteOptions |= PPP_LCP_SSHF; } if ( pConnObj->PppProjectionResult.lcp.dwRemoteOptions & PPPLCPO_DES_56 ) { pRasConnection2->PppInfo2.lcp.dwRemoteOptions |= PPP_LCP_DES_56; } if ( pConnObj->PppProjectionResult.lcp.dwRemoteOptions & PPPLCPO_3_DES ) { pRasConnection2->PppInfo2.lcp.dwRemoteOptions |= PPP_LCP_3_DES; } return( NO_ERROR ); } DWORD GetRasConnection0Data( IN PCONNECTION_OBJECT pConnObj, OUT PRAS_CONNECTION_0 pRasConn0 ) { #ifdef _WIN64 DWORD dwErr; RASI_CONNECTION_0 RasiConn0; dwErr = GetRasiConnection0Data(pConnObj, &RasiConn0); if (dwErr == NO_ERROR) { pRasConn0->hConnection = UlongToPtr(RasiConn0.dwConnection); pRasConn0->hInterface = UlongToPtr(RasiConn0.dwInterface); pRasConn0->dwConnectDuration = RasiConn0.dwConnectDuration; pRasConn0->dwInterfaceType = RasiConn0.dwInterfaceType; pRasConn0->dwConnectionFlags = RasiConn0.dwConnectionFlags; wcscpy(pRasConn0->wszInterfaceName, RasiConn0.wszInterfaceName); wcscpy(pRasConn0->wszUserName, RasiConn0.wszUserName); wcscpy(pRasConn0->wszLogonDomain, RasiConn0.wszLogonDomain); wcscpy(pRasConn0->wszRemoteComputer,RasiConn0.wszRemoteComputer); } return dwErr; #else return GetRasiConnection0Data(pConnObj, (PRASI_CONNECTION_0)pRasConn0); #endif } DWORD GetRasConnection1Data( IN PCONNECTION_OBJECT pConnObj, OUT PRAS_CONNECTION_1 pRasConn1 ) { #ifdef _WIN64 DWORD dwErr; RASI_CONNECTION_1 RasiConn1; dwErr = GetRasiConnection1Data(pConnObj, &RasiConn1); if (dwErr == NO_ERROR) { pRasConn1->hConnection = UlongToPtr(RasiConn1.dwConnection); pRasConn1->hInterface = UlongToPtr(RasiConn1.dwInterface); pRasConn1->PppInfo = RasiConn1.PppInfo; pRasConn1->dwBytesXmited = RasiConn1.dwBytesXmited; pRasConn1->dwBytesRcved = RasiConn1.dwBytesRcved; pRasConn1->dwFramesXmited = RasiConn1.dwFramesXmited; pRasConn1->dwFramesRcved = RasiConn1.dwFramesRcved; pRasConn1->dwCrcErr = RasiConn1.dwCrcErr; pRasConn1->dwTimeoutErr = RasiConn1.dwTimeoutErr; pRasConn1->dwAlignmentErr = RasiConn1.dwAlignmentErr; pRasConn1->dwHardwareOverrunErr = RasiConn1.dwHardwareOverrunErr; pRasConn1->dwFramingErr = RasiConn1.dwFramingErr; pRasConn1->dwBufferOverrunErr = RasiConn1.dwBufferOverrunErr; pRasConn1->dwCompressionRatioIn = RasiConn1.dwCompressionRatioIn; pRasConn1->dwCompressionRatioOut= RasiConn1.dwCompressionRatioOut; } return dwErr; #else return GetRasiConnection1Data(pConnObj, (PRASI_CONNECTION_1)pRasConn1); #endif } DWORD GetRasConnection2Data( IN PCONNECTION_OBJECT pConnObj, OUT PRAS_CONNECTION_2 pRasConn2 ) { #ifdef _WIN64 DWORD dwErr; RASI_CONNECTION_2 RasiConn2; dwErr = GetRasiConnection2Data(pConnObj, &RasiConn2); if (dwErr == NO_ERROR) { pRasConn2->hConnection = UlongToPtr(RasiConn2.dwConnection); pRasConn2->dwInterfaceType = RasiConn2.dwInterfaceType; pRasConn2->guid = RasiConn2.guid; pRasConn2->PppInfo2 = RasiConn2.PppInfo2; wcscpy(pRasConn2->wszUserName, RasiConn2.wszUserName); } return dwErr; #else return GetRasiConnection2Data(pConnObj, (PRASI_CONNECTION_2)pRasConn2); #endif } //** // // Call: GetRasiPort0Data // // Returns: NO_ERROR - Success // Non-zero returns - Failure // // Description: Given a pointer to a DEVICE_OBJECT structure will extract all // relevent information and insert it into a RAS_PORT_0 structure. // DWORD GetRasiPort0Data( IN PDEVICE_OBJECT pDevObj, OUT PRASI_PORT_0 pRasPort0 ) { pRasPort0->dwPort = PtrToUlong(pDevObj->hPort); pRasPort0->dwConnection = PtrToUlong(pDevObj->hConnection); pRasPort0->dwTotalNumberOfCalls = pDevObj->dwTotalNumberOfCalls; pRasPort0->dwConnectDuration = 0; wcscpy( pRasPort0->wszPortName, pDevObj->wchPortName ); wcscpy( pRasPort0->wszMediaName, pDevObj->wchMediaName ); wcscpy( pRasPort0->wszDeviceName, pDevObj->wchDeviceName ); wcscpy( pRasPort0->wszDeviceType, pDevObj->wchDeviceType ); if ( pDevObj->fFlags & DEV_OBJ_OPENED_FOR_DIALOUT ) { RASCONNSTATUS ConnectionStatus; ConnectionStatus.dwSize = sizeof( RASCONNSTATUS ); if ( RasGetConnectStatus( pDevObj->hRasConn, &ConnectionStatus ) ) { // // On any error we assume the port is disconnected and closed. // pRasPort0->dwPortCondition = RAS_PORT_LISTENING; return( NO_ERROR ); } switch( ConnectionStatus.rasconnstate ) { case RASCS_OpenPort: case RASCS_PortOpened: case RASCS_ConnectDevice: case RASCS_DeviceConnected: case RASCS_AllDevicesConnected: case RASCS_Authenticate: case RASCS_AuthNotify: case RASCS_AuthRetry: case RASCS_AuthChangePassword: case RASCS_AuthLinkSpeed: case RASCS_AuthAck: case RASCS_ReAuthenticate: case RASCS_AuthProject: case RASCS_StartAuthentication: case RASCS_LogonNetwork: case RASCS_RetryAuthentication: case RASCS_CallbackComplete: case RASCS_PasswordExpired: pRasPort0->dwPortCondition = RAS_PORT_AUTHENTICATING; break; case RASCS_CallbackSetByCaller: case RASCS_AuthCallback: case RASCS_PrepareForCallback: case RASCS_WaitForModemReset: case RASCS_WaitForCallback: pRasPort0->dwPortCondition = RAS_PORT_LISTENING; break; case RASCS_Projected: case RASCS_Authenticated: pRasPort0->dwPortCondition = RAS_PORT_AUTHENTICATED; break; case RASCS_SubEntryConnected: case RASCS_Connected: pRasPort0->dwPortCondition = RAS_PORT_AUTHENTICATED; pRasPort0->dwConnectDuration = GetActiveTimeInSeconds( &(pDevObj->qwActiveTime) ); break; case RASCS_Disconnected: case RASCS_SubEntryDisconnected: pRasPort0->dwPortCondition = RAS_PORT_DISCONNECTED; break; case RASCS_Interactive: default: pRasPort0->dwPortCondition = RAS_PORT_DISCONNECTED; break; } return( NO_ERROR ); } switch( pDevObj->DeviceState ) { case DEV_OBJ_LISTENING: pRasPort0->dwPortCondition = RAS_PORT_LISTENING; break; case DEV_OBJ_HW_FAILURE: pRasPort0->dwPortCondition = RAS_PORT_NON_OPERATIONAL; break; case DEV_OBJ_RECEIVING_FRAME: case DEV_OBJ_LISTEN_COMPLETE: case DEV_OBJ_AUTH_IS_ACTIVE: pRasPort0->dwPortCondition = RAS_PORT_AUTHENTICATING; break; case DEV_OBJ_ACTIVE: pRasPort0->dwPortCondition = RAS_PORT_AUTHENTICATED; pRasPort0->dwConnectDuration = GetActiveTimeInSeconds( &(pDevObj->qwActiveTime) ); break; case DEV_OBJ_CALLBACK_DISCONNECTING: case DEV_OBJ_CALLBACK_DISCONNECTED: case DEV_OBJ_CALLBACK_CONNECTING: pRasPort0->dwPortCondition = RAS_PORT_CALLING_BACK; break; case DEV_OBJ_CLOSED: case DEV_OBJ_CLOSING: pRasPort0->dwPortCondition = RAS_PORT_DISCONNECTED; break; default: ASSERT( FALSE ); } return( NO_ERROR ); } //** // // Call: GetRasiPort1Data // // Returns: NO_ERROR - Success // Non-zero returns - Failure // // Description: Given a pointer to a DEVICE_OBJECT structure will extract all // relevent information and insert it into a RAS_PORT_0 structure. // DWORD GetRasiPort1Data( IN PDEVICE_OBJECT pDevObj, OUT PRASI_PORT_1 pRasPort1 ) { BYTE buffer[sizeof(RAS_STATISTICS) + (MAX_STATISTICS * sizeof (ULONG))]; RAS_STATISTICS *pStats = (RAS_STATISTICS *)buffer; DWORD dwSize = sizeof (buffer); DWORD dwRetCode; RASMAN_INFO RasManInfo; pRasPort1->dwPort = PtrToUlong(pDevObj->hPort); pRasPort1->dwConnection = PtrToUlong(pDevObj->hConnection); pRasPort1->dwHardwareCondition = ( pDevObj->DeviceState == DEV_OBJ_HW_FAILURE ) ? RAS_HARDWARE_FAILURE : RAS_HARDWARE_OPERATIONAL; dwRetCode = RasGetInfo( NULL, (HPORT)pDevObj->hPort, &RasManInfo ); if ( dwRetCode != NO_ERROR ) { return( dwRetCode ); } pRasPort1->dwLineSpeed = RasManInfo.RI_LinkSpeed; dwRetCode = RasPortGetStatisticsEx(NULL, (HPORT)pDevObj->hPort, (PBYTE)pStats, &dwSize ); if ( dwRetCode != NO_ERROR ) { return( dwRetCode ); } pRasPort1->dwLineSpeed = RasManInfo.RI_LinkSpeed; pRasPort1->dwBytesXmited = pStats->S_Statistics[BYTES_XMITED]; pRasPort1->dwBytesRcved = pStats->S_Statistics[BYTES_RCVED]; pRasPort1->dwFramesXmited = pStats->S_Statistics[FRAMES_XMITED]; pRasPort1->dwFramesRcved = pStats->S_Statistics[FRAMES_RCVED]; pRasPort1->dwCrcErr = pStats->S_Statistics[CRC_ERR]; pRasPort1->dwTimeoutErr = pStats->S_Statistics[TIMEOUT_ERR]; pRasPort1->dwAlignmentErr = pStats->S_Statistics[ALIGNMENT_ERR]; pRasPort1->dwFramingErr = pStats->S_Statistics[FRAMING_ERR]; pRasPort1->dwHardwareOverrunErr = pStats->S_Statistics[HARDWARE_OVERRUN_ERR]; pRasPort1->dwBufferOverrunErr = pStats->S_Statistics[BUFFER_OVERRUN_ERR]; pRasPort1->dwCompressionRatioIn = pStats->S_Statistics[ COMPRESSION_RATIO_IN ]; pRasPort1->dwCompressionRatioOut = pStats->S_Statistics[ COMPRESSION_RATIO_OUT ]; return( NO_ERROR ); } DWORD GetRasPort0Data( IN PDEVICE_OBJECT pDevObj, OUT PRAS_PORT_0 pRasPort0 ) { #ifdef _WIN64 DWORD dwErr; RASI_PORT_0 RasiPort0; dwErr = GetRasiPort0Data(pDevObj, &RasiPort0); if (dwErr == NO_ERROR) { pRasPort0->hPort = UlongToPtr(RasiPort0.dwPort); pRasPort0->hConnection = UlongToPtr(RasiPort0.dwConnection); pRasPort0->dwPortCondition = RasiPort0.dwPortCondition; pRasPort0->dwTotalNumberOfCalls = RasiPort0.dwTotalNumberOfCalls; pRasPort0->dwConnectDuration = RasiPort0.dwConnectDuration; wcscpy(pRasPort0->wszPortName, RasiPort0.wszPortName); wcscpy(pRasPort0->wszMediaName, RasiPort0.wszMediaName); wcscpy(pRasPort0->wszDeviceName, RasiPort0.wszDeviceName); wcscpy(pRasPort0->wszDeviceType, RasiPort0.wszDeviceType); } return dwErr; #else return GetRasiPort0Data(pDevObj, (PRASI_PORT_0)pRasPort0); #endif } DWORD GetRasPort1Data( IN PDEVICE_OBJECT pDevObj, OUT PRAS_PORT_1 pRasPort1 ) { #ifdef _WIN64 DWORD dwErr; RASI_PORT_1 RasiPort1; dwErr = GetRasiPort1Data(pDevObj, &RasiPort1); if (dwErr == NO_ERROR) { pRasPort1->hPort = UlongToPtr(RasiPort1.dwPort); pRasPort1->hConnection = UlongToPtr(RasiPort1.dwConnection); pRasPort1->dwHardwareCondition = RasiPort1.dwHardwareCondition; pRasPort1->dwLineSpeed = RasiPort1.dwLineSpeed; pRasPort1->dwBytesXmited = RasiPort1.dwBytesXmited; pRasPort1->dwBytesRcved = RasiPort1.dwBytesRcved; pRasPort1->dwFramesXmited = RasiPort1.dwFramesXmited; pRasPort1->dwFramesRcved = RasiPort1.dwFramesRcved; pRasPort1->dwCrcErr = RasiPort1.dwCrcErr; pRasPort1->dwTimeoutErr = RasiPort1.dwTimeoutErr; pRasPort1->dwAlignmentErr = RasiPort1.dwAlignmentErr; pRasPort1->dwHardwareOverrunErr = RasiPort1.dwHardwareOverrunErr; pRasPort1->dwFramingErr = RasiPort1.dwFramingErr; pRasPort1->dwBufferOverrunErr = RasiPort1.dwBufferOverrunErr; pRasPort1->dwCompressionRatioIn = RasiPort1.dwCompressionRatioIn; pRasPort1->dwCompressionRatioOut= RasiPort1.dwCompressionRatioOut; } return dwErr; #else return GetRasiPort1Data(pDevObj, (PRASI_PORT_1)pRasPort1); #endif } //*** // // Function: SignalHwError // // Descr: // //*** VOID SignalHwError( IN PDEVICE_OBJECT pDeviceObj ) { LPWSTR portnamep; DDM_PRINT( gblDDMConfigInfo.dwTraceId, TRACE_FSM, "SignalHwErr: Entered"); portnamep = pDeviceObj->wchPortName; DDMLogError( ROUTERLOG_DEV_HW_ERROR, 1, &portnamep, 0 ); } DWORD MapAuthCodeToLogId( IN WORD Code ) { switch (Code) { case AUTH_ALL_PROJECTIONS_FAILED: return (ROUTERLOG_AUTH_NO_PROJECTIONS); case AUTH_PASSWORD_EXPIRED: return(ROUTERLOG_PASSWORD_EXPIRED); case AUTH_ACCT_EXPIRED: return(ROUTERLOG_ACCT_EXPIRED); case AUTH_NO_DIALIN_PRIVILEGE: return(ROUTERLOG_NO_DIALIN_PRIVILEGE); case AUTH_UNSUPPORTED_VERSION: return(ROUTERLOG_UNSUPPORTED_VERSION); case AUTH_ENCRYPTION_REQUIRED: return(ROUTERLOG_ENCRYPTION_REQUIRED); } return(0); } BOOL IsPortOwned( IN PDEVICE_OBJECT pDeviceObj ) { RASMAN_INFO rasinfo; // // get the current port state // if ( RasGetInfo( NULL, pDeviceObj->hPort, &rasinfo ) != NO_ERROR ) { return( FALSE ); } return( rasinfo.RI_OwnershipFlag ); } VOID GetLoggingInfo( IN PDEVICE_OBJECT pDeviceObj, OUT PDWORD BaudRate, OUT PDWORD BytesSent, OUT PDWORD BytesRecv, OUT RASMAN_DISCONNECT_REASON *Reason, OUT SYSTEMTIME *Time ) { RASMAN_INFO RasmanInfo; BYTE buffer[sizeof(RAS_STATISTICS) + (MAX_STATISTICS * sizeof (ULONG))]; RAS_STATISTICS *PortStats = (RAS_STATISTICS *)buffer; DWORD PortStatsSize = sizeof (buffer); *Reason = 3L; // // Time is a piece of cake // GetLocalTime(Time); // // Now the statistics // *BytesSent = 0L; *BytesRecv = 0L; if (RasPortGetStatisticsEx( NULL, pDeviceObj->hPort, (PBYTE)PortStats, &PortStatsSize)) { return; } *BytesRecv = PortStats->S_Statistics[BYTES_RCVED]; *BytesSent = PortStats->S_Statistics[BYTES_XMITED]; // // And finally the disconnect reason (local or remote) and baud rate // if (RasGetInfo(NULL, pDeviceObj->hPort, &RasmanInfo)) { return; } *Reason = RasmanInfo.RI_DisconnectReason; *BaudRate = GetLineSpeed(pDeviceObj->hPort); // // If we have a disconnect reason - will have one // when disconnect is happening because of a ppp // reason, use that one instead. // if(pDeviceObj->dwDisconnectReason) { *Reason = pDeviceObj->dwDisconnectReason; } return; } DWORD GetLineSpeed( IN HPORT hPort ) { RASMAN_INFO RasManInfo; if (RasGetInfo(NULL, hPort, &RasManInfo)) { return 0; } return (RasManInfo.RI_LinkSpeed); } VOID LogConnectionEvent( IN PCONNECTION_OBJECT pConnObj, IN PDEVICE_OBJECT pDeviceObj ) { DWORD BaudRate = 0; DWORD BytesSent; DWORD BytesRecv; RASMAN_DISCONNECT_REASON Reason; SYSTEMTIME DiscTime; LPWSTR auditstrp[12]; WCHAR *ReasonStr; WCHAR BytesRecvStr[20]; WCHAR BytesSentStr[20]; WCHAR BaudRateStr[20]; WCHAR DateConnected[64]; WCHAR DateDisconnected[64]; WCHAR TimeConnected[64]; WCHAR TimeDisconnected[64]; DWORD active_time; WCHAR minutes[20]; WCHAR seconds[4]; WCHAR wchFullUserName[UNLEN+DNLEN+2]; WCHAR *DiscReasons[] = { gblpszAdminRequest, gblpszUserRequest, gblpszHardwareFailure, gblpszUnknownReason, gblpszIdleDisconnect, gblpszSessionTimeout }; GetLoggingInfo( pDeviceObj, &BaudRate, &BytesSent, &BytesRecv, &Reason, &DiscTime); wcscpy(TimeConnected, L""); wcscpy(DateConnected, L""); wcscpy(TimeDisconnected, L""); wcscpy(DateDisconnected, L""); GetTimeFormat( LOCALE_SYSTEM_DEFAULT, TIME_NOSECONDS, &pDeviceObj->ConnectionTime, NULL, TimeConnected, sizeof(TimeConnected)/sizeof(WCHAR)); GetDateFormat( LOCALE_SYSTEM_DEFAULT, DATE_SHORTDATE, &pDeviceObj->ConnectionTime, NULL, DateConnected, sizeof(DateConnected)/sizeof(WCHAR)); GetTimeFormat( LOCALE_SYSTEM_DEFAULT, TIME_NOSECONDS, &DiscTime, NULL, TimeDisconnected, sizeof(TimeDisconnected)/sizeof(WCHAR)); GetDateFormat( LOCALE_SYSTEM_DEFAULT, DATE_SHORTDATE, &DiscTime, NULL, DateDisconnected, sizeof(DateDisconnected)/sizeof(WCHAR)); active_time = GetActiveTimeInSeconds( &(pDeviceObj->qwActiveTime) ); DDM_PRINT( gblDDMConfigInfo.dwTraceId, TRACE_FSM, "CLIENT ACTIVE FOR %li SECONDS", active_time); _itow(active_time / 60, minutes, 10); _itow(active_time % 60, seconds, 10); wsprintf(BytesSentStr, TEXT("%u"), BytesSent); wsprintf(BytesRecvStr, TEXT("%u"), BytesRecv); wsprintf(BaudRateStr, TEXT("%i"), BaudRate); ReasonStr = DiscReasons[Reason]; if ( pConnObj->wchDomainName[0] != TEXT('\0') ) { wcscpy( wchFullUserName, pConnObj->wchDomainName ); wcscat( wchFullUserName, TEXT("\\") ); wcscat( wchFullUserName, pConnObj->wchUserName ); } else { wcscpy( wchFullUserName, pConnObj->wchUserName ); } auditstrp[0] = wchFullUserName; auditstrp[1] = pDeviceObj->wchPortName; auditstrp[2] = DateConnected; auditstrp[3] = TimeConnected; auditstrp[4] = DateDisconnected; auditstrp[5] = TimeDisconnected; auditstrp[6] = minutes; auditstrp[7] = seconds; auditstrp[8] = BytesSentStr; auditstrp[9] = BytesRecvStr; if(RAS_DEVICE_CLASS(pDeviceObj->dwDeviceType) == RDT_Tunnel) { auditstrp[10] = DiscReasons[Reason]; auditstrp[11] = NULL; DDMLogInformation( ROUTERLOG_USER_ACTIVE_TIME_VPN, 11, auditstrp ); } else { auditstrp[10] = BaudRateStr; auditstrp[11] = DiscReasons[Reason]; DDMLogInformation( ROUTERLOG_USER_ACTIVE_TIME, 12, auditstrp ); } if(pConnObj->PppProjectionResult.ip.dwError == NO_ERROR) { WCHAR *pszAddress = GetIpAddress( pConnObj->PppProjectionResult.ip.dwRemoteAddress); auditstrp[0] = pszAddress; DDMLogInformation( ROUTERLOG_IP_USER_DISCONNECTED, 1, auditstrp); LocalFree(pszAddress); } } //** // // Call: GetTransportIndex // // Returns: Index of the tansport entry in the interface object // // Description: Given the id of a protocol return an index. // DWORD GetTransportIndex( IN DWORD dwProtocolId ) { DWORD dwTransportIndex; for ( dwTransportIndex = 0; dwTransportIndex < gblDDMConfigInfo.dwNumRouterManagers; dwTransportIndex++ ) { if ( gblRouterManagers[dwTransportIndex].DdmRouterIf.dwProtocolId == dwProtocolId ) { return( dwTransportIndex ); } } return( (DWORD)-1 ); } VOID DDMPostCleanup( VOID ) { if ( gblDDMConfigInfo.hinstAcctModule != NULL ) { DWORD dwRetCode; HKEY hKeyAccounting; if ( gblDDMConfigInfo.lpfnRasAcctProviderTerminate != NULL ) { gblDDMConfigInfo.lpfnRasAcctProviderTerminate(); } // // Write back the AccntSessionId value // dwRetCode = RegOpenKeyEx( HKEY_LOCAL_MACHINE, RAS_KEYPATH_ACCOUNTING, 0, KEY_READ | KEY_WRITE, &hKeyAccounting ); if ( dwRetCode == NO_ERROR ) { RegSetValueEx( hKeyAccounting, RAS_VALNAME_ACCTSESSIONID, 0, REG_DWORD, (BYTE *)(&gblDDMConfigInfo.dwAccountingSessionId), 4 ); RegCloseKey( hKeyAccounting ); } FreeLibrary( gblDDMConfigInfo.hinstAcctModule ); gblDDMConfigInfo.hinstAcctModule = NULL; } DeleteCriticalSection( &(gblDDMConfigInfo.CSAccountingSessionId) ); if ( gblDDMConfigInfo.hinstAuthModule != NULL ) { if ( gblDDMConfigInfo.lpfnRasAuthProviderTerminate != NULL ) { gblDDMConfigInfo.lpfnRasAuthProviderTerminate(); } FreeLibrary( gblDDMConfigInfo.hinstAuthModule ); gblDDMConfigInfo.hinstAuthModule = NULL; } } //** // // Call: DDMCleanUp // // Returns: None // // Description: Will clean up all DDM allocations // VOID DDMCleanUp( VOID ) { DWORD dwIndex; if ( gblDDMConfigInfo.hIpHlpApi != NULL ) { FreeLibrary( gblDDMConfigInfo.hIpHlpApi ); gblDDMConfigInfo.hIpHlpApi = NULL; gblDDMConfigInfo.lpfnAllocateAndGetIfTableFromStack = NULL; gblDDMConfigInfo.lpfnAllocateAndGetIpAddrTableFromStack = NULL; } if ( gblDDMConfigInfo.fRasSrvrInitialized ) { RasSrvrUninitialize(); gblDDMConfigInfo.fRasSrvrInitialized = FALSE; } PppDdmDeInit(); if ( gblDDMConfigInfo.hkeyParameters != NULL ) { RegCloseKey( gblDDMConfigInfo.hkeyParameters ); gblDDMConfigInfo.hkeyParameters = NULL; } if ( gblDDMConfigInfo.hkeyAccounting != NULL ) { RegCloseKey( gblDDMConfigInfo.hkeyParameters ); gblDDMConfigInfo.hkeyParameters = NULL; } if ( gblDDMConfigInfo.hkeyAuthentication != NULL ) { RegCloseKey( gblDDMConfigInfo.hkeyParameters ); gblDDMConfigInfo.hkeyParameters = NULL; } { DWORD i; for (i=0; ihInstAdminModule != NULL ) { if ( AdminDllCallbacks->lpfnRasAdminTerminateDll != NULL ) { DWORD (*TerminateAdminDll)() = (DWORD(*)(VOID))AdminDllCallbacks->lpfnRasAdminTerminateDll; TerminateAdminDll(); } FreeLibrary( AdminDllCallbacks->hInstAdminModule ); } } } if ( gblDDMConfigInfo.AdminDllCallbacks != NULL ) { LOCAL_FREE( gblDDMConfigInfo.AdminDllCallbacks ); } if ( gblDDMConfigInfo.hInstSecurityModule != NULL ) { FreeLibrary( gblDDMConfigInfo.hInstSecurityModule ); } if ( gblpRouterPhoneBook != NULL ) { LOCAL_FREE( gblpRouterPhoneBook ); } if ( gblpszAdminRequest != NULL ) { LOCAL_FREE( gblpszAdminRequest ); } if ( gblpszUserRequest != NULL ) { LOCAL_FREE( gblpszUserRequest ); } if ( gblpszHardwareFailure != NULL ) { LOCAL_FREE( gblpszHardwareFailure ); } if ( gblpszUnknownReason != NULL ) { LOCAL_FREE( gblpszUnknownReason ); } if ( gblpszPm != NULL ) { LOCAL_FREE( gblpszPm ); } if ( gblpszAm != NULL ) { LOCAL_FREE( gblpszAm ); } if ( gblpszIdleDisconnect != NULL ) { LOCAL_FREE( gblpszIdleDisconnect ); } if( gblpszSessionTimeout != NULL ) { LOCAL_FREE( gblpszSessionTimeout ); } if( gblDDMConfigInfo.apAnalogIPAddresses != NULL ) { LocalFree( gblDDMConfigInfo.apAnalogIPAddresses[0] ); LocalFree( gblDDMConfigInfo.apAnalogIPAddresses ); gblDDMConfigInfo.apAnalogIPAddresses = NULL; gblDDMConfigInfo.cAnalogIPAddresses = 0; } if( gblDDMConfigInfo.apDigitalIPAddresses != NULL ) { LocalFree( gblDDMConfigInfo.apDigitalIPAddresses[0] ); LocalFree( gblDDMConfigInfo.apDigitalIPAddresses ); gblDDMConfigInfo.apDigitalIPAddresses = NULL; gblDDMConfigInfo.cDigitalIPAddresses = 0; } gblDDMConfigInfo.dwIndex = 0; if ( gblDeviceTable.DeviceBucket != NULL ) { // // close all opened devices // DeviceObjIterator( DeviceObjClose, FALSE, NULL ); } if(gblDDMConfigInfo.fRasmanReferenced) { // // Decerement rasman's refrence count. This does not happen // automatically since we are in the same process as rasman. // RasReferenceRasman( FALSE ); } if ( gblSupervisorEvents != (HANDLE *)NULL ) { DeleteMessageQs(); for ( dwIndex = 0; dwIndex < NUM_DDM_EVENTS + gblDeviceTable.NumDeviceBuckets + gblDeviceTable.NumConnectionBuckets; dwIndex ++ ) { if ( gblSupervisorEvents[dwIndex] != NULL ) { switch( dwIndex ) { case DDM_EVENT_SVC_TERMINATED: case DDM_EVENT_SVC: break; default: CloseHandle( gblSupervisorEvents[dwIndex] ); break; } gblSupervisorEvents[dwIndex] = NULL; } } } // // Wait for this to be released // EnterCriticalSection( &(gblDeviceTable.CriticalSection) ); DeleteCriticalSection( &(gblDeviceTable.CriticalSection) ); TimerQDelete(); // // Release all notification events // if ( gblDDMConfigInfo.NotificationEventListHead.Flink != NULL ) { while( !IsListEmpty( &(gblDDMConfigInfo.NotificationEventListHead ) ) ) { NOTIFICATION_EVENT * pNotificationEvent = (NOTIFICATION_EVENT *) RemoveHeadList( &(gblDDMConfigInfo.NotificationEventListHead) ); CloseHandle( pNotificationEvent->hEventClient ); CloseHandle( pNotificationEvent->hEventRouter ); LOCAL_FREE( pNotificationEvent ); } } MediaObjFreeTable(); // // Destroy private heap // if ( gblDDMConfigInfo.hHeap != NULL ) { HeapDestroy( gblDDMConfigInfo.hHeap ); } // // Zero out globals // ZeroMemory( &gblDeviceTable, sizeof( gblDeviceTable ) ); ZeroMemory( &gblMediaTable, sizeof( gblMediaTable ) ); ZeroMemory( gblEventHandlerTable, sizeof( gblEventHandlerTable ) ); //ZeroMemory( &gblDDMConfigInfo, sizeof( gblDDMConfigInfo ) ); gblRouterManagers = NULL; gblpInterfaceTable = NULL; gblSupervisorEvents = NULL; gblphEventDDMServiceState = NULL; gblpRouterPhoneBook = NULL; gblpszAdminRequest = NULL; gblpszUserRequest = NULL; gblpszHardwareFailure = NULL; gblpszUnknownReason = NULL; gblpszPm = NULL; gblpszAm = NULL; gblpszIdleDisconnect = NULL; gblpszSessionTimeout = NULL; } //** // // Call: GetRouterPhoneBook // // Returns: NO_ERROR - Success // Non-zero returns - Failure // // Description: Will set the gblpRouterPhoneBook global to point to the // full path of the router phonebook. // DWORD GetRouterPhoneBook( VOID ) { DWORD dwSize; DWORD cchDir = GetWindowsDirectory( NULL, 0 ); if ( cchDir == 0 ) { return( GetLastError() ); } dwSize=(cchDir+wcslen(TEXT("\\SYSTEM32\\RAS\\ROUTER.PBK"))+1)*sizeof(WCHAR); if ( ( gblpRouterPhoneBook = LOCAL_ALLOC( LPTR, dwSize ) ) == NULL ) { return( GetLastError() ); } if ( GetWindowsDirectory( gblpRouterPhoneBook, cchDir ) == 0 ) { return( GetLastError() ); } if ( gblpRouterPhoneBook[cchDir-1] != TEXT('\\') ) { wcscat( gblpRouterPhoneBook, TEXT("\\") ); } wcscat( gblpRouterPhoneBook, TEXT("SYSTEM32\\RAS\\ROUTER.PBK") ); return( NO_ERROR ); } //** // // Call: LoadStrings // // Returns: NO_ERROR - Success // Non-zero returns - Failure // // Description: Loads all localizable strings from the resource table // DWORD LoadStrings( VOID ) { #define MAX_XLATE_STRING 40 LPWSTR lpwsModuleName = TEXT("MPRDDM.DLL"); // // Load strings from resource file // gblpszAdminRequest = LOCAL_ALLOC( LPTR, MAX_XLATE_STRING*sizeof(WCHAR)); gblpszUserRequest = LOCAL_ALLOC( LPTR, MAX_XLATE_STRING*sizeof(WCHAR)); gblpszHardwareFailure = LOCAL_ALLOC( LPTR, MAX_XLATE_STRING*sizeof(WCHAR)); gblpszUnknownReason = LOCAL_ALLOC( LPTR, MAX_XLATE_STRING*sizeof(WCHAR)); gblpszPm = LOCAL_ALLOC( LPTR, MAX_XLATE_STRING*sizeof(WCHAR)); gblpszAm = LOCAL_ALLOC( LPTR, MAX_XLATE_STRING*sizeof(WCHAR)); gblpszUnknown = LOCAL_ALLOC( LPTR, MAX_XLATE_STRING*sizeof(WCHAR)); gblpszIdleDisconnect = LOCAL_ALLOC(LPTR, MAX_XLATE_STRING*sizeof(WCHAR)); gblpszSessionTimeout = LOCAL_ALLOC( LPTR, MAX_XLATE_STRING*sizeof(WCHAR)); if ( ( gblpszAdminRequest == NULL ) || ( gblpszUserRequest == NULL ) || ( gblpszHardwareFailure == NULL ) || ( gblpszUnknownReason == NULL ) || ( gblpszUnknown == NULL ) || ( gblpszPm == NULL ) || ( gblpszAm == NULL ) || ( gblpszIdleDisconnect == NULL ) || ( gblpszSessionTimeout == NULL )) { return( GetLastError() ); } if (( !LoadString( GetModuleHandle( lpwsModuleName ), 1, gblpszAdminRequest, MAX_XLATE_STRING )) || ( !LoadString( GetModuleHandle( lpwsModuleName ), 2, gblpszUserRequest, MAX_XLATE_STRING )) || ( !LoadString( GetModuleHandle( lpwsModuleName ), 3, gblpszHardwareFailure, MAX_XLATE_STRING )) || ( !LoadString( GetModuleHandle( lpwsModuleName ), 4, gblpszUnknownReason, MAX_XLATE_STRING )) || ( !LoadString( GetModuleHandle( lpwsModuleName) , 5, gblpszAm, MAX_XLATE_STRING )) || ( !LoadString( GetModuleHandle( lpwsModuleName ), 6, gblpszPm, MAX_XLATE_STRING )) || ( !LoadString( GetModuleHandle( lpwsModuleName) , 7, gblpszUnknown, MAX_XLATE_STRING )) || ( !LoadString( GetModuleHandle( lpwsModuleName) , 8, gblpszIdleDisconnect, MAX_XLATE_STRING )) || ( !LoadString( GetModuleHandle( lpwsModuleName), 9, gblpszSessionTimeout, MAX_XLATE_STRING))) { return( GetLastError() ); } return( NO_ERROR ); } //** // // Call: AcceptNewLink // // Returns: TRUE - Continue with link processing // FALSE - Abort link processing // // Description: // BOOL AcceptNewLink( IN DEVICE_OBJECT * pDeviceObj, IN CONNECTION_OBJECT * pConnObj ) { DWORD i; BOOL bFirstLoop, bReturnFalse; RAS_PORT_0 RasPort0; RAS_PORT_1 RasPort1; BOOL (*MprAdminAcceptNewLink)( RAS_PORT_0 *, RAS_PORT_1 * ); // // return TRUE only if no one says FALSE // for (i=0,bFirstLoop=TRUE,bReturnFalse=FALSE; (ilpfnRasAdminAcceptNewLink != NULL ) { if (bFirstLoop) { bFirstLoop = FALSE; if ((GetRasPort0Data(pDeviceObj,&RasPort0) != NO_ERROR) || (GetRasPort1Data(pDeviceObj,&RasPort1) != NO_ERROR)) { DevStartClosing( pDeviceObj ); return( FALSE ); } pDeviceObj->fFlags &= (~DEV_OBJ_NOTIFY_OF_DISCONNECTION); } MprAdminAcceptNewLink = (BOOL (*)( RAS_PORT_0 *, RAS_PORT_1 * )) AdminDllCallbacks->lpfnRasAdminAcceptNewLink; if ( !MprAdminAcceptNewLink( &RasPort0, &RasPort1 ) ) { DevStartClosing( pDeviceObj ); bReturnFalse = TRUE; break; } } } if (bReturnFalse) { DWORD j; for (j=0; jlpfnRasAdminLinkHangupNotification != NULL) { MprAdminLinkHangupNotification = (VOID (*)( RAS_PORT_0 *, RAS_PORT_1 * )) AdminDllCallbacks->lpfnRasAdminLinkHangupNotification; MprAdminLinkHangupNotification( &RasPort0, &RasPort1 ); } } return FALSE; } //return false pDeviceObj->fFlags |= DEV_OBJ_NOTIFY_OF_DISCONNECTION; return( TRUE ); } //** // // Call: AcceptNewConnection // // Returns: TRUE - Continue with connection processing // FALSE - Abort connection processing // // Description: // BOOL AcceptNewConnection( IN DEVICE_OBJECT * pDeviceObj, IN CONNECTION_OBJECT * pConnObj ) { DWORD i; BOOL bFirstLoop, bReturnFalse; RAS_CONNECTION_0 RasConnection0; RAS_CONNECTION_1 RasConnection1; RAS_CONNECTION_2 RasConnection2; // // return TRUE only if no one says FALSE // for (i=0,bFirstLoop=TRUE,bReturnFalse=FALSE; (ilpfnRasAdminAcceptNewConnection != NULL ) || ( AdminDllCallbacks->lpfnRasAdminAcceptNewConnection2 != NULL ) ) { if (bFirstLoop) { bFirstLoop = FALSE; if ((GetRasConnection0Data(pConnObj,&RasConnection0) != NO_ERROR) || (GetRasConnection1Data(pConnObj,&RasConnection1) != NO_ERROR) || (GetRasConnection2Data(pConnObj,&RasConnection2) != NO_ERROR)) { ConnObjDisconnect( pConnObj ); return( FALSE ); } // // Let callout DLL know that we do not have a username for this user // if ( _wcsicmp( RasConnection0.wszUserName, gblpszUnknown ) == 0 ) { RasConnection0.wszUserName[0] = (WCHAR)NULL; } pConnObj->fFlags &= (~CONN_OBJ_NOTIFY_OF_DISCONNECTION); } if ( AdminDllCallbacks->lpfnRasAdminAcceptNewConnection2 != NULL ) { BOOL (*MprAdminAcceptNewConnection2)( RAS_CONNECTION_0 *, RAS_CONNECTION_1 *, RAS_CONNECTION_2 * ); MprAdminAcceptNewConnection2 = (BOOL (*)( RAS_CONNECTION_0 *, RAS_CONNECTION_1 * , RAS_CONNECTION_2 * )) AdminDllCallbacks->lpfnRasAdminAcceptNewConnection2; if ( !MprAdminAcceptNewConnection2( &RasConnection0, &RasConnection1, &RasConnection2 ) ) { ConnObjDisconnect( pConnObj ); bReturnFalse = TRUE; break; } } else { BOOL (*MprAdminAcceptNewConnection)( RAS_CONNECTION_0 *, RAS_CONNECTION_1 * ); MprAdminAcceptNewConnection = (BOOL (*)( RAS_CONNECTION_0 *, RAS_CONNECTION_1 * )) AdminDllCallbacks->lpfnRasAdminAcceptNewConnection; if ( !MprAdminAcceptNewConnection( &RasConnection0, &RasConnection1 ) ) { ConnObjDisconnect( pConnObj ); bReturnFalse = TRUE; break; } } } } if (bReturnFalse) { DWORD j; for (j=0; jlpfnRasAdminConnectionHangupNotification2 != NULL) { VOID (*MprAdminConnectionHangupNotification2)( RAS_CONNECTION_0 *, RAS_CONNECTION_1 *, RAS_CONNECTION_2 * ); MprAdminConnectionHangupNotification2 = (VOID (*)( RAS_CONNECTION_0 *, RAS_CONNECTION_1 *, RAS_CONNECTION_2 * )) AdminDllCallbacks->lpfnRasAdminConnectionHangupNotification2; MprAdminConnectionHangupNotification2( &RasConnection0, &RasConnection1, &RasConnection2 ); } else if ( AdminDllCallbacks->lpfnRasAdminConnectionHangupNotification != NULL) { VOID (*MprAdminConnectionHangupNotification)( RAS_CONNECTION_0 *, RAS_CONNECTION_1 * ); MprAdminConnectionHangupNotification = (VOID (*)( RAS_CONNECTION_0 *, RAS_CONNECTION_1 * )) AdminDllCallbacks->lpfnRasAdminConnectionHangupNotification; MprAdminConnectionHangupNotification( &RasConnection0, &RasConnection1 ); } } //for return( FALSE ); } pConnObj->fFlags |= CONN_OBJ_NOTIFY_OF_DISCONNECTION; return( TRUE ); } //** // // Call: ConnectionHangupNotification // // Returns: NO_ERROR - Success // Non-zero returns - Failure // // Description: // VOID ConnectionHangupNotification( IN CONNECTION_OBJECT * pConnObj ) { RAS_CONNECTION_0 RasConnection0; RAS_CONNECTION_1 RasConnection1; RAS_CONNECTION_2 RasConnection2; if ((GetRasConnection0Data(pConnObj,&RasConnection0) == NO_ERROR) && (GetRasConnection1Data(pConnObj,&RasConnection1) == NO_ERROR) && (GetRasConnection2Data(pConnObj,&RasConnection2) == NO_ERROR)) { DWORD i; for (i=0; ilpfnRasAdminConnectionHangupNotification2 != NULL) { VOID (*MprAdminConnectionHangupNotification2)( RAS_CONNECTION_0 *, RAS_CONNECTION_1 *, RAS_CONNECTION_2 * ); MprAdminConnectionHangupNotification2 = (VOID (*)( RAS_CONNECTION_0 *, RAS_CONNECTION_1 *, RAS_CONNECTION_2 * )) AdminDllCallbacks->lpfnRasAdminConnectionHangupNotification2; MprAdminConnectionHangupNotification2( &RasConnection0, &RasConnection1, &RasConnection2 ); } else { VOID (*MprAdminConnectionHangupNotification)( RAS_CONNECTION_0 *, RAS_CONNECTION_1 * ); MprAdminConnectionHangupNotification = (VOID (*)( RAS_CONNECTION_0 *, RAS_CONNECTION_1 * )) AdminDllCallbacks->lpfnRasAdminConnectionHangupNotification; MprAdminConnectionHangupNotification( &RasConnection0, &RasConnection1 ); } } //for } } //** // // Call: GetActiveTimeInSeconds // // Returns: NO_ERROR - Success // Non-zero returns - Failure // // Description: Will return the difference, in seconds, between then time the // current time and the time represented by the argument passed in. // DWORD GetActiveTimeInSeconds( IN ULARGE_INTEGER * pqwActiveTime ) { ULARGE_INTEGER qwCurrentTime; ULARGE_INTEGER qwUpTime; DWORD dwRemainder; if ( pqwActiveTime->QuadPart == 0 ) { return( 0 ); } GetSystemTimeAsFileTime( (FILETIME*)&qwCurrentTime ); if ( pqwActiveTime->QuadPart > qwCurrentTime.QuadPart ) { return( 0 ); } qwUpTime.QuadPart = qwCurrentTime.QuadPart - pqwActiveTime->QuadPart; return( RtlEnlargedUnsignedDivide(qwUpTime,(DWORD)10000000,&dwRemainder)); } //** // // Call: DDMRecognizeFrame // // Returns: TRUE - Recognized // FALSE - Unrecognized // // Description: Returns whether a received packet has a recognized format // by the RAS server (i.e. is in the format of a data-link layer // protocol that is supported by RAS). // // Up though Windows 2000, this api would return true for AMB // or PPP packets. // // Now, only PPP packets are supported. // BOOL DDMRecognizeFrame( IN PVOID pvFrameBuf, // pointer to the frame IN WORD wFrameLen, // Length in bytes of the frame OUT DWORD *pProtocol // xport id - valid only if recognized ) { PBYTE pb; WORD FrameType; if ( wFrameLen < 16 ) { DDMTRACE( "Initial frame length is less than 16, frame not recognized"); //ASSERT( FALSE ); return( FALSE ); } // // Check PPP // pb = ((PBYTE) pvFrameBuf) + 12; GET_USHORT(&FrameType, pb); switch( FrameType ) { case PPP_LCP_PROTOCOL: case PPP_PAP_PROTOCOL: case PPP_CBCP_PROTOCOL: case PPP_BACP_PROTOCOL: case PPP_BAP_PROTOCOL: case PPP_CHAP_PROTOCOL: case PPP_IPCP_PROTOCOL: case PPP_ATCP_PROTOCOL: case PPP_IPXCP_PROTOCOL: case PPP_CCP_PROTOCOL: case PPP_SPAP_NEW_PROTOCOL: case PPP_EAP_PROTOCOL: *pProtocol = PPP_LCP_PROTOCOL; return( TRUE ); default: DDMTRACE1("Initial frame has unknown header %x, frame unrecognized", FrameType ); //ASSERT( FALSE ); break; } return( FALSE ); } //** // // Call: DDMGetIdentityAttributes // // Returns: NO_ERROR - Success // Non-zero returns - Failure // // Description: Will gather all identity attributes and return them to // DIM to be plumbed into the DS // DWORD DDMGetIdentityAttributes( IN OUT ROUTER_IDENTITY_ATTRIBUTE * pRouterIdAttributes ) { DWORD dwIndex; // // Get all media types used // DeviceObjIterator( DeviceObjGetType, FALSE, pRouterIdAttributes ); for( dwIndex = 0; pRouterIdAttributes[dwIndex].dwVendorId != (DWORD)-1; dwIndex++ ); // // Find out the authentication/accounting providers // if ( gblDDMConfigInfo.fFlags & DDM_USING_NT_AUTHENTICATION ) { pRouterIdAttributes[dwIndex].dwVendorId = 311; pRouterIdAttributes[dwIndex].dwType = 6; pRouterIdAttributes[dwIndex].dwValue = 801; dwIndex++; } else if ( gblDDMConfigInfo.fFlags & DDM_USING_RADIUS_AUTHENTICATION ) { pRouterIdAttributes[dwIndex].dwVendorId = 311; pRouterIdAttributes[dwIndex].dwType = 6; pRouterIdAttributes[dwIndex].dwValue = 802; dwIndex++; } if ( gblDDMConfigInfo.fFlags & DDM_USING_RADIUS_ACCOUNTING ) { pRouterIdAttributes[dwIndex].dwVendorId = 311; pRouterIdAttributes[dwIndex].dwType = 6; pRouterIdAttributes[dwIndex].dwValue = 803; dwIndex++; } if ( gblDDMConfigInfo.fArapAllowed ) { // AppleTalkRAS(ATCP): Vendor= MS, TypeMajor= 6, TypeMinor= 504 // pRouterIdAttributes[dwIndex].dwVendorId = 311; pRouterIdAttributes[dwIndex].dwType = 6; pRouterIdAttributes[dwIndex].dwValue = 504; dwIndex++; } // // Terminate the array // pRouterIdAttributes[dwIndex].dwVendorId = (DWORD)-1; pRouterIdAttributes[dwIndex].dwType = (DWORD)-1; pRouterIdAttributes[dwIndex].dwValue = (DWORD)-1; return( NO_ERROR ); } //** // // Call: GetNextAccountingSessionId // // Returns: Next Accounting session Id to use // // Description: Called by PPP to get the next accounting session ID // to use the next accouting request sent to the accounting // provider. // DWORD GetNextAccountingSessionId( VOID ) { DWORD dwAccountingSessionId; EnterCriticalSection( &(gblDDMConfigInfo.CSAccountingSessionId) ); dwAccountingSessionId = (gblDDMConfigInfo.dwAccountingSessionId++); LeaveCriticalSection( &(gblDDMConfigInfo.CSAccountingSessionId) ); return( dwAccountingSessionId ); } //** // // Call: LoadIpHlpApiDll // // Returns: NO_ERROR - Success // Non-zero returns - Failure // // Description: Loads iphlpapi.dll and gets the proc addresses of // AllocateAndGetIfTableFromStack and // AllocateAndGetIpAddrTableFromStack. These values are stored in // gblDDMConfigInfo. If anything fails, the variables in // gblDDMConfigInfo remain NULL, and no cleanup is necessary. // DWORD LoadIpHlpApiDll( VOID ) { DWORD dwResult = NO_ERROR; if ( gblDDMConfigInfo.hIpHlpApi != NULL ) { RTASSERT( gblDDMConfigInfo.lpfnAllocateAndGetIfTableFromStack != NULL ); RTASSERT( gblDDMConfigInfo.lpfnAllocateAndGetIpAddrTableFromStack != NULL ); return ( NO_ERROR ); } do { gblDDMConfigInfo.hIpHlpApi = LoadLibrary(TEXT("iphlpapi.dll")); if ( gblDDMConfigInfo.hIpHlpApi == NULL ) { dwResult = GetLastError(); DDM_PRINT( gblDDMConfigInfo.dwTraceId, TRACE_FSM, "LoadLibrary(iphlpapi.dll) failed: %d", dwResult); break; } gblDDMConfigInfo.lpfnAllocateAndGetIfTableFromStack = (ALLOCATEANDGETIFTABLEFROMSTACK) GetProcAddress( gblDDMConfigInfo.hIpHlpApi, "AllocateAndGetIfTableFromStack" ); if ( gblDDMConfigInfo.lpfnAllocateAndGetIfTableFromStack == NULL ) { dwResult = GetLastError(); DDM_PRINT( gblDDMConfigInfo.dwTraceId, TRACE_FSM, "GetProcAddress( AllocateAndGetIfTableFromStack ) " "failed: %d", dwResult); break; } gblDDMConfigInfo.lpfnAllocateAndGetIpAddrTableFromStack = (ALLOCATEANDGETIPADDRTABLEFROMSTACK) GetProcAddress( gblDDMConfigInfo.hIpHlpApi, "AllocateAndGetIpAddrTableFromStack" ); if ( gblDDMConfigInfo.lpfnAllocateAndGetIpAddrTableFromStack == NULL ) { dwResult = GetLastError(); DDM_PRINT( gblDDMConfigInfo.dwTraceId, TRACE_FSM, "GetProcAddress( AllocateAndGetIpAddrTableFromStack ) " "failed: %d", dwResult); break; } } while ( FALSE ); if ( dwResult != NO_ERROR ) { gblDDMConfigInfo.lpfnAllocateAndGetIfTableFromStack = NULL; gblDDMConfigInfo.lpfnAllocateAndGetIpAddrTableFromStack = NULL; if ( gblDDMConfigInfo.hIpHlpApi != NULL ) { FreeLibrary( gblDDMConfigInfo.hIpHlpApi ); gblDDMConfigInfo.hIpHlpApi = NULL; } } return( dwResult ); } //** // // Call: LogUnreachabilityEvent // // Returns: NO_ERROR - Success // Non-zero returns - Failure // // Description: // VOID LogUnreachabilityEvent( IN DWORD dwReason, IN LPWSTR lpwsInterfaceName ) { DWORD dwEventLogId = 0; switch( dwReason ) { case INTERFACE_OUT_OF_RESOURCES: dwEventLogId = ROUTERLOG_IF_UNREACHABLE_REASON1; break; case INTERFACE_CONNECTION_FAILURE: dwEventLogId = ROUTERLOG_IF_UNREACHABLE_REASON2; break; case INTERFACE_DISABLED: dwEventLogId = ROUTERLOG_IF_UNREACHABLE_REASON3; break; case INTERFACE_SERVICE_IS_PAUSED: dwEventLogId = ROUTERLOG_IF_UNREACHABLE_REASON4; break; case INTERFACE_DIALOUT_HOURS_RESTRICTION: dwEventLogId = ROUTERLOG_IF_UNREACHABLE_REASON5; break; case INTERFACE_NO_MEDIA_SENSE: dwEventLogId = ROUTERLOG_IF_UNREACHABLE_REASON6; break; case INTERFACE_NO_DEVICE: dwEventLogId = ROUTERLOG_IF_UNREACHABLE_REASON7; break; default: dwEventLogId = 0; break; } if ( dwEventLogId != 0 ) { DDMLogInformation( dwEventLogId, 1, &lpwsInterfaceName ); } } //** // // Call: GetLocalNASIpAddress // // Returns: IP address of Local Machine - Success // 0 - Failure // // Description: Will get the IP address of this NAS to be sent to the back-end // authentication module, if IP is installed on the local machine, // otherwise it will // DWORD GetLocalNASIpAddress( VOID ) { DWORD dwResult, i, j, dwSize; DWORD dwIpAddress; PMIB_IFTABLE pIfTable; PMIB_IPADDRTABLE pIpAddrTable; dwResult = LoadIpHlpApiDll(); if ( dwResult != NO_ERROR ) { return( 0 ); } dwSize = 0; dwResult = gblDDMConfigInfo.lpfnAllocateAndGetIfTableFromStack( &pIfTable, FALSE, GetProcessHeap(), HEAP_ZERO_MEMORY, TRUE); if ( dwResult != NO_ERROR ) { return( 0 ); } if( pIfTable->dwNumEntries == 0 ) { LocalFree( pIfTable ); return( 0 ); } // // Ok so now we have the IF Table, get the corresponding IP Address table // dwResult = gblDDMConfigInfo.lpfnAllocateAndGetIpAddrTableFromStack( &pIpAddrTable, FALSE, GetProcessHeap(), HEAP_ZERO_MEMORY); if ( dwResult != NO_ERROR ) { LocalFree( pIfTable ); return( 0 ); } if ( pIpAddrTable->dwNumEntries == 0 ) { LocalFree( pIfTable ); LocalFree( pIpAddrTable ); return( 0 ); } for ( i = 0; i < pIfTable->dwNumEntries; i++ ) { // // Go through the interface trying to find a good one // if((pIfTable->table[i].dwType == MIB_IF_TYPE_PPP) || (pIfTable->table[i].dwType == MIB_IF_TYPE_SLIP) || (pIfTable->table[i].dwType == MIB_IF_TYPE_LOOPBACK)) { // // Dont want any of these // continue; } for ( j = 0; j < pIpAddrTable->dwNumEntries; j++ ) { if( pIpAddrTable->table[j].dwIndex == pIfTable->table[i].dwIndex ) { if( pIpAddrTable->table[j].dwAddr == 0x00000000 ) { // // An invalid address // continue; } LocalFree( pIfTable ); dwIpAddress = WireToHostFormat32( (CHAR*)&(pIpAddrTable->table[j].dwAddr)); LocalFree( pIpAddrTable ); return( dwIpAddress ); } } } LocalFree( pIfTable ); LocalFree( pIpAddrTable ); return( 0 ); } DWORD ModifyDefPolicyToForceEncryption( IN BOOL bStrong) { HANDLE hServer = NULL; DWORD dwErr = NO_ERROR, dwType, dwSize, dwFlags = 0; HKEY hkFlags = NULL; do { dwErr = MprAdminUserServerConnect(NULL, TRUE, &hServer); if (dwErr != NO_ERROR) { break; } dwErr = MprAdminUserWriteProfFlags( hServer, (bStrong) ? MPR_USER_PROF_FLAG_FORCE_STRONG_ENCRYPTION : MPR_USER_PROF_FLAG_FORCE_ENCRYPTION); // DISP_E_MEMBERNOTFOUND returned from MprAdminUserWriteProfFlags means that // there is no default policy either because there are no policies or because // there are more than one. // // If there is no default policy, then we should continue on this function // to clear the bits. // if ((dwErr != DISP_E_MEMBERNOTFOUND) && (dwErr != NO_ERROR)) { break; } dwErr = RegOpenKeyExW( HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Services\\RemoteAccess\\Parameters", 0, KEY_READ | KEY_WRITE, &hkFlags); if (dwErr != ERROR_SUCCESS) { break; } dwType = REG_DWORD; dwSize = sizeof(DWORD); dwErr = RegQueryValueExW( hkFlags, L"ServerFlags", NULL, &dwType, (LPBYTE)&dwFlags, &dwSize); if (dwErr != ERROR_SUCCESS) { break; } dwFlags &= ~PPPCFG_RequireEncryption; dwFlags &= ~PPPCFG_RequireStrongEncryption; dwErr = RegSetValueExW( hkFlags, L"ServerFlags", 0, dwType, (CONST BYTE*)&dwFlags, dwSize); if (dwErr != ERROR_SUCCESS) { break; } } while (FALSE); // Cleanup { if (hServer) { MprAdminUserServerDisconnect(hServer); } if (hkFlags) { RegCloseKey(hkFlags); } } return dwErr; } DWORD MungePhoneNumber( char *cbphno, DWORD dwIndex, DWORD *pdwSizeofMungedPhNo, char **ppszMungedPhNo ) { DWORD dwErr = ERROR_SUCCESS; BOOL fDigital = FALSE; WCHAR *pwszAddress; char *pszMungedPhNo; DWORD dwSizeofMungedPhNo; *ppszMungedPhNo = cbphno; *pdwSizeofMungedPhNo = strlen(cbphno); do { if( (NULL == cbphno) || ('\0' == cbphno[0]) || ('\0' == cbphno[1])) { break; } // // find out if the cbphno is digital or analog // if( ( ('D' == cbphno[0]) || ('d' == cbphno[0])) && (':' == cbphno[1])) { fDigital = TRUE; } if(fDigital) { if(0 == gblDDMConfigInfo.cDigitalIPAddresses) { break; } dwIndex = (dwIndex % gblDDMConfigInfo.cDigitalIPAddresses); pwszAddress = gblDDMConfigInfo.apDigitalIPAddresses[dwIndex]; } else { if(0 == gblDDMConfigInfo.cAnalogIPAddresses) { break; } dwIndex = (dwIndex % gblDDMConfigInfo.cAnalogIPAddresses); pwszAddress = gblDDMConfigInfo.apAnalogIPAddresses[dwIndex]; } dwSizeofMungedPhNo = strlen(cbphno) + wcslen(pwszAddress) + 2; // +2 is for a space and terminating NULL; pszMungedPhNo = LocalAlloc( LPTR, dwSizeofMungedPhNo); if(NULL == pszMungedPhNo) { dwErr = GetLastError(); break; } sprintf(pszMungedPhNo, "%ws %s", pwszAddress, cbphno); *ppszMungedPhNo = pszMungedPhNo; *pdwSizeofMungedPhNo = dwSizeofMungedPhNo; } while (FALSE); return dwErr; } WCHAR * GetIpAddress(DWORD dwIpAddress) { struct in_addr ipaddr; CHAR *pszaddr; WCHAR *pwszaddr = NULL; ipaddr.s_addr = dwIpAddress; pszaddr = inet_ntoa(ipaddr); if(NULL != pszaddr) { DWORD cb; cb = MultiByteToWideChar( CP_ACP, 0, pszaddr, -1, NULL, 0); pwszaddr = LocalAlloc(LPTR, cb * sizeof(WCHAR)); if (pwszaddr == NULL) { return NULL; } cb = MultiByteToWideChar( CP_ACP, 0, pszaddr, -1, pwszaddr, cb); if (!cb) { LocalFree(pwszaddr); return NULL; } } return pwszaddr; } //** // // Call: RemoveQuarantineOnConnection // // Returns: ERROR_SUCCESS if function succeeded. // // Description: Will remove any quarantine filters if // they had been plumbed and will plumb regular filters // if available. Then it will queue a workitem to ppp's // worker thread to give it a chance to remove quarantine- // session-timer. NOTE: gblDeviceTable's lock should be // held before calling this function. // DWORD RemoveQuarantineOnConnection(CONNECTION_OBJECT *pConnObj) { DWORD dwErr = ERROR_SUCCESS; ROUTER_INTERFACE_OBJECT *pIfObject; BOOL fLocked = FALSE; PRTR_INFO_BLOCK_HEADER pClientInterface = NULL; // // Do the work here to remove the quarantine filters // and to add the actual filters. Then delete the // filters maintained in the connection object. // if(NULL != pConnObj->pQuarantineFilter) { DWORD dwIndex; DIM_ROUTER_INTERFACE *pDdmRouterIf = NULL; DWORD dwTransportIndex; DWORD dwInfoSize; PRTR_INFO_BLOCK_HEADER pFilter; DWORD i; PRTR_INFO_BLOCK_HEADER pTempClientInterface; EnterCriticalSection(&gblpInterfaceTable->CriticalSection); fLocked = TRUE; dwTransportIndex = GetTransportIndex(PID_IP); if((DWORD) -1 == dwTransportIndex) { dwErr = ERROR_NO_SUCH_INTERFACE; goto done; } pIfObject = IfObjectGetPointer(pConnObj->hDIMInterface); if(NULL == pIfObject) { dwErr = ERROR_NO_SUCH_INTERFACE; goto done; } // // Now run through the quarantine filters and remove them from // the blob. // pClientInterface = (PRTR_INFO_BLOCK_HEADER) pConnObj->pQuarantineFilter; pFilter = (PRTR_INFO_BLOCK_HEADER) pConnObj->pFilter; for(i = 0; i < pClientInterface->TocEntriesCount; i++) { // // Set the QuarantineFilters size to 0 only if its // not present in the regular filters because then // we want to delete the filter. Otherwisewe only // change the filter. // if( (NULL == pFilter) || (!MprInfoBlockExists(pFilter, pClientInterface->TocEntry[i].InfoType))) { pClientInterface->TocEntry[i].InfoSize = 0; } } if(NULL != pFilter) { // // Now run through the regular filters and add them // for(i = 0; i < pFilter->TocEntriesCount; i++) { // // Remove the block if its present note we would not // have zero'd out the size of the filter is present // in the pFilter. // dwErr = MprInfoBlockRemove(pClientInterface, pFilter->TocEntry[i].InfoType, &pTempClientInterface); if(NO_ERROR == dwErr) { MprInfoDelete(pClientInterface); pClientInterface = pTempClientInterface; } dwErr = MprInfoBlockAdd( pClientInterface, pFilter->TocEntry[i].InfoType, pFilter->TocEntry[i].InfoSize, pFilter->TocEntry[i].Count, GetInfoFromTocEntry(pFilter, &pFilter->TocEntry[i]), &pTempClientInterface); if(dwErr != ERROR_SUCCESS) { goto done; } MprInfoDelete(pClientInterface); pClientInterface = pTempClientInterface; pTempClientInterface = NULL; } } // // Now set the modified info on the interface // dwErr = gblRouterManagers[dwTransportIndex].DdmRouterIf.SetInterfaceInfo( pIfObject->Transport[dwTransportIndex].hInterface, pClientInterface); if(dwErr != ERROR_SUCCESS) { goto done; } } if(!(pConnObj->fFlags & CONN_OBJ_QUARANTINE_PRESENT)) { dwErr = ERROR_NOT_FOUND; goto done; } done: // // Queue a message to ppp to remove quarantine if we have // a valid connection. // if(NULL != pConnObj) { // // Send message to ppp to remove the session timer // if any. The following function will just queue // a work item to ppp's thread and return. // (VOID) PppDdmRemoveQuarantine(pConnObj->hConnection); pConnObj->fFlags &= (~CONN_OBJ_QUARANTINE_PRESENT); } if(NULL != pClientInterface) { MprInfoDelete(pClientInterface); } if(NULL != pConnObj->pQuarantineFilter) { pConnObj->pQuarantineFilter = NULL; } if(NULL != pConnObj->pFilter) { MprInfoDelete(pConnObj->pFilter); pConnObj->pFilter = NULL; } if(fLocked) { LeaveCriticalSection(&gblpInterfaceTable->CriticalSection); } return dwErr; } #ifdef MEM_LEAK_CHECK //** // // Call: DebugAlloc // // Returns: return from HeapAlloc // // Description: Will use the memory table to store the pointer returned by // LocalAlloc // LPVOID DebugAlloc( IN DWORD Flags, IN DWORD dwSize ) { DWORD Index; LPBYTE pMem = (LPBYTE)HeapAlloc( gblDDMConfigInfo.hHeap, HEAP_ZERO_MEMORY,dwSize+8); if ( pMem == NULL ) return( pMem ); for( Index=0; Index < DDM_MEM_TABLE_SIZE; Index++ ) { if ( DdmMemTable[Index] == NULL ) { DdmMemTable[Index] = pMem; break; } } *((LPDWORD)pMem) = dwSize; pMem += 4; // // Our signature // *(pMem+dwSize) = 0x0F; *(pMem+dwSize+1) = 0x0E; *(pMem+dwSize+2) = 0x0A; *(pMem+dwSize+3) = 0x0B; RTASSERT( Index != DDM_MEM_TABLE_SIZE ); return( (LPVOID)pMem ); } //** // // Call: DebugFree // // Returns: return from HeapFree // // Description: Will remove the pointer from the memory table before freeing // the memory block // BOOL DebugFree( IN LPVOID pMem ) { DWORD Index; pMem = ((LPBYTE)pMem) - 4; for( Index=0; Index < DDM_MEM_TABLE_SIZE; Index++ ) { if ( DdmMemTable[Index] == pMem ) { DdmMemTable[Index] = NULL; break; } } RTASSERT( Index != DDM_MEM_TABLE_SIZE ); return( HeapFree( gblDDMConfigInfo.hHeap, 0, pMem ) ); } //** // // Call: DebugReAlloc // // Returns: return from HeapReAlloc // // Description: Will change the value of the realloced pointer. // LPVOID DebugReAlloc( PVOID pMem, DWORD dwSize ) { DWORD Index; if ( pMem == NULL ) { RTASSERT(FALSE); } for( Index=0; Index < DDM_MEM_TABLE_SIZE; Index++ ) { if ( DdmMemTable[Index] == pMem ) { DdmMemTable[Index] = HeapReAlloc( gblDDMConfigInfo.hHeap, HEAP_ZERO_MEMORY, pMem, dwSize+8 ); pMem = DdmMemTable[Index]; *((LPDWORD)pMem) = dwSize; ((LPBYTE)pMem) += 4; // // Our signature // *(((LPBYTE)pMem)+dwSize) = 0x0F; *(((LPBYTE)pMem)+dwSize+1) = 0x0E; *(((LPBYTE)pMem)+dwSize+2) = 0x0A; *(((LPBYTE)pMem)+dwSize+3) = 0x0B; break; } } RTASSERT( Index != DDM_MEM_TABLE_SIZE ); return( (LPVOID)pMem ); } #endif