/**********************************************************************/ /** Microsoft Windows NT **/ /** Copyright(c) Microsoft Corp., 1994 **/ /**********************************************************************/ /* tcputil.cxx This module contains common utility routines for the TCP services FILE HISTORY: Johnl 09-Oct-1994 Created. MuraliK Miscellaneous Mods MuraliK 03-Oct-1995 Added optimized InetNtoa() */ #include "tcpdllp.hxx" // // Public functions. // LPSTR ConvertUnicodeToAnsi( IN LPCWSTR lpszUnicode, IN LPSTR lpszAnsi ) /*++ Description: Converts given null-terminated string into ANSI in the buffer supplied. Arguments: lpszUnicode null-terminated string in Unicode lpszAnsi buffer supplied to copy string after conversion. if ( lpszAnsi == NULL), then this module allocates space using TCP_ALLOC, which should be freed calling TCP_FREE by user. Returns: pointer to converted ANSI string. NULL on errors. History: MuraliK 12-01-1994 Created. --*/ { #ifndef CHICAGO DWORD cchLen; LPSTR lpszAlloc = NULL; if ( lpszUnicode == NULL) { return (NULL); } cchLen = wcslen( lpszUnicode); if ( lpszAnsi == NULL) { #ifdef JAPAN // ntbug #35081 lpszAlloc = (LPSTR ) TCP_ALLOC( (cchLen + 1) * sizeof(CHAR) * 2); #else lpszAlloc = (LPSTR ) TCP_ALLOC( (cchLen + 1) * sizeof(CHAR)); #endif } else { lpszAlloc = lpszAnsi; } if ( lpszAlloc != NULL) { cchLen = WideCharToMultiByte( CP_ACP, WC_COMPOSITECHECK, lpszUnicode, -1, lpszAlloc, #ifdef JAPAN // ntbug #35081 (cchLen + 1) * sizeof(CHAR) * 2, #else (cchLen + 1) * sizeof(CHAR), #endif NULL, // lpszDefaultChar NULL // lpfDefaultUsed ); if ( cchLen == 0) { // There was a failure. Free up buffer if need be. if ( lpszAnsi == NULL) { // we alloced buffer. Now we will free it. TCP_FREE( lpszAlloc); lpszAlloc = NULL; } } } return ( lpszAlloc); #else if ( lpszUnicode == NULL) { return (NULL); } if ( lpszAnsi == NULL ) { return NULL; } WideCharToMultiByte( 0, 0, lpszUnicode, lstrlenW(lpszUnicode), lpszAnsi, 2*lstrlenW(lpszUnicode), NULL, NULL); return lpszAnsi; #endif } // ConvertUnicodeToAnsi() /******************************************************************* NAME: ReadRegistryDword SYNOPSIS: Reads a DWORD value from the registry. ENTRY: hkey - Openned registry key to read pszValueName - The name of the value. dwDefaultValue - The default value to use if the value cannot be read. RETURNS DWORD - The value from the registry, or dwDefaultValue. ********************************************************************/ DWORD ReadRegistryDwordA( HKEY hkey, LPCSTR pszValueName, DWORD dwDefaultValue ) { DWORD err; DWORD dwBuffer; DWORD cbBuffer = sizeof(dwBuffer); DWORD dwType; #ifndef CHICAGO if( hkey != NULL ) { err = RegQueryValueExA( hkey, pszValueName, NULL, &dwType, (LPBYTE)&dwBuffer, &cbBuffer ); if( ( err == NO_ERROR ) && ( dwType == REG_DWORD ) ) { dwDefaultValue = dwBuffer; } } #else if( hkey != NULL ) { err = RegQueryValueEx( hkey, pszValueName, NULL, &dwType, (LPBYTE)&dwBuffer, &cbBuffer ); if( ( err == NO_ERROR ) ) { dwDefaultValue = dwBuffer; } } #endif return dwDefaultValue; } // ReadRegistryDwordA() /******************************************************************* NAME: ReadRegistryDwordW SYNOPSIS: Reads a DWORD value from the registry. ENTRY: hkey - Openned registry key to read pszValueName - The name of the value. dwDefaultValue - The default value to use if the value cannot be read. RETURNS DWORD - The value from the registry, or dwDefaultValue. NOTES: This function cannot be called until after InitializeGlobals(). HISTORY: MuraliK 03-Feb-1995 Created. ********************************************************************/ DWORD ReadRegistryDwordW( HKEY hkey, LPCWSTR pszValueName, DWORD dwDefaultValue ) { DWORD err; DWORD dwBuffer; DWORD cbBuffer = sizeof(dwBuffer); DWORD dwType; #ifndef CHICAGO if( hkey != NULL ) { err = RegQueryValueExW( hkey, pszValueName, NULL, &dwType, (LPBYTE)&dwBuffer, &cbBuffer ); if( ( err == NO_ERROR ) && ( dwType == REG_DWORD ) ) { dwDefaultValue = dwBuffer; } } #else if( hkey != NULL ) { CHAR szValueA[MAX_PATH]; DWORD cch; *szValueA = '0'; cch = WideCharToMultiByte(CP_ACP, 0, pszValueName, -1, szValueA, sizeof(szValueA)/sizeof(CHAR), NULL,NULL ); err = RegQueryValueEx( hkey, szValueA, NULL, &dwType, (LPBYTE)&dwBuffer, &cbBuffer ); if( ( err == NO_ERROR ) && ( dwType == REG_DWORD ) ) { dwDefaultValue = dwBuffer; } } #endif return dwDefaultValue; } // ReadRegistryDwordW() DWORD WriteRegistryDwordA( IN HKEY hkey, IN LPCSTR pszValueName, IN DWORD dwValue) /*++ Description: Writes the given DWORD value into registry entry specified by hkey\pszValueName Arguments: hkey handle to registry key pszValueName name of the value dwValue new value for write Returns: Win32 error codes. NO_ERROR if successful. History: MuraliK 12-01-1994 Created. --*/ { DWORD err; if ( hkey == NULL || pszValueName == NULL) { err = ( ERROR_INVALID_PARAMETER); } else { err = RegSetValueExA( hkey, pszValueName, 0, REG_DWORD, (LPBYTE ) &dwValue, sizeof( dwValue)); } return ( err); } // WriteRegistryDwordA() DWORD WriteRegistryDwordW( IN HKEY hkey, IN LPCWSTR pszValueName, IN DWORD dwValue) /*++ Description: Writes the given DWORD value into registry entry specified by hkey\pszValueName Arguments: hkey handle to registry key pszValueName name of the value dwValue new value for write Returns: Win32 error codes. NO_ERROR if successful. History: MuraliK 12-01-1994 Created. --*/ { DWORD err; if ( hkey == NULL || pszValueName == NULL) { err = ( ERROR_INVALID_PARAMETER); } else { err = RegSetValueExW( hkey, pszValueName, 0, REG_DWORD, (LPBYTE ) &dwValue, sizeof( dwValue)); } return ( err); } // WriteRegistryDwordW() DWORD WriteRegistryStringA( IN HKEY hkey, IN LPCSTR pszValueName, IN LPCSTR pszValue, IN DWORD cbValue, IN DWORD fdwType) /*++ Description: Writes the given ANSI String into registry entry specified by hkey\pszValueName. Arguments: hkey handle to registry key pszValueName name of the value pszValue new value for write cbValue count of bytes of value written. Should include terminating null characters. fdwType type of the value being written ( REG_SZ, REG_MULTI_SZ etc) Returns: Win32 error codes. NO_ERROR if successful. History: MuraliK 12-01-1994 Created. --*/ { DWORD err; if ( hkey == NULL || pszValueName == NULL || cbValue == 0 ) { err = ERROR_INVALID_PARAMETER; } else { err = RegSetValueExA( hkey, pszValueName, 0, fdwType, (LPBYTE ) pszValue, cbValue); // + 1 for null character } return ( err); } // WriteRegistryStringA() DWORD WriteRegistryStringW( IN HKEY hkey, IN LPCWSTR pszValueName, IN LPCWSTR pszValue, IN DWORD cbValue, IN DWORD fdwType) /*++ Description: Writes the given ANSI String into registry entry specified by hkey\pszValueName. Arguments: hkey handle to registry key pszValueName name of the value pszValue new value for write cbValue count of bytes of value written. Should include terminating null characters. fdwType type of the value being written ( REG_SZ, REG_MULTI_SZ etc) Returns: Win32 error codes. NO_ERROR if successful. History: MuraliK 12-01-1994 Created. --*/ { DWORD err; if ( hkey == NULL || pszValueName == NULL || cbValue == 0 ) { err = ERROR_INVALID_PARAMETER; } else { err = RegSetValueExW( hkey, pszValueName, 0, fdwType, (LPBYTE ) pszValue, cbValue); } return ( err); } // WriteRegistryStringW() /******************************************************************* NAME: ReadRegistryString SYNOPSIS: Allocates necessary buffer space for a registry string, then reads the string into the buffer. ENTRY: pszValueName - The name of the value. pszDefaultValue - The default value to use if the value cannot be read. fExpand - Expand environment strings if TRUE. RETURNS: TCHAR * - The string, NULL if error. NOTES: I always allocate one more character than actually necessary. This will ensure that any code expecting to read a REG_MULTI_SZ will not explode if the registry actually contains a REG_SZ. This function cannot be called until after InitializeGlobals(). HISTORY: KeithMo 15-Mar-1993 Created. ********************************************************************/ TCHAR * ReadRegistryString( HKEY hkey, LPCTSTR pszValueName, LPCTSTR pszDefaultValue, BOOL fExpand ) { TCHAR * pszBuffer1; TCHAR * pszBuffer2; DWORD cbBuffer; DWORD dwType; DWORD err; // // Determine the buffer size. // pszBuffer1 = NULL; pszBuffer2 = NULL; cbBuffer = 0; if( hkey == NULL ) { // // Pretend the key wasn't found. // err = ERROR_FILE_NOT_FOUND; } else { err = RegQueryValueEx( hkey, pszValueName, NULL, &dwType, NULL, &cbBuffer ); if( ( err == NO_ERROR ) || ( err == ERROR_MORE_DATA ) ) { if( ( dwType != REG_SZ ) && ( dwType != REG_MULTI_SZ ) && ( dwType != REG_EXPAND_SZ ) ) { // // Type mismatch, registry data NOT a string. // Use default. // err = ERROR_FILE_NOT_FOUND; } else { // // Item found, allocate a buffer. // pszBuffer1 = (TCHAR *) TCP_ALLOC( cbBuffer+sizeof(TCHAR) ); if( pszBuffer1 == NULL ) { err = GetLastError(); } else { // // Now read the value into the buffer. // err = RegQueryValueEx( hkey, pszValueName, NULL, NULL, (LPBYTE)pszBuffer1, &cbBuffer ); } } } } if( err == ERROR_FILE_NOT_FOUND ) { // // Item not found, use default value. // err = NO_ERROR; if( pszDefaultValue != NULL ) { pszBuffer1 = (TCHAR *)TCP_ALLOC( (_tcslen(pszDefaultValue)+1) * sizeof(TCHAR) ); if( pszBuffer1 == NULL ) { err = GetLastError(); } else { _tcscpy( pszBuffer1, pszDefaultValue ); } } } if( err != NO_ERROR ) { // // Tragic error reading registry, abort now. // goto ErrorCleanup; } // // pszBuffer1 holds the registry value. Now expand // the environment strings if necessary. // #ifndef CHICAGO if( !fExpand ) { return pszBuffer1; } #else return pszBuffer1; #endif // // Returns number of characters // cbBuffer = ExpandEnvironmentStrings( pszBuffer1, NULL, 0 ); pszBuffer2 = (TCHAR *) TCP_ALLOC( (cbBuffer+1)*sizeof(TCHAR) ); if( pszBuffer2 == NULL ) { goto ErrorCleanup; } if( ExpandEnvironmentStrings( pszBuffer1, pszBuffer2, cbBuffer ) > cbBuffer ) { goto ErrorCleanup; } // // pszBuffer2 now contains the registry value with // environment strings expanded. // TCP_FREE( pszBuffer1 ); pszBuffer1 = NULL; return pszBuffer2; ErrorCleanup: // // Something tragic happend; free any allocated buffers // and return NULL to the caller, indicating failure. // if( pszBuffer1 != NULL ) { TCP_FREE( pszBuffer1 ); pszBuffer1 = NULL; } if( pszBuffer2 != NULL ) { TCP_FREE( pszBuffer2 ); pszBuffer2 = NULL; } return NULL; } // ReadRegistryString // // Chicago does not support the REG_MULTI_SZ registry value. As // a hack (er, workaround), we'll create *keys* in the registry // in place of REG_MULTI_SZ *values*. We'll then use the names // of any values under the key as the REG_MULTI_SZ entries. So, // instead of this: // // ..\Control\ServiceProvider // ProviderOrder = REG_MULTI_SZ "MSTCP" // "NWLINK" // "FOOBAR" // // We'll use this: // // ..\Control\Service\Provider\ProviderOrder // MSTCP = REG_SZ "" // NWLINK = REG_SZ "" // FOOBAR = REG_SZ "" // // This function takes an open registry key handle, enumerates // the names of values contained within the key, and constructs // a REG_MULTI_SZ string from the value names. // // Note that this function is not multithread safe; if another // thread (or process) creates or deletes values under the // specified key, the results are indeterminate. // // This function returns NULL on error. It returns non-NULL // on success, even if the resulting REG_MULTI_SZ is empty. // TCHAR * KludgeMultiSz( HKEY hkey, LPDWORD lpdwLength ) { LONG err; DWORD iValue; DWORD cchTotal; DWORD cchValue; TCHAR szValue[MAX_PATH]; LPTSTR lpMultiSz; LPTSTR lpTmp; LPTSTR lpEnd; // // Enumerate the values and total up the lengths. // iValue = 0; cchTotal = 0; for( ; ; ) { cchValue = sizeof(szValue)/sizeof(TCHAR); err = RegEnumValue( hkey, iValue, szValue, &cchValue, NULL, NULL, NULL, NULL ); if( err != NO_ERROR ) { break; } // // Add the length of the value's name, plus one // for the terminator. // cchTotal += _tcslen( szValue ) + 1; // // Advance to next value. // iValue++; } // // Add one for the final terminating NULL. // cchTotal++; *lpdwLength = cchTotal; // // Allocate the MULTI_SZ buffer. // lpMultiSz = (TCHAR *) TCP_ALLOC( cchTotal * sizeof(TCHAR) ); if( lpMultiSz == NULL ) { SetLastError( ERROR_NOT_ENOUGH_MEMORY ); return NULL; } memset( lpMultiSz, 0, cchTotal * sizeof(TCHAR) ); // // Enumerate the values and append to the buffer. // iValue = 0; lpTmp = lpMultiSz; lpEnd = lpMultiSz + cchTotal; for( ; ; ) { cchValue = sizeof(szValue)/sizeof(TCHAR); err = RegEnumValue( hkey, iValue, szValue, &cchValue, NULL, NULL, NULL, NULL ); if( err != NO_ERROR ) { break; } // // Compute the length of the value name (including // the terminating NULL). // cchValue = _tcslen( szValue ) + 1; // // Determine if there is room in the array, taking into // account the second NULL that terminates the string list. // if( ( lpTmp + cchValue + 1 ) > lpEnd ) { break; } // // Append the value name. // _tcscpy( lpTmp, szValue ); lpTmp += cchValue; // // Advance to next value. // iValue++; } // // Success! // return (LPTSTR)lpMultiSz; } // KludgeMultiSz BOOL ReadRegistryStr( IN HKEY hkeyReg, OUT STR & str, IN LPCTSTR lpszValueName, IN LPCTSTR lpszDefaultValue, IN BOOL fExpand ) /*++ Reads the registry string into the string buffer supplied. If there is no value in the registry the default value is set to be the value of the string. If an environment expansion is requested, it is also performed. Arguments: hkeyReg handle for registry entry str string to contain the result of read operation lpszValueName pointer to string containing the key name whose value needs to be fetched. lpszDefaultValue pointer to string containing a value which is used if no value exists in the registry. fExpand boolean flag indicating if an expansion is desired. Returns: FALSE if there is any error. TRUE when the string is successfully set. --*/ { BOOL fReturn = FALSE; LPTSTR pszValueAlloc; pszValueAlloc = ReadRegistryString( hkeyReg, lpszValueName, lpszDefaultValue, fExpand); if ( pszValueAlloc != NULL) { fReturn = str.Copy( pszValueAlloc); TCP_FREE( pszValueAlloc); } else { DBG_ASSERT( fReturn == FALSE); } if ( !fReturn) { IF_DEBUG( ERROR) { DWORD err = GetLastError(); DBGPRINTF(( DBG_CONTEXT, " Error %u in ReadRegistryString( %08x, %s).\n", err, hkeyReg, lpszValueName)); SetLastError(err); } } return ( fReturn); } // ReadRegistryString() /******************************************************************* NAME: FlipSlashes SYNOPSIS: Flips the Unix-ish forward slashes ('/') into Dos-ish back slashes ('\'). ENTRY: pszPath - The path to munge. RETURNS: TCHAR * - pszPath. HISTORY: KeithMo 04-Jun-1993 Created. ********************************************************************/ TCHAR * FlipSlashes( TCHAR * pszPath ) { TCHAR ch; TCHAR * pszScan = pszPath; while( ( ch = *pszScan ) != TEXT('\0') ) { if( ch == TEXT('/') ) { *pszScan = TEXT('\\'); } pszScan++; } return pszPath; } // FlipSlashes /*++ Copyright (c) 1991 Microsoft Corporation Module Name: i_ntoa.c Abstract: This module implements a routine to convert a numerical IP address into a dotted-decimal character string Internet address. Author: Mike Massa (mikemas) Sept 20, 1991 Revision History: Who When What -------- -------- ---------------------------------------------- mikemas 9-20-91 created davidtr 9-19-95 completely rewritten for performance muralik 3-Oct-1995 massaged it for Internet services Notes: Exports: InetNtoa() --*/ #define UC(b) (((int)b)&0xff) // // This preinitialized array defines the strings to be used for // inet_ntoa. The index of each row corresponds to the value for a byte // in an IP address. The first three bytes of each row are the // char/string value for the byte, and the fourth byte in each row is // the length of the string required for the byte. This approach // allows a fast implementation with no jumps. // static BYTE NToACharStrings[][4] = { '0', 'x', 'x', 1, '1', 'x', 'x', 1, '2', 'x', 'x', 1, '3', 'x', 'x', 1, '4', 'x', 'x', 1, '5', 'x', 'x', 1, '6', 'x', 'x', 1, '7', 'x', 'x', 1, '8', 'x', 'x', 1, '9', 'x', 'x', 1, '1', '0', 'x', 2, '1', '1', 'x', 2, '1', '2', 'x', 2, '1', '3', 'x', 2, '1', '4', 'x', 2, '1', '5', 'x', 2, '1', '6', 'x', 2, '1', '7', 'x', 2, '1', '8', 'x', 2, '1', '9', 'x', 2, '2', '0', 'x', 2, '2', '1', 'x', 2, '2', '2', 'x', 2, '2', '3', 'x', 2, '2', '4', 'x', 2, '2', '5', 'x', 2, '2', '6', 'x', 2, '2', '7', 'x', 2, '2', '8', 'x', 2, '2', '9', 'x', 2, '3', '0', 'x', 2, '3', '1', 'x', 2, '3', '2', 'x', 2, '3', '3', 'x', 2, '3', '4', 'x', 2, '3', '5', 'x', 2, '3', '6', 'x', 2, '3', '7', 'x', 2, '3', '8', 'x', 2, '3', '9', 'x', 2, '4', '0', 'x', 2, '4', '1', 'x', 2, '4', '2', 'x', 2, '4', '3', 'x', 2, '4', '4', 'x', 2, '4', '5', 'x', 2, '4', '6', 'x', 2, '4', '7', 'x', 2, '4', '8', 'x', 2, '4', '9', 'x', 2, '5', '0', 'x', 2, '5', '1', 'x', 2, '5', '2', 'x', 2, '5', '3', 'x', 2, '5', '4', 'x', 2, '5', '5', 'x', 2, '5', '6', 'x', 2, '5', '7', 'x', 2, '5', '8', 'x', 2, '5', '9', 'x', 2, '6', '0', 'x', 2, '6', '1', 'x', 2, '6', '2', 'x', 2, '6', '3', 'x', 2, '6', '4', 'x', 2, '6', '5', 'x', 2, '6', '6', 'x', 2, '6', '7', 'x', 2, '6', '8', 'x', 2, '6', '9', 'x', 2, '7', '0', 'x', 2, '7', '1', 'x', 2, '7', '2', 'x', 2, '7', '3', 'x', 2, '7', '4', 'x', 2, '7', '5', 'x', 2, '7', '6', 'x', 2, '7', '7', 'x', 2, '7', '8', 'x', 2, '7', '9', 'x', 2, '8', '0', 'x', 2, '8', '1', 'x', 2, '8', '2', 'x', 2, '8', '3', 'x', 2, '8', '4', 'x', 2, '8', '5', 'x', 2, '8', '6', 'x', 2, '8', '7', 'x', 2, '8', '8', 'x', 2, '8', '9', 'x', 2, '9', '0', 'x', 2, '9', '1', 'x', 2, '9', '2', 'x', 2, '9', '3', 'x', 2, '9', '4', 'x', 2, '9', '5', 'x', 2, '9', '6', 'x', 2, '9', '7', 'x', 2, '9', '8', 'x', 2, '9', '9', 'x', 2, '1', '0', '0', 3, '1', '0', '1', 3, '1', '0', '2', 3, '1', '0', '3', 3, '1', '0', '4', 3, '1', '0', '5', 3, '1', '0', '6', 3, '1', '0', '7', 3, '1', '0', '8', 3, '1', '0', '9', 3, '1', '1', '0', 3, '1', '1', '1', 3, '1', '1', '2', 3, '1', '1', '3', 3, '1', '1', '4', 3, '1', '1', '5', 3, '1', '1', '6', 3, '1', '1', '7', 3, '1', '1', '8', 3, '1', '1', '9', 3, '1', '2', '0', 3, '1', '2', '1', 3, '1', '2', '2', 3, '1', '2', '3', 3, '1', '2', '4', 3, '1', '2', '5', 3, '1', '2', '6', 3, '1', '2', '7', 3, '1', '2', '8', 3, '1', '2', '9', 3, '1', '3', '0', 3, '1', '3', '1', 3, '1', '3', '2', 3, '1', '3', '3', 3, '1', '3', '4', 3, '1', '3', '5', 3, '1', '3', '6', 3, '1', '3', '7', 3, '1', '3', '8', 3, '1', '3', '9', 3, '1', '4', '0', 3, '1', '4', '1', 3, '1', '4', '2', 3, '1', '4', '3', 3, '1', '4', '4', 3, '1', '4', '5', 3, '1', '4', '6', 3, '1', '4', '7', 3, '1', '4', '8', 3, '1', '4', '9', 3, '1', '5', '0', 3, '1', '5', '1', 3, '1', '5', '2', 3, '1', '5', '3', 3, '1', '5', '4', 3, '1', '5', '5', 3, '1', '5', '6', 3, '1', '5', '7', 3, '1', '5', '8', 3, '1', '5', '9', 3, '1', '6', '0', 3, '1', '6', '1', 3, '1', '6', '2', 3, '1', '6', '3', 3, '1', '6', '4', 3, '1', '6', '5', 3, '1', '6', '6', 3, '1', '6', '7', 3, '1', '6', '8', 3, '1', '6', '9', 3, '1', '7', '0', 3, '1', '7', '1', 3, '1', '7', '2', 3, '1', '7', '3', 3, '1', '7', '4', 3, '1', '7', '5', 3, '1', '7', '6', 3, '1', '7', '7', 3, '1', '7', '8', 3, '1', '7', '9', 3, '1', '8', '0', 3, '1', '8', '1', 3, '1', '8', '2', 3, '1', '8', '3', 3, '1', '8', '4', 3, '1', '8', '5', 3, '1', '8', '6', 3, '1', '8', '7', 3, '1', '8', '8', 3, '1', '8', '9', 3, '1', '9', '0', 3, '1', '9', '1', 3, '1', '9', '2', 3, '1', '9', '3', 3, '1', '9', '4', 3, '1', '9', '5', 3, '1', '9', '6', 3, '1', '9', '7', 3, '1', '9', '8', 3, '1', '9', '9', 3, '2', '0', '0', 3, '2', '0', '1', 3, '2', '0', '2', 3, '2', '0', '3', 3, '2', '0', '4', 3, '2', '0', '5', 3, '2', '0', '6', 3, '2', '0', '7', 3, '2', '0', '8', 3, '2', '0', '9', 3, '2', '1', '0', 3, '2', '1', '1', 3, '2', '1', '2', 3, '2', '1', '3', 3, '2', '1', '4', 3, '2', '1', '5', 3, '2', '1', '6', 3, '2', '1', '7', 3, '2', '1', '8', 3, '2', '1', '9', 3, '2', '2', '0', 3, '2', '2', '1', 3, '2', '2', '2', 3, '2', '2', '3', 3, '2', '2', '4', 3, '2', '2', '5', 3, '2', '2', '6', 3, '2', '2', '7', 3, '2', '2', '8', 3, '2', '2', '9', 3, '2', '3', '0', 3, '2', '3', '1', 3, '2', '3', '2', 3, '2', '3', '3', 3, '2', '3', '4', 3, '2', '3', '5', 3, '2', '3', '6', 3, '2', '3', '7', 3, '2', '3', '8', 3, '2', '3', '9', 3, '2', '4', '0', 3, '2', '4', '1', 3, '2', '4', '2', 3, '2', '4', '3', 3, '2', '4', '4', 3, '2', '4', '5', 3, '2', '4', '6', 3, '2', '4', '7', 3, '2', '4', '8', 3, '2', '4', '9', 3, '2', '5', '0', 3, '2', '5', '1', 3, '2', '5', '2', 3, '2', '5', '3', 3, '2', '5', '4', 3, '2', '5', '5', 3 }; DWORD InetNtoa( IN struct in_addr inaddr, OUT CHAR * pchBuffer ) /*++ Routine Description: This function takes an Internet address structure specified by the in parameter. It returns an ASCII string representing the address in ".'' notation as "a.b.c.d". Arguments: inaddr - A structure which represents an Internet host address. pchBuffer - pointer to at least 16 character buffer for storing the result of conversion. Return Value: If no error occurs, InetNtoa() returns NO_ERROR with the buffer containing the text address in standard "." notation. Otherwise, it returns Win32 error code. --*/ { PUCHAR p; PUCHAR buffer = (PUCHAR ) pchBuffer; PUCHAR b = buffer; if ( pchBuffer == NULL) { return ( ERROR_INSUFFICIENT_BUFFER); } // // We do not check for sufficient length of the buffer yet. !! // // // In an unrolled loop, calculate the string value for each of the four // bytes in an IP address. Note that for values less than 100 we will // do one or two extra assignments, but we save a test/jump with this // algorithm. // p = (PUCHAR) &inaddr; *b = NToACharStrings[*p][0]; *(b+1) = NToACharStrings[*p][1]; *(b+2) = NToACharStrings[*p][2]; b += NToACharStrings[*p][3]; *b++ = '.'; p++; *b = NToACharStrings[*p][0]; *(b+1) = NToACharStrings[*p][1]; *(b+2) = NToACharStrings[*p][2]; b += NToACharStrings[*p][3]; *b++ = '.'; p++; *b = NToACharStrings[*p][0]; *(b+1) = NToACharStrings[*p][1]; *(b+2) = NToACharStrings[*p][2]; b += NToACharStrings[*p][3]; *b++ = '.'; p++; *b = NToACharStrings[*p][0]; *(b+1) = NToACharStrings[*p][1]; *(b+2) = NToACharStrings[*p][2]; b += NToACharStrings[*p][3]; *b = '\0'; return ( NO_ERROR); } // InetNtoa()