windows-xp/Source/XPSP1/NT/windows/winstate/v1/scanstate/scansys.cxx

//--------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1999 - 2000.
//
// File:        scansys
//
// Contents:    Scan system settings.
//
//---------------------------------------------------------------

#include <scanhead.cxx>
#pragma hdrstop

#include <common.hxx>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <io.h>
#include <objerror.h>
#include <scanstate.hxx>

#include <winuser.h>
#include <winnetwk.h>
#include <winspool.h>
#include <lmerr.h>
#include <lmaccess.h>

// We need to define WINVER to a pre-2000 definition in order to
// pull in the right structure definitions and sizes for correct
// operation on 9x and NT.
#undef WINVER
#define WINVER 0x400

#include <ras.h>
#include <raserror.h>
#include "bothchar.hxx"
#include "scansys.hxx"

//---------------------------------------------------------------

const CHAR SHARES[] = "[NetShares]\r\n";
const CHAR PRINTERS[] = "[Printers]\r\n";
const CHAR RAS[] = "[RAS]\r\n";

#define LINEBUFSIZE 1024

// longest ip address is: XXX.XXX.XXX.XXX\0
#define MAX_IP_ADDRESS 16

const CHAR REGKEY_TIMEZONE[] = "System\\CurrentControlSet\\Control\\TimeZoneInformation";
const CHAR REGVAL_TIMEZONE[] = "StandardName";
const CHAR REGKEY_VERSION[] = "Software\\Microsoft\\Windows NT\\CurrentVersion";
const CHAR REGKEY_VERSION_9x[] = "Software\\Microsoft\\Windows\\CurrentVersion";
const CHAR REGVAL_FULLNAME[] = "RegisteredOwner";
const CHAR REGVAL_ORGNAME[] = "RegisteredOrganization";

const CHAR REGKEY_RAS[] = "System\\CurrentControlSet\\Services\\RemoteAccess";

const CHAR SCRNSAVE[] = "SCRNSAVE.EXE";

const CHAR REGKEY_NT4_PBK[] = "Software\\Microsoft\\RAS Phonebook";
const CHAR REGVAL_NT4_PRS_PBK_LOC[] = "PersonalPhonebookFile";
const CHAR REGVAL_NT4_ALT_PBK_LOC[] = "AlternatePhonebookPath";

const CHAR RAS_NT4_RAS_PATH[] = "system32\\ras";
const CHAR RAS_NT4_SYSTEM_PHONEBOOK[] = "rasphone.pbk";

#define ChkErr(s) if ((dwErr = (s)) != ERROR_SUCCESS) goto Err;

//+---------------------------------------------------------------------------
// Types
// RAS api functions
typedef DWORD
(*MRasEnumEntries)(
    IN LPCSTR reserved,
    IN LPCSTR lpszPhonebook,
    OUT LPRASENTRYNAMEA lprasentryname,
    OUT LPDWORD lpcb,
    OUT LPDWORD lpcEntries);
typedef DWORD
(*MRasGetEntryProperties)(
    IN LPCSTR lpszPhonebook,
    IN LPCSTR lpszEntry,
    OUT LPRASENTRYA lpRasEntry,
    OUT LPDWORD lpdwEntryInfoSize,
    OUT LPBYTE lpbDeviceInfo,
    OUT LPDWORD lpdwDeviceInfoSize);
typedef DWORD
(*MRasGetEntryDialParams)(
    IN LPCSTR lpszPhonebook,
    OUT LPRASDIALPARAMSA lprasdialparams,
    OUT LPBOOL lpfPassword);

//+---------------------------------------------------------------------------
// Statics
static MRasEnumEntries        GRasEnumEntries        = NULL;
static MRasGetEntryProperties GRasGetEntryProperties = NULL;
static MRasGetEntryDialParams GRasGetEntryDialParams = NULL;

//+---------------------------------------------------------------------------
//
//  Function:   InitializeRasApi
//
//  Synopsis:   Loads rasapi32.dll if it exists
//
//  Arguments:  none
//
//  Returns:    Appropriate status code
//
//  History:    24-Feb-00   Jay Thaler   Created
DWORD InitializeRasApi()
{
  DWORD      result = ERROR_SUCCESS;
  HINSTANCE  rasdll;

  // Load rasapi32.dll
  rasdll = LoadLibraryA( "rasapi32.dll" );
  if (rasdll == NULL)
  {
    result = GetLastError();
    if (DebugOutput)
    {
        Win32Printf(STDERR, "Warning: rasapi32.dll not loaded: %d\r\n", result);
    }
    goto cleanup;
  }

  GRasEnumEntries        = (MRasEnumEntries)GetProcAddress(rasdll, "RasEnumEntriesA");
  if (GRasEnumEntries == NULL)
  {
    result = GetLastError();
    goto cleanup;
  }

  GRasGetEntryProperties = (MRasGetEntryProperties)GetProcAddress(rasdll, "RasGetEntryPropertiesA");
  if (GRasGetEntryProperties == NULL)
  {
    result = GetLastError();
    goto cleanup;
  }

  GRasGetEntryDialParams = (MRasGetEntryDialParams)GetProcAddress(rasdll, "RasGetEntryDialParamsA");
  if (GRasGetEntryDialParams == NULL)
  {
    result = GetLastError();
    goto cleanup;
  }

cleanup:
  if (result != ERROR_SUCCESS)
  {
      GRasEnumEntries        = NULL;
      GRasGetEntryProperties = NULL;
      GRasGetEntryDialParams = NULL;
  }
  return result;
}

//+---------------------------------------------------------------------------
//
//  Function:   GetInfField
//
//  Synopsis:   returns an allocated string for current line field #N
//
//  Arguments:  [ppBuffer] -- output buffer
//              [pContext] -- INF file context
//              [nArg] -- argument field number
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD GetInfField (TCHAR **ppBuffer, INFCONTEXT *pContext, DWORD nArg)
{
    ULONG len = 0;
    DWORD dwErr = ERROR_SUCCESS;
    TCHAR *buffer;

    *ppBuffer = NULL;
    if (!SetupGetStringField ( pContext, nArg, NULL, 0, &len ))
        return ERROR_BAD_FORMAT;

    // Allocate a buffer.
    buffer = (TCHAR *) malloc( len*sizeof(TCHAR) );
    if (buffer == NULL)
    {
        dwErr = ERROR_NOT_ENOUGH_MEMORY;
    }
    else
    {
        if (!SetupGetStringField ( pContext, nArg, buffer, len, &len ))
        {
            free( buffer );
            dwErr = ERROR_BAD_FORMAT;
        }
        else *ppBuffer = buffer;
    }

    return dwErr;
}

//+---------------------------------------------------------------------------
//
//  Function:   LogFormatError
//
//  Synopsis:   logs error message in current locale
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD LogFormatError (DWORD dwErr)
{
    DWORD dwRet = ERROR_SUCCESS;
    TCHAR *pcs = NULL;

    if (0 != FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM |
                            FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL,
                            dwErr, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                            (TCHAR*) &pcs, 0, NULL))
    {
        dwRet = Win32Printf (LogFile, "%s\r\n", pcs);
        LocalFree (pcs);
    }
    else dwRet = GetLastError();

    return dwRet;
}

//+---------------------------------------------------------------------------
//
//  Function:   ScanGenerateEncryptKey
//
//  Synopsis:   decode the RAS address BLOB
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

BYTE ScanGenerateEncryptKey (CHAR *szKey)
{
    BYTE   bKey;
    BYTE*  pKey;

    for (bKey = 0, pKey = (BYTE*)szKey; *pKey != 0; pKey++)
    {
        bKey += *pKey;
    };

    return bKey;
}

//+---------------------------------------------------------------------------
//
//  Function:   ScanDecryptEntry
//
//  Synopsis:   decode the RAS address BLOB
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

void ScanDecryptEntry (CHAR * szEntry, BYTE * pEnt, DWORD cb)
{
    // Generate the encryption key from the entry name
    BYTE bKey = ScanGenerateEncryptKey(szEntry);

    // Encrypt the address entry one byte at a time
    for (;cb > 0; cb--, pEnt++)
    {
        *pEnt ^= bKey;
    };
    return;
}

//+---------------------------------------------------------------------------
//
//  Function:   IsRasInstalled
//
//  Synopsis:   determines if RAS is installed
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

BOOL IsRasInstalled ()
{
    HKEY hKey = NULL;
    if (ERROR_SUCCESS == RegOpenKeyExA(HKEY_LOCAL_MACHINE,
                                       REGKEY_RAS,
                                       NULL,
                                       KEY_READ,
                                       &hKey))
    {
        RegCloseKey (hKey);
        return TRUE;
    }
    return FALSE;
}

//----------------------------------------------------------------------------
DWORD RasReadIpAddress(HINF h,
                       const TCHAR *pszEntryName,
                       const TCHAR *pszKeyName,
                       RASIPADDR *lpIpAddr)
{
    BOOL        fSuccess;
    INFCONTEXT  IpAddrLine;
    TCHAR       szIpAddr[MAX_IP_ADDRESS];
    DWORD       dwAddr1, dwAddr2, dwAddr3, dwAddr4;
    DWORD       dwErr = ERROR_SUCCESS;

    fSuccess = SetupFindFirstLine(h,
                                  pszEntryName,
                                  pszKeyName,
                                  &IpAddrLine);

    if (fSuccess == FALSE)
    {
        dwErr = GetLastError();
        Win32PrintfResource(LogFile, IDS_RAS_ENTRY_NOT_MIGRATED, pszEntryName);
        if (DebugOutput)
        {
            Win32Printf(LogFile,
                        "SetupFindFirstLine: Error %d looking for %s[%s]\r\n",
                        dwErr, pszEntryName, pszKeyName);
        }
        goto cleanup;
    }

    fSuccess = SetupGetStringField(&IpAddrLine, 1, szIpAddr, MAX_IP_ADDRESS, 0);
    if (fSuccess == FALSE)
    {
        dwErr = GetLastError();
        Win32PrintfResource(LogFile, IDS_RAS_ENTRY_NOT_MIGRATED, pszEntryName);
        if (DebugOutput)
        {
            Win32Printf(LogFile,
                        "SetupGetStringField: Error %d reading %s[%s]\r\n",
                        dwErr, pszEntryName, pszKeyName);
        }
        goto cleanup;
    }
    if (_stscanf(szIpAddr, "%d.%d.%d.%d",
                 &dwAddr1, &dwAddr2, &dwAddr3, &dwAddr4) != 4)
    {
        if (DebugOutput)
        {
            Win32Printf(LogFile,
                        "szIpAddr for %s[%s] is not an address: %s\r\n",
                        pszEntryName, pszKeyName, szIpAddr);
        }
        dwErr = ERROR_BAD_FORMAT;
        goto cleanup;
    }
    lpIpAddr->a = (BYTE)dwAddr1;
    lpIpAddr->b = (BYTE)dwAddr2;
    lpIpAddr->c = (BYTE)dwAddr3;
    lpIpAddr->d = (BYTE)dwAddr4;

cleanup:
    return dwErr;
}

//----------------------------------------------------------------------------
DWORD ScanRasPhonebook( HANDLE h, LPCTSTR lpPbkFileName )
{
    DWORD           dwErr = ERROR_SUCCESS;
    LPRASENTRYNAMEA lpRasEntryName;
    DWORD           i = 0;
    DWORD           dwRasEntrySize = 0;
    DWORD           dwRasEntryNameSize = 0;
    DWORD           dwBufferSize   = 0;
    DWORD           cEntries = 0;
    LPRASENTRYA     lpRasEntry = NULL;
    RASDIALPARAMSA  RasDialParams;
    BOOL            bPasswordRead = FALSE;
    HINF            hPbkFile = INVALID_HANDLE_VALUE;

    // Make sure the file exists
    if(GetFileAttributes(lpPbkFileName) == -1)
    {
        ChkErr( GetLastError() );
    }

    lpRasEntryName = (LPRASENTRYNAMEA)GlobalAlloc(GPTR, sizeof(RASENTRYNAMEA));
    lpRasEntryName->dwSize = sizeof(RASENTRYNAMEA);   // Should be 264 when WINVER < 0x500

    dwErr = GRasEnumEntries(NULL,
                          lpPbkFileName,
                          lpRasEntryName,
                          &dwRasEntryNameSize,
                          &cEntries);
    if (dwErr == ERROR_INVALID_SIZE || dwErr == ERROR_BUFFER_TOO_SMALL )
    {
        lpRasEntryName = (LPRASENTRYNAMEA)GlobalAlloc(GPTR, dwRasEntryNameSize);
        if ( cEntries > 1 )
        {
            lpRasEntryName->dwSize = dwRasEntryNameSize / cEntries;
        }
        else
        {
            lpRasEntryName->dwSize = dwRasEntryNameSize;
        }
        dwErr = GRasEnumEntries(NULL,
                                lpPbkFileName,
                                lpRasEntryName,
                                &dwRasEntryNameSize,
                                &cEntries);
    }

    if (dwErr != ERROR_SUCCESS)
    {
        // The resource file specifies %1!d! which requires an int argument in this case
        Win32PrintfResource (LogFile, IDS_RAS_CANNOT_ENUM, dwErr);
        goto Err;
    }

    for(i=0; i < cEntries; i++)
    {
        // Read size needed
        GRasGetEntryProperties(lpPbkFileName,
                               lpRasEntryName->szEntryName,
                               NULL,
                               &dwRasEntrySize,
                               NULL,
                               0);

        if (lpRasEntry == NULL)
        {
            lpRasEntry = (LPRASENTRYA)malloc(dwRasEntrySize);
        }
        else if (dwRasEntrySize > dwBufferSize)
        {
            lpRasEntry = (LPRASENTRYA)realloc(lpRasEntry, dwRasEntrySize);
            dwBufferSize = dwRasEntrySize;
        }

        ZeroMemory( lpRasEntry, dwBufferSize );
        lpRasEntry->dwSize = sizeof(RASENTRYA);

        dwErr = GRasGetEntryProperties( lpPbkFileName,
                                       lpRasEntryName->szEntryName,
                                       lpRasEntry,
                                       &dwRasEntrySize,
                                       NULL,
                                       0 );
        if (dwErr != ERROR_SUCCESS)
        {
            // Log Error
            Win32PrintfResource (LogFile, IDS_RAS_ENTRY_NOT_MIGRATED, lpRasEntryName->szEntryName);
            if (DebugOutput)
            {
                Win32Printf(LogFile, "RasGetEntryProperties: Error %d\r\n", dwErr );
            }
            goto Err;
        }

        if ((lpPbkFileName != NULL) &&
            (lpRasEntry->dwFramingProtocol == RASFP_Slip))
        {

            // We read from a PBK file (not Win9x) and we're using SLIP.
            // This means the ipAddress, DNS addresses, and WINS addresses
            // were probably lost.  Those bastards!
            UINT        dwErrorLine;

            hPbkFile = SetupOpenInfFile(lpPbkFileName,
                                        NULL,
                                        INF_STYLE_OLDNT | INF_STYLE_WIN4,
                                        &dwErrorLine);
            if (hPbkFile == INVALID_HANDLE_VALUE)
            {
                dwErr = GetLastError();
                Win32PrintfResource(LogFile, IDS_RAS_ENTRY_NOT_MIGRATED,
                                    lpRasEntryName->szEntryName);
                if (DebugOutput)
                {
                    Win32Printf(LogFile,
                                "SetupOpenInfFile: Error 0x%X opening %s, line %d\r\n",
                                dwErr, lpPbkFileName, dwErrorLine );
                }
                goto Err;
            }

            // Check IpAddress
            if ((*(DWORD*)&lpRasEntry->ipaddr) == 0 )
            {
                ChkErr( RasReadIpAddress(hPbkFile,
                                         lpRasEntryName->szEntryName,
                                         TEXT("IpAddress"),
                                         &(lpRasEntry->ipaddr)) );
            }
            if ((*(DWORD*)&lpRasEntry->ipaddr) != 0 )
            {
                lpRasEntry->dwfOptions |= RASEO_SpecificIpAddr;
            }

            // Check ipaddrDns
            if ((*(DWORD*)&lpRasEntry->ipaddrDns) == 0 )
            {
                ChkErr( RasReadIpAddress(hPbkFile,
                                         lpRasEntryName->szEntryName,
                                         TEXT("IpDnsAddress"),
                                         &(lpRasEntry->ipaddrDns)) );
            }
            if ((*(DWORD*)&lpRasEntry->ipaddrDns) != 0 )
            {
                lpRasEntry->dwfOptions |= RASEO_SpecificNameServers;
            }

            // Check ipaddrDnsAlt
            if ((*(DWORD*)&lpRasEntry->ipaddrDnsAlt) == 0 )
            {
                ChkErr( RasReadIpAddress(hPbkFile,
                                         lpRasEntryName->szEntryName,
                                         TEXT("IpDns2Address"),
                                         &(lpRasEntry->ipaddrDnsAlt)) );
            }
            if ((*(DWORD*)&lpRasEntry->ipaddrDnsAlt) != 0 )
            {
                lpRasEntry->dwfOptions |= RASEO_SpecificNameServers;
            }

            // Check ipaddrWins
            if ((*(DWORD*)&lpRasEntry->ipaddrWins) == 0 )
            {
                ChkErr( RasReadIpAddress(hPbkFile,
                                         lpRasEntryName->szEntryName,
                                         TEXT("IpWinsAddress"),
                                         &(lpRasEntry->ipaddrWins)) );
            }
            if ((*(DWORD*)&lpRasEntry->ipaddrWins) != 0 )
            {
                lpRasEntry->dwfOptions |= RASEO_SpecificNameServers;
            }

            // Check ipaddrWinsAlt
            if ((*(DWORD*)&lpRasEntry->ipaddrWinsAlt) == 0 )
            {
                ChkErr( RasReadIpAddress(hPbkFile,
                                         lpRasEntryName->szEntryName,
                                         TEXT("IpWins2Address"),
                                         &(lpRasEntry->ipaddrWinsAlt)) );
            }
            if ((*(DWORD*)&lpRasEntry->ipaddrWinsAlt) != 0 )
            {
                lpRasEntry->dwfOptions |= RASEO_SpecificNameServers;
            }
        }

        ChkErr (Win32Printf(h, "\"%s\",", lpRasEntryName->szEntryName) );
        ChkErr (Win32Printf(h, "0x%0X,",  lpRasEntry->dwfOptions ) );
        ChkErr (Win32Printf(h, "%d,",     lpRasEntry->dwCountryID ) );
        ChkErr (Win32Printf(h, "%d,",     lpRasEntry->dwCountryCode ) );
        ChkErr (Win32Printf(h, "\"%s\",", lpRasEntry->szAreaCode ) );
        ChkErr (Win32Printf(h, "\"%s\",", lpRasEntry->szLocalPhoneNumber) );
        ChkErr (Win32Printf(h, "%d,",     0) );   // lpRasEntry->dwAlternateOffset
        ChkErr (Win32Printf(h, "0x%08X,", lpRasEntry->ipaddr ) );
        ChkErr (Win32Printf(h, "0x%08X,", lpRasEntry->ipaddrDns ) );
        ChkErr (Win32Printf(h, "0x%08X,", lpRasEntry->ipaddrDnsAlt) );
        ChkErr (Win32Printf(h, "0x%08X,", lpRasEntry->ipaddrWins ) );
        ChkErr (Win32Printf(h, "0x%08X,", lpRasEntry->ipaddrWinsAlt) );
        ChkErr (Win32Printf(h, "%d,",     lpRasEntry->dwFrameSize ) );
        ChkErr (Win32Printf(h, "%d,",     lpRasEntry->dwfNetProtocols ) );
        ChkErr (Win32Printf(h, "%d,",     lpRasEntry->dwFramingProtocol) );
        ChkErr (Win32Printf(h, "\"%s\",", lpRasEntry->szScript ) );
        ChkErr (Win32Printf(h, "\"%s\",", lpRasEntry->szAutodialDll ) );
        ChkErr (Win32Printf(h, "\"%s\",", lpRasEntry->szAutodialFunc ) );
        ChkErr (Win32Printf(h, "\"%s\",", lpRasEntry->szDeviceType ) );
        ChkErr (Win32Printf(h, "\"%s\",", lpRasEntry->szDeviceName ) );
        ChkErr (Win32Printf(h, "\"%s\",", lpRasEntry->szX25PadType ) );
        ChkErr (Win32Printf(h, "\"%s\",", lpRasEntry->szX25Address ) );
        ChkErr (Win32Printf(h, "\"%s\",", lpRasEntry->szX25Facilities ) );
        ChkErr (Win32Printf(h, "\"%s\",", lpRasEntry->szX25UserData ) );
        ChkErr (Win32Printf(h, "%d,",     lpRasEntry->dwChannels ) );

        ZeroMemory( &RasDialParams, sizeof(RASDIALPARAMSA) );

        lstrcpyA( RasDialParams.szEntryName, lpRasEntryName->szEntryName);
        RasDialParams.dwSize = sizeof(RASDIALPARAMSA);

        dwErr = GRasGetEntryDialParams( lpPbkFileName,
                                       &RasDialParams,
                                       &bPasswordRead );
        if ( dwErr != ERROR_SUCCESS )
        {
            Win32PrintfResource (LogFile, IDS_RAS_ENTRY_NOT_MIGRATED, lpRasEntryName->szEntryName);
            if (DebugOutput)
            {
                Win32Printf(LogFile, "RasGetDialParams: Error %d\n", dwErr );
            }
            goto Err;
        }

        ChkErr (Win32Printf(h, "%s,", RasDialParams.szPhoneNumber ) );
        ChkErr (Win32Printf(h, "%s,", RasDialParams.szCallbackNumber ) );
        ChkErr (Win32Printf(h, "%s,", RasDialParams.szUserName ) );
        ChkErr (Win32Printf(h, "%s,", RasDialParams.szPassword ) );
        ChkErr (Win32Printf(h, "%s\r\n", RasDialParams.szDomain) );

        lpRasEntryName++;
    }

Err:

    if (hPbkFile != INVALID_HANDLE_VALUE)
        SetupCloseInfFile(hPbkFile);

    Win32Printf(h, "\r\n" );
    if (lpRasEntry != NULL)
        free (lpRasEntry);

    if (lpRasEntryName != NULL)
        GlobalFree (lpRasEntryName);
    return dwErr;
}

DWORD ScanRasPerPhonebook (HANDLE h)
{
    DWORD          dwErr = ERROR_SUCCESS;
    CHAR           szValue[LINEBUFSIZE];
    CHAR           szPbkFileName[MAX_PATH];
    TCHAR          szWinDir[MAX_PATH];

    if (Win9x)
    {
        // System phonebook
        dwErr = ScanRasPhonebook( h, NULL );
        if (ERROR_CANNOT_OPEN_PHONEBOOK == dwErr)
        {
            // 9x stores Ras in the registry. If it can't find the registry,
            // assume there are no Ras connections that need migrating.
            dwErr = ERROR_SUCCESS;
        }
    }
    else
    {
        // Scan system pbk
        dwErr = GetWindowsDirectory(szWinDir, MAX_PATH );
        if (dwErr <= 0 || dwErr > MAX_PATH)
        {
            if (Verbose)
            {
                Win32Printf(LogFile,
                            "Error: Could not retrieve Windows directory: %d\r\n",
                            dwErr);
            }
            goto Err;
        }

        if ( (_tcslen(szWinDir) +
              _tcslen(RAS_NT4_RAS_PATH) +
              _tcslen(RAS_NT4_SYSTEM_PHONEBOOK) + 3) > MAX_PATH )
        {
            Win32PrintfResource(LogFile,
                                IDS_FILENAME_TOOLONG,
                                RAS_NT4_SYSTEM_PHONEBOOK);
            if (Verbose)
            {
                Win32Printf(STDERR,
                            "Error: Too Long Phonebook Filename: %s\\%s\\%s\r\n",
                            szWinDir,
                            RAS_NT4_RAS_PATH,
                            RAS_NT4_SYSTEM_PHONEBOOK);
            }
            dwErr = ERROR_FILENAME_EXCED_RANGE;
            goto Err;
        }

        sprintf( szPbkFileName, "%s\\%s\\%s",
                 szWinDir, RAS_NT4_RAS_PATH, RAS_NT4_SYSTEM_PHONEBOOK );
        // Make sure the file exists
        dwErr = GetFileAttributes(szPbkFileName);
        if (-1 == dwErr)
        {
            dwErr = GetLastError();
            if (dwErr == ERROR_FILE_NOT_FOUND ||
                dwErr == ERROR_PATH_NOT_FOUND)
            {
                // This phonebook file doesn't exist, which is fine.  Just skip it.
                dwErr = ERROR_SUCCESS;
            }
            else
            {
                goto Err;
            }
        }
        else
        {
            ChkErr( ScanRasPhonebook( h, szPbkFileName ) );
        }

        // Scan personal pbk
        dwErr = ScanReadKey (HKEY_CURRENT_USER,
                             (CHAR*) REGKEY_NT4_PBK,
                             (CHAR*) REGVAL_NT4_PRS_PBK_LOC,
                             (CHAR*) szValue, sizeof(szValue));
        if ( dwErr == ERROR_SUCCESS && szValue[0] != '\0')
        {
            if ( (_tcslen(szWinDir) +
                  _tcslen(RAS_NT4_RAS_PATH) +
                  _tcslen(szValue) + 3) > MAX_PATH )
            {
                 Win32PrintfResource(LogFile,
                                     IDS_FILENAME_TOOLONG,
                                     szValue);
                 if (Verbose)
                 {
                     Win32Printf(STDERR,
                                 "Error: Too Long Phonebook Filename: %s\\%s\\%s\r\n",
                                 szWinDir,
                                 RAS_NT4_RAS_PATH,
                                 szValue);
                 }
                 dwErr = ERROR_FILENAME_EXCED_RANGE;
                 goto Err;
            }

            sprintf( szPbkFileName, "%s\\%s\\%s", szWinDir, RAS_NT4_RAS_PATH, szValue );

            // Make sure the file exists
            dwErr = GetFileAttributes(szPbkFileName);
            if (-1 == dwErr)
            {
                dwErr = GetLastError();
                if (dwErr == ERROR_FILE_NOT_FOUND ||
                    dwErr == ERROR_PATH_NOT_FOUND)
                {
                    // This phonebook file doesn't exist. Just skip it
                    dwErr = ERROR_SUCCESS;
                }
                else
                {
                    goto Err;
                }
            }
            else
            {
                ChkErr( ScanRasPhonebook( h, szPbkFileName ) );
            }
        }
        else if (dwErr == ERROR_FILE_NOT_FOUND)
        {
            // Just because there is no personal pbk defined in the registry doesn't
            // mean there was a fatal error.  Just skip it and move on with life.
            dwErr = ERROR_SUCCESS;
        }
        else if (dwErr != ERROR_SUCCESS)
        {
            if (DebugOutput)
            {
                Win32Printf(LogFile, "ScanReadKey for personal PBK returned %d\r\n", dwErr);
            }
            goto Err;
        }

        // Scan alternate pbk
        dwErr = ScanReadKey (HKEY_CURRENT_USER,
                             (CHAR*) REGKEY_NT4_PBK,
                             (CHAR*) REGVAL_NT4_ALT_PBK_LOC,
                             (CHAR*) szValue, sizeof(szValue));
        if ( dwErr == ERROR_SUCCESS && szValue[0] != '\0')
        {
            // Make sure the file exists
            dwErr = GetFileAttributes(szValue);
            if (-1 == dwErr)
            {
                dwErr = GetLastError();
                if (dwErr == ERROR_FILE_NOT_FOUND ||
                    dwErr == ERROR_PATH_NOT_FOUND)
                {
                    // This phonebook file doesn't exist. Just skip it.
                    dwErr = ERROR_SUCCESS;
                }
                else
                {
                    return dwErr;
                }
            }
            else
            {
                ChkErr( ScanRasPhonebook( h, szValue ) );
            }
        }
        else if (dwErr == ERROR_FILE_NOT_FOUND)
        {
            // Just because there is no alternate pbk defined in the registry doesn't
            // mean there was a fatal error.  Just skip it and move on with life.
            dwErr = ERROR_SUCCESS;
        }
        else if ( dwErr != ERROR_SUCCESS )
        {
            if (DebugOutput)
            {
                Win32Printf(LogFile, "ScanReadKey for alternate pbk returned: %d\r\n", dwErr);
            }
            goto Err;
        }
    }

Err:
    return dwErr;
}

//+---------------------------------------------------------------------------
//
//  Function:   ScanRasSettings
//
//  Synopsis:   scans RAS settings for current user
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD ScanRasSettings (HANDLE h)
{
    DWORD          dwErr = ERROR_SUCCESS;

   if (IsRasInstalled())
    {
        ChkErr (Win32Printf (h, (CHAR *) RAS));
        ChkErr (ScanRasPerPhonebook (h));
    }
Err:
    return dwErr;
}

//+---------------------------------------------------------------------------
//
//  Function:   ScanEnumerateShares
//
//  Synopsis:   lists public (non-system) network shares
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD ScanEnumerateShares (HANDLE h)
{

    short nLevel = (short) (Win9x ? 50 : 502);
    DWORD dwErr = ERROR_SUCCESS;
    const int MAX_ENTRIES = 64;

    ScanNetShareEnumNT pNetShareEnum = NULL;
    ScanNetShareEnum9x pNetShareEnum9x = NULL;
    ScanNetAccessEnum9x pNetAccessEnum9x = NULL;

    HINSTANCE hInst = LoadLibraryA (Win9x ? "svrapi.dll" : "netapi32.dll");
    if (hInst == 0)
    {
        ChkErr (ERROR_INVALID_DLL);
    }

    ChkErr (Win32Printf (h, (CHAR *) SHARES));
    if (Win9x)
    {
        USHORT cbBuffer;
        USHORT nEntriesRead = 0;
        USHORT nTotalEntries = 0;
        USHORT i;
        static _share_info_50 pBuf[MAX_ENTRIES];
        _share_info_50* pTmpBuf = NULL;

        cbBuffer = MAX_ENTRIES * sizeof(_share_info_50);

        pNetShareEnum9x = (ScanNetShareEnum9x) GetProcAddress (hInst,
                            "NetShareEnum");
        if (pNetShareEnum9x == NULL)
        {
            ChkErr (ERROR_INVALID_DLL);
        }
        pNetAccessEnum9x = (ScanNetAccessEnum9x) GetProcAddress (hInst,
                            "NetAccessEnum");
        if (pNetAccessEnum9x == NULL)
        {
            ChkErr (ERROR_INVALID_DLL);
        }

        //
        // Call the NetShareEnum function to list the
        //  shares, specifying information level 50.
        //
        dwErr = (*pNetShareEnum9x)(NULL,
                          (short) nLevel,
                          (char *) pBuf,
                          cbBuffer,
                          &nEntriesRead,
                          &nTotalEntries);

        if (dwErr == ERROR_SUCCESS)
        {
            if (nTotalEntries > 0 && nEntriesRead != nTotalEntries)
                ChkErr (ERROR_MORE_DATA);

            for (i = 0; i < nEntriesRead; i++)
            {
                DWORD dwPerms = 0;
                pTmpBuf = &pBuf[i];

                // Require share to be a user-defined, persistent disk share
                if ((pTmpBuf->shi50_flags & SHI50F_SYSTEM) ||
                   !(pTmpBuf->shi50_flags & SHI50F_PERSIST) ||
                    pTmpBuf->shi50_type != STYPE_DISKTREE )
                {
                    continue;
                }

                if (pTmpBuf->shi50_flags & SHI50F_RDONLY)
                    dwPerms = ACCESS_READ;
                else if (pTmpBuf->shi50_flags & SHI50F_FULL)
                    dwPerms = ACCESS_ALL;
                //
                // Display the information for each entry retrieved.
                //
                ChkErr (Win32Printf (h, "%s, %s, %d, %s\r\n",
                        pTmpBuf->shi50_netname, pTmpBuf->shi50_path,
                        dwPerms, pTmpBuf->shi50_remark));

                //
                // Process custom access permissions
                //
                if ((pTmpBuf->shi50_flags & SHI50F_ACCESSMASK) ==
                                                SHI50F_ACCESSMASK)
                {
                   static CHAR AccessInfoBuf[16384];
                   WORD wItemsAvail, wItemsRead;
                   access_info_2 *pai;
                   access_list_2 *pal;

                   dwErr = (*pNetAccessEnum9x) (NULL,
                                     pTmpBuf->shi50_path,
                                     0,
                                     2,
                                     AccessInfoBuf,
                                     sizeof (AccessInfoBuf),
                                     &wItemsRead,
                                     &wItemsAvail
                                     );

                   if (dwErr != NERR_ACFNotLoaded)
                   {
                       BOOL LostCustomAccess = FALSE;
                       if (dwErr == ERROR_SUCCESS)
                       {
                            pai = (access_info_2 *) AccessInfoBuf;
                            pal = (access_list_2 *) (&pai[1]);

                            for (int i = 0 ; i < pai->acc2_count ; i++)
                            {
#if 0
                    // turn off custom access support
                    // implementation is incomplete
                                if (pal->acl2_access & READ_ACCESS_FLAGS)
                                    Win32Printf (h, "  %s, read\r\n",
                                                    pal->acl2_ugname);
                                else if(pal->acl2_access & FULL_ACCESS_FLAGS)
                                    Win32Printf (h, "  %s, full\r\n",
                                                    pal->acl2_ugname);
                                else
#endif
                                    LostCustomAccess = TRUE;

                                pal++;
                            }
                            if (LostCustomAccess)
                                Win32Printf (LogFile, "Warning custom access"
                                   " not migrated %s\r\n",
                                   pTmpBuf->shi50_netname);
                            pTmpBuf->shi50_flags |= SHI50F_ACLS;
                       }
                       else ChkErr (dwErr);
                   }
                }
                if (!(pTmpBuf->shi50_flags & SHI50F_ACLS) &&
                         (pTmpBuf->shi50_rw_password[0] ||
                          pTmpBuf->shi50_ro_password[0]))
                {
                    Win32PrintfResource (LogFile,
                                         IDS_SHARE_PASSWORD_NOT_MIGRATED,
                                         pTmpBuf->shi50_netname);
                }
            }
        }
        else if (dwErr == NERR_ServerNotStarted)
        {
             dwErr = ERROR_SUCCESS;
        }
    }
    else
    {
        ULONG cbBuffer = MAX_ENTRIES * sizeof(SHARE_INFO_502);
        ULONG nEntriesRead = 0;
        ULONG nTotalEntries = 0;
        ULONG i;
        SHARE_INFO_502* pBuf = NULL;
        SHARE_INFO_502* pTmpBuf = NULL;

        pNetShareEnum = (ScanNetShareEnumNT) GetProcAddress(hInst,
                                             "NetShareEnum");
        if (pNetShareEnum == NULL)
        {
            ChkErr (ERROR_INVALID_DLL);
        }
        //
        // Call the NetShareEnum function to list the
        //  shares, specifying information level 502.
        //
        dwErr = (*pNetShareEnum)(NULL,
                          nLevel,
                          (BYTE **) &pBuf,
                          cbBuffer,
                          &nEntriesRead,
                          &nTotalEntries,
                          NULL);

        //
        // Loop through the entries; process errors.
        //
        if (dwErr == ERROR_SUCCESS)
        {
            if ((pTmpBuf = pBuf) != NULL)
            {
                for (i = 0; (i < nEntriesRead); i++)
                {
                    //
                    // Display the information for each entry retrieved.
                    //
                    ChkErr (Win32Printf (h, "%ws, %ws, %d, %ws\r\n",
                        pTmpBuf->shi502_netname, pTmpBuf->shi502_path,
                        pTmpBuf->shi502_permissions, pTmpBuf->shi502_remark));

                    pTmpBuf++;
                }
            }
        }
        else
        {
            Win32PrintfResource (LogFile, IDS_CANNOT_ENUM_NETSHARES);
            LogFormatError (dwErr);
            dwErr = ERROR_SUCCESS;  // continue with other settings
        }

        if (pBuf != NULL)
        {
           ScanNetApiBufferFreeNT pNetApiBufferFree = NULL;

           pNetApiBufferFree = (ScanNetApiBufferFreeNT) GetProcAddress (hInst,
                                   "NetApiBufferFree");
           if (pNetApiBufferFree != NULL)
               (*pNetApiBufferFree) (pBuf);
        }
    }


Err:
    if (Verbose && dwErr != ERROR_SUCCESS)
        Win32Printf (LogFile, "Out ScanEnumerateShares => 0x%x\r\n", dwErr);
   return dwErr;
}

//+---------------------------------------------------------------------------
//
//  Function:   ScanEnumeratePrinters
//
//  Synopsis:   list connected printers
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD ScanEnumeratePrinters (HANDLE h)
{
    DWORD dwErr;
    DWORD cbBuffer = 16384;      // 16K is a good size
    DWORD cbReceived;
    DWORD nPrinters;
    DWORD i;
    PRINTER_INFO_2 *pPrinterEnum;

    for(i = 0; i < 2; i++)
    {
       dwErr = ERROR_SUCCESS;

       pPrinterEnum = (PRINTER_INFO_2 *) GlobalAlloc(GPTR, cbBuffer);
       if (pPrinterEnum == NULL)
           ChkErr (ERROR_NOT_ENOUGH_MEMORY);

       if (FALSE == EnumPrintersA (Win9x ? PRINTER_ENUM_LOCAL :
                                  PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS,
                                  NULL,
                                  2,
                                  (BYTE *) pPrinterEnum,
                                  cbBuffer,
                                  &cbReceived,
                                  &nPrinters))
       {
           dwErr = GetLastError();
           if (RPC_S_SERVER_UNAVAILABLE == dwErr)
           {
               // If the print spooler is turned off, then
               // assume there are no printers to migrate
               dwErr = ERROR_SUCCESS;
               goto Err;
           }

           if( dwErr == ERROR_INSUFFICIENT_BUFFER || dwErr == ERROR_MORE_DATA )
           {
              GlobalFree(pPrinterEnum);
              cbBuffer = cbReceived;

              // Try again.
              continue;
           }
       }

       // Success, or some other error besides buffer to small.. so bail.
       break;
    }
    ChkErr (dwErr);

    ChkErr (Win32Printf (h, (CHAR *) PRINTERS));
    for (i=0; i < nPrinters; i++)
    {
        if (Win9x)
        {
            ChkErr (Win32Printf(h, "%s\r\n", pPrinterEnum[i].pPortName));
        }
        else
        {
            ChkErr (Win32Printf(h, "%s\r\n", pPrinterEnum[i].pPrinterName));
        }
    }

Err:
    if (pPrinterEnum != NULL)
        GlobalFree (pPrinterEnum);

    if (Verbose && dwErr != ERROR_SUCCESS)
        Win32Printf (LogFile, "Out ScanEnumeratePrinters => 0x%x\r\n", dwErr);
    return dwErr;
}

//+---------------------------------------------------------------------------
//
//  Function:   ScanEnumerateNetResources
//
//  Synopsis:   lists connected remote drives and resources
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD ScanEnumerateNetResources (HANDLE h, DWORD dwScope, NETRESOURCEA *lpnr)
{

  DWORD dwErr, dwResultEnum;
  HANDLE hEnum;
  DWORD cbBuffer = 16384;      // 16K is a good size
  DWORD cEntries = 0xFFFFFFFF; // enumerate all possible entries
  LPNETRESOURCEA lpnrLocal;     // pointer to enumerated structures
  DWORD i;

  dwErr = WNetOpenEnumA(dwScope,
                          RESOURCETYPE_ANY,
                          0,        // enumerate all resources
                          lpnr,     // NULL first time this function is called
                          &hEnum);  // handle to resource

  if (dwErr != NO_ERROR)
  {
    // An application-defined error handler is demonstrated in the
    // section titled "Retrieving Network Errors."

    return dwErr;
  }

  lpnrLocal = (LPNETRESOURCEA) GlobalAlloc(GPTR, cbBuffer);
    if (lpnrLocal == NULL)
        ChkErr (ERROR_NOT_ENOUGH_MEMORY);

  do
  {
    ZeroMemory(lpnrLocal, cbBuffer);

    dwResultEnum = WNetEnumResourceA (hEnum,      // resource handle
                                    &cEntries,  // defined locally as 0xFFFFFFFF
                                    lpnrLocal,  // LPNETRESOURCE
                                    &cbBuffer); // buffer size

    if (dwResultEnum == NO_ERROR)
    {
      for(i = 0; i < cEntries; i++)
      {
        // Following is an application-defined function for
        // displaying contents of NETRESOURCE structures.

        if (lpnrLocal[i].lpLocalName != NULL)
        {
            ChkErr (Win32Printf (h, "%s, %s, %s\r\n", lpnrLocal[i].lpLocalName,
            lpnrLocal[i].lpRemoteName == NULL ? "" : lpnrLocal[i].lpRemoteName,
            lpnrLocal[i].dwScope == RESOURCE_REMEMBERED ? "persist" : ""));
        }

#if 0
        // If this NETRESOURCE is a container, call the function
        // recursively.

        // Looking at the docs, it appears that the dwUsage is only applicable for
        // GLOBALNET enumerations, and not for CONNECTED enumerations.  We shouldn't
        // have to worry about recursively finding resources, because all we care
        // about is what is currently connected.  This was a problem for Netware
        // shares, in which case it recursively found itself until it aborted or AV'd.

        if(RESOURCEUSAGE_CONTAINER == (lpnrLocal[i].dwUsage
                                       & RESOURCEUSAGE_CONTAINER))
          if((dwErr = ScanEnumerateNetResources (h, dwScope, &lpnrLocal[i])) !=
                         ERROR_SUCCESS)
             return dwErr;
#endif
      }
    }
  }
  while(dwResultEnum != ERROR_NO_MORE_ITEMS);

    if (lpnrLocal != NULL)
        GlobalFree((HGLOBAL)lpnrLocal);

    dwErr = WNetCloseEnum(hEnum);

Err:
    return dwErr;
}

//+---------------------------------------------------------------------------
//
//  Function:   ScanReadKey
//
//  Synopsis:   retrieves a string or blob from the registry
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD ScanReadKey (HKEY hKeyStart,
                   CHAR *szKey,
                   CHAR *szName,
                   CHAR *szValue,
                   ULONG ulLen)
{
    HKEY hKey = NULL;
    DWORD dwErr = ERROR_SUCCESS;

    ChkErr (RegOpenKeyExA(hKeyStart, szKey, NULL, KEY_READ, &hKey));
    ChkErr (RegQueryValueExA(hKey, szName, NULL, NULL,(BYTE*)szValue, &ulLen));

Err:
    if (hKey != NULL)
        RegCloseKey (hKey);

    return dwErr;
}

//+---------------------------------------------------------------------------
//
//  Function:   ScanGetTimeZone
//
//  Synopsis:   retrieves the time zone name
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD ScanGetTimeZone (HANDLE h)
{
    CHAR szValue[LINEBUFSIZE];
    DWORD dwErr =  ERROR_SUCCESS;

    if (ERROR_SUCCESS == ScanReadKey (HKEY_LOCAL_MACHINE,
                                     (CHAR*) REGKEY_TIMEZONE,
                                     (CHAR*) REGVAL_TIMEZONE,
                                     (CHAR*) szValue, sizeof(szValue)))
    {
        dwErr = Win32Printf (h, "%s=%s\r\n", TIMEZONE, szValue);
    }

    return dwErr;
}

//+---------------------------------------------------------------------------
//
//  Function:   ScanGetComputerName
//
//  Synopsis:   retrieves the current NETBIOS machine name
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

#if 0   // currently not used, but may be needed in the future
DWORD ScanGetComputerName (CHAR *szValue, ULONG ulLen)
{
    if (FALSE == GetComputerNameA(szValue, &ulLen))
        return GetLastError();

    return ERROR_SUCCESS;
}
#endif

//+---------------------------------------------------------------------------
//
//  Function:   ScanGetFullName
//
//  Synopsis:   retrieves the registered name
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD ScanGetFullName (HANDLE h)
{
    CHAR szValue[LINEBUFSIZE];
    DWORD dwErr =  ERROR_SUCCESS;

    if (ERROR_SUCCESS == ScanReadKey (HKEY_LOCAL_MACHINE,
                        Win9x ? (CHAR*)REGKEY_VERSION_9x :(CHAR*)REGKEY_VERSION,
                        (CHAR*) REGVAL_FULLNAME, szValue, sizeof(szValue)))
    {
        dwErr = Win32Printf (h, "%s=%s\r\n", FULLNAME, szValue);
    }

    return dwErr;
}

//+---------------------------------------------------------------------------
//
//  Function:   ScanGetOrgName
//
//  Synopsis:   retrieves the organization name
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD ScanGetOrgName (HANDLE h)
{
    CHAR szValue[LINEBUFSIZE];
    DWORD dwErr = ERROR_SUCCESS;

    if (ERROR_SUCCESS == ScanReadKey (HKEY_LOCAL_MACHINE,
                        Win9x ? (CHAR*)REGKEY_VERSION_9x :(CHAR*)REGKEY_VERSION,
                        (CHAR*)REGVAL_ORGNAME, szValue, sizeof(szValue)))
    {
        dwErr = Win32Printf (h, "%s=%s\r\n", ORGNAME, szValue);
    }

    return dwErr;
}

//
// IsLanguageMatched : if source and target language are matched (or compatible)
//
//      1. if SourceNativeLangID == TargetNativeLangID
//
//      2. if SourceNativeLangID's alternative ID == TargetNative LangID
//

typedef struct _tagLANGINFO {
    LANGID LangID;
    INT    Count;
} LANGINFO,*PLANGINFO;

//+---------------------------------------------------------------------------
//
//  Function:   EnumLangProc
//
//  Synopsis:   callback to pull out the langid while enumerating
//
//  Arguments:
//
//  Returns:    bool to continue to stop enumeration
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

BOOL CALLBACK EnumLangProc(
    HANDLE hModule,     // resource-module handle
    LPCTSTR lpszType,   // pointer to resource type
    LPCTSTR lpszName,   // pointer to resource name
    WORD wIDLanguage,   // resource language identifier
    LONG_PTR lParam     // application-defined parameter
   )
{
    PLANGINFO LangInfo;

    LangInfo = (PLANGINFO) lParam;

    LangInfo->Count++;

    //
    // for localized build contains multiple resource,
    // it usually contains 0409 as backup lang.
    //
    // if LangInfo->LangID != 0 means we already assigned an ID to it
    //
    // so when wIDLanguage == 0x409, we keep the one we got from last time
    //
    if ((wIDLanguage == 0x409) && (LangInfo->LangID != 0)) {
        return TRUE;
    }

    LangInfo->LangID  = wIDLanguage;

    return TRUE;        // continue enumeration
}

//+---------------------------------------------------------------------------
//
//  Function:   GetNTDLLNativeLangID
//
//  Synopsis:   pull the language id from ntdll for NT systems only
//
//  Arguments:
//
//  Returns:    Native lang ID in ntdll.dll
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

LANGID GetNTDLLNativeLangID()
{
    LPCTSTR Type = (LPCTSTR) RT_VERSION;
    LPCTSTR Name = (LPCTSTR) 1;

    LANGINFO LangInfo;

    ZeroMemory(&LangInfo,sizeof(LangInfo));

    EnumResourceLanguages(
            GetModuleHandle(TEXT("ntdll.dll")),
            Type,
            Name,
            (ENUMRESLANGPROC) EnumLangProc,
            (LONG_PTR) &LangInfo
            );

    return LangInfo.LangID;
}

//+---------------------------------------------------------------------------
//
//  Function:   IsHongKongVersion
//
//  Synopsis:   identifies HongKong NT 4.0  (English UI w/ Chinese locale)
//
//  Arguments:
//
//  Returns:    TRUE/FALSE
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

BOOL IsHongKongVersion()
{
    HMODULE hMod;
    BOOL bRet = FALSE;
    typedef BOOL (*IMMRELEASECONTEXT) (HWND,HANDLE);
    IMMRELEASECONTEXT pImmReleaseContext;

    LANGID TmpID = GetNTDLLNativeLangID();

    if (((GetVersion() >> 16) == 1381) && (TmpID == 0x0409))
    {

        hMod = LoadLibrary(TEXT("imm32.dll"));
        if (hMod)
        {
            pImmReleaseContext = (IMMRELEASECONTEXT)
                GetProcAddress(hMod,"ImmReleaseContext");

            if (pImmReleaseContext) {
                bRet = pImmReleaseContext(NULL,NULL);
            }

            FreeLibrary(hMod);
        }
    }
    return (bRet);
}

//+---------------------------------------------------------------------------
//
//  Function:   GetDefaultUserLangID
//
//  Synopsis:   retrieves the language of the OS
//
//  Arguments:
//
//  Returns:    .DEFAULT user's LANGID
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

LANGID GetDefaultUserLangID()
{
    LONG            dwErr;
    HKEY            hkey;
    DWORD           dwSize;
    CHAR            buffer[512];
    LANGID          langid = 0;

    dwErr = RegOpenKeyEx( HKEY_USERS,
                          TEXT(".DEFAULT\\Control Panel\\International"),
                          0,
                          KEY_READ,
                          &hkey );

    if( dwErr == ERROR_SUCCESS )
    {

        dwSize = sizeof(buffer);
        dwErr = RegQueryValueExA(hkey,
                                 "Locale",
                                 NULL,  //reserved
                                 NULL,  //type
                                 (BYTE *)buffer,
                                 &dwSize );

        if(dwErr == ERROR_SUCCESS)
        {
            langid = LANGIDFROMLCID(strtoul(buffer,NULL,16));

        }
        RegCloseKey(hkey);
    }
    return langid;
}

//+---------------------------------------------------------------------------
//
//  Function:   ScanGetLang
//
//  Synopsis:   retrieves the language of the OS
//
//  Arguments:  [pdwLang] -- output Language ID
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD ScanGetLang (DWORD *pdwLang)
{
    HKEY hKey;
    DWORD dwErr = ERROR_SUCCESS;
    DWORD langid = 0;
    DWORD dwSize;
    BYTE buffer[LINEBUFSIZE];

    if (Win9x)
    {
        dwErr = RegOpenKeyEx( HKEY_USERS,
                    TEXT(".Default\\Control Panel\\desktop\\ResourceLocale"),
                    0, KEY_READ, &hKey );

        if (dwErr == ERROR_SUCCESS)
        {
            dwSize = sizeof(buffer);
            dwErr = RegQueryValueExA( hKey,
                                     "",
                                     NULL,  //reserved
                                     NULL,  //type
                                     buffer,
                                     &dwSize );

            if(dwErr == ERROR_SUCCESS)
            {
                langid = LANGIDFROMLCID(strtoul((CHAR*)buffer,NULL,16));
                *pdwLang = langid;
            }
            RegCloseKey(hKey);
        }
        if ( dwErr != ERROR_SUCCESS )
        {
           dwErr = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                    TEXT("System\\CurrentControlSet\\Control\\Nls\\Locale"),
                    0, KEY_READ, &hKey );

           if (dwErr == ERROR_SUCCESS)
           {
              dwSize = sizeof(buffer);
              dwErr = RegQueryValueExA( hKey,
                                        "",
                                        NULL,  //reserved
                                        NULL,  //type
                                        buffer,
                                        &dwSize );

              if (dwErr == ERROR_SUCCESS)
              {
                  langid = LANGIDFROMLCID(strtoul((CHAR*)buffer,NULL,16));
                  *pdwLang = langid;
              }
              RegCloseKey(hKey);
           }
        }
    }
    else
    {
         langid = GetNTDLLNativeLangID();
         if (langid == 0x0409)
         {
             if (IsHongKongVersion())  // block Pan-Chinese upgrade to English
             {
                 langid = 0x0C04;      // map to Chinese (Hong Kong SAR)
             }
         }
         *pdwLang = langid;
    }
    if (Verbose && dwErr != ERROR_SUCCESS)
        Win32Printf (LogFile, "ScanGetLang %d, LangID=%x\n", dwErr, langid);
    return dwErr;
}

#define ACCESS_KEY TEXT("Control Panel\\Accessibility\\")

//+---------------------------------------------------------------------------
//
//  Function:   ScanConvertFlags
//
//  Synopsis:   convert accessibility flags
//
//  Arguments:  [pcsObject] -- registry key name
//              [pOptions]  -- conversion table
//              [dwForceValues] -- force these options to be on
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD ScanConvertFlags (HANDLE h,
                        TCHAR *pcsObject,
                        ACCESS_OPTION *pOptions,
                        DWORD dwForceValues)
{
    HKEY hKey = NULL;
    DWORD dwErr = ERROR_SUCCESS;
    DWORD Flags;
    DWORD dw;
    BYTE  *lpBuffer = NULL;
    DWORD dwBufferSize = 0;
    DWORD dwRequiredSize;

    if (ERROR_SUCCESS == RegOpenKeyEx( HKEY_CURRENT_USER,
                    pcsObject, 0, KEY_READ, &hKey ))
    {
        //
        // Get flag settings from Win95 registry and convert them to Flags
        //

        Flags = 0;

        while (pOptions->ValueName)
        {
            // How big of a buffer do we need?
            RegQueryValueEx(hKey, pOptions->ValueName, NULL, NULL, NULL, &dwRequiredSize);
            if (dwRequiredSize > dwBufferSize)
            {
                if (lpBuffer == NULL)
                {
                    lpBuffer = (BYTE *)malloc(dwRequiredSize * sizeof(BYTE));
                }
                else
                {
                    lpBuffer = (BYTE *)realloc(lpBuffer, dwRequiredSize * sizeof(BYTE));
                }
                dwBufferSize = dwRequiredSize;
            }

            ZeroMemory(lpBuffer, dwBufferSize);

            // Read value
            if (ERROR_SUCCESS == RegQueryValueEx( hKey,
                                      pOptions->ValueName,
                                      NULL,  //reserved
                                      NULL,  //type
                                      lpBuffer,
                                      &dwBufferSize ))
            {
                // Convert to int
                dw = atoi((const char *)lpBuffer);

                //
                // Most flags are identical on Win9x and NT, but there's one
                // MouseKey flag that needs to be inverted.
                //

                if (pOptions->FlagVal & SPECIAL_INVERT_OPTION)
                {
                    if (dw == 0)
                    {
                        Flags |= (pOptions->FlagVal & (~SPECIAL_INVERT_OPTION));
                    }
                }
                else if (dw != 0)
                {
                    Flags |= pOptions->FlagVal;
                }
            }
            pOptions++;
        }
        Flags |= dwForceValues;
        Win32Printf (h, "HKR, \"%s\", \"Flags\", 0x0, \"%d\"\r\n",
                     pcsObject, Flags);

        RegCloseKey (hKey);
    }
    return dwErr;
}

//+---------------------------------------------------------------------------
//
//  Function:   ScanAccessibility
//
//  Synopsis:   convertes Accessibility settings
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD ScanAccessibility (HANDLE h)
{
    DWORD dwErr = ERROR_SUCCESS;

    const TCHAR ACCESS_AVAILABLE[] =          TEXT("Available");
    const TCHAR ACCESS_CLICKON[] =            TEXT("ClickOn");
    const TCHAR ACCESS_CONFIRMHOTKEY[] =      TEXT("ConfirmHotKey");
    const TCHAR ACCESS_HOTKEYACTIVE[] =       TEXT("HotKeyActive");
    const TCHAR ACCESS_HOTKEYSOUND[] =        TEXT("HotKeySound");
    const TCHAR ACCESS_ON[] =                 TEXT("On");
    const TCHAR ACCESS_ONOFFFEEDBACK[] =      TEXT("OnOffFeedback");
    const TCHAR ACCESS_SHOWSTATUSINDICATOR[]= TEXT("ShowStatusIndicator");
    const TCHAR ACCESS_MODIFIERS[] =          TEXT("Modifiers");
    const TCHAR ACCESS_REPLACENUMBERS[] =     TEXT("ReplaceNumbers");
    const TCHAR ACCESS_AUDIBLEFEEDBACK[] =    TEXT("AudibleFeedback");
    const TCHAR ACCESS_TRISTATE[] =           TEXT("TriState");
    const TCHAR ACCESS_TWOKEYSOFF[] =         TEXT("TwoKeysOff");
    const TCHAR ACCESS_HOTKEYAVAILABLE[] =    TEXT("HotKeyAvailable");

    ACCESS_OPTION FilterKeys[] = {
        ACCESS_ON,                     BASICS_ON,
        ACCESS_AVAILABLE,              BASICS_AVAILABLE,
        ACCESS_HOTKEYACTIVE,           BASICS_HOTKEYACTIVE,
        ACCESS_CONFIRMHOTKEY,          BASICS_CONFIRMHOTKEY,
        ACCESS_HOTKEYSOUND,            BASICS_HOTKEYSOUND,
        ACCESS_SHOWSTATUSINDICATOR,    BASICS_INDICATOR,
        ACCESS_CLICKON,                FKF_CLICKON,
        NULL,                       0
    };

    ACCESS_OPTION MouseKeys[] = {
        ACCESS_ON,                     BASICS_ON,
        ACCESS_AVAILABLE,              BASICS_AVAILABLE,
        ACCESS_HOTKEYACTIVE,           BASICS_HOTKEYACTIVE,
        ACCESS_CONFIRMHOTKEY,          BASICS_CONFIRMHOTKEY,
        ACCESS_HOTKEYSOUND,            BASICS_HOTKEYSOUND,
        ACCESS_SHOWSTATUSINDICATOR,    BASICS_INDICATOR,
        ACCESS_MODIFIERS,              MKF_MODIFIERS|SPECIAL_INVERT_OPTION,
        ACCESS_REPLACENUMBERS,         MKF_REPLACENUMBERS,
        NULL,                       0
    };

    ACCESS_OPTION StickyKeys[] = {
        ACCESS_ON,                     BASICS_ON,
        ACCESS_AVAILABLE,              BASICS_AVAILABLE,
        ACCESS_HOTKEYACTIVE,           BASICS_HOTKEYACTIVE,
        ACCESS_CONFIRMHOTKEY,          BASICS_CONFIRMHOTKEY,
        ACCESS_HOTKEYSOUND,            BASICS_HOTKEYSOUND,
        ACCESS_SHOWSTATUSINDICATOR,    BASICS_INDICATOR,
        ACCESS_AUDIBLEFEEDBACK,        SKF_AUDIBLEFEEDBACK,
        ACCESS_TRISTATE,               SKF_TRISTATE,
        ACCESS_TWOKEYSOFF,             SKF_TWOKEYSOFF,
        NULL,                       0
    };

    ACCESS_OPTION SoundSentry[] = {
        ACCESS_ON,                     BASICS_ON,
        ACCESS_AVAILABLE,              BASICS_AVAILABLE,
        ACCESS_SHOWSTATUSINDICATOR,    BASICS_INDICATOR,
        NULL,                       0
    };

    ACCESS_OPTION TimeOut[] = {
        ACCESS_ON,                     BASICS_ON,
        ACCESS_ONOFFFEEDBACK,          ATF_ONOFFFEEDBACK,
        NULL,                       0
    };

    ACCESS_OPTION ToggleKeys[] = {
        ACCESS_ON,                     BASICS_ON,
        ACCESS_AVAILABLE,              BASICS_AVAILABLE,
        ACCESS_HOTKEYACTIVE,           BASICS_HOTKEYACTIVE,
        ACCESS_CONFIRMHOTKEY,          BASICS_CONFIRMHOTKEY,
        ACCESS_HOTKEYSOUND,            BASICS_HOTKEYSOUND,
        ACCESS_SHOWSTATUSINDICATOR,    BASICS_INDICATOR,
        NULL,                       0
    };

    ACCESS_OPTION HighContrast[] = {
        ACCESS_ON,                     BASICS_ON,
        ACCESS_AVAILABLE,              BASICS_AVAILABLE,
        ACCESS_HOTKEYACTIVE,           BASICS_HOTKEYACTIVE,
        ACCESS_CONFIRMHOTKEY,          BASICS_CONFIRMHOTKEY,
        ACCESS_HOTKEYSOUND,            BASICS_HOTKEYSOUND,
        ACCESS_SHOWSTATUSINDICATOR,    BASICS_INDICATOR,
        ACCESS_HOTKEYAVAILABLE,        HCF_HOTKEYAVAILABLE,
        NULL,                       0
    };

    ChkErr (Win32Printf (h, "\r\n[Accessibility]\r\n"));
    ChkErr (ScanConvertFlags (h, ACCESS_KEY "KeyboardResponse", &FilterKeys[0],  BASICS_AVAILABLE));
    ChkErr (ScanConvertFlags (h, ACCESS_KEY "MouseKeys",   &MouseKeys[0],   BASICS_AVAILABLE));
    ChkErr (ScanConvertFlags (h, ACCESS_KEY "StickyKeys",  &StickyKeys[0],  BASICS_AVAILABLE));
    ChkErr (ScanConvertFlags (h, ACCESS_KEY "SoundSentry", &SoundSentry[0], BASICS_AVAILABLE));
    ChkErr (ScanConvertFlags (h, ACCESS_KEY "TimeOut",     &TimeOut[0],     0));
    ChkErr (ScanConvertFlags (h, ACCESS_KEY "ToggleKeys",  &ToggleKeys[0],  0));
    ChkErr (ScanConvertFlags (h, ACCESS_KEY "HighContrast",&HighContrast[0],
        BASICS_AVAILABLE | BASICS_INDICATOR | HCF_HOTKEYAVAILABLE));

Err:
    if (Verbose && dwErr != ERROR_SUCCESS)
        Win32Printf (LogFile, "Out ScanAccessibility => %d\n", dwErr);
    return dwErr;
}

#define DESKTOP_KEY TEXT("Control Panel\\desktop")

//+--------------------------------------------------------------------------
//
//  Function:   ScanGetScreenSaverExe
//
//  Synopsis:   get screen saver name from system.ini
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//---------------------------------------------------------------------------

DWORD ScanGetScreenSaverExe (HANDLE h)
{
    DWORD dwErr = ERROR_SUCCESS;
    TCHAR IniFileSetting[MAX_PATH];

    GetPrivateProfileString (
            TEXT("boot"),
            SCRNSAVE,
            TEXT(""),
            IniFileSetting,
            MAX_PATH,
            TEXT("SYSTEM.INI"));

    if (IniFileSetting[0] == '\0')
        return ERROR_SUCCESS;

    dwErr = Win32Printf (h, "HKR, \"%s\", \"%s\", 0x%x, \"%s\"\r\n",
                 DESKTOP_KEY, SCRNSAVE, FLG_ADDREG_TYPE_SZ, IniFileSetting);

    return dwErr;
}

//+--------------------------------------------------------------------------
//
//  Function:   ScanDesktop
//
//  Synopsis:   convert desktop settings
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//---------------------------------------------------------------------------

DWORD ScanDesktop (HANDLE h)
{
    DWORD dwErr = ERROR_SUCCESS;

    if (Win9x)  // screen savers are already in the registry on NT
    {
        ChkErr (Win32Printf (h, "\r\n[Desktop]\r\n"));
        ChkErr (ScanGetScreenSaverExe (h));
        ChkErr (Win32Printf (h, "\r\n"));

Err:
        if (Verbose && dwErr != ERROR_SUCCESS)
            Win32Printf (LogFile, "Out ScanDesktop => %x\r\n", dwErr);
    }
    return dwErr;
}

#define IS_IME_KBDLAYOUT(hkl) ((HIWORD((ULONG_PTR)(hkl)) & 0xf000) == 0xe000)

//+--------------------------------------------------------------------------
//
//  Function:   ScanGetKeyboardLayouts
//
//  Synopsis:   retrieve all active input locales
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//---------------------------------------------------------------------------

DWORD ScanGetKeyboardLayouts (HANDLE h)
{
    DWORD dwErr = ERROR_SUCCESS;
    TCHAR kbname[KL_NAMELENGTH];
    int nLayout = GetKeyboardLayoutList(0, NULL);
    HKL hkl = GetKeyboardLayout (0);
    HKL * phkl = new HKL [nLayout];
    if (phkl == NULL)
        ChkErr (ERROR_NOT_ENOUGH_MEMORY);

    if (FALSE != GetKeyboardLayoutName (kbname))
    {
        // get the default input locale
        //
        ChkErr (Win32Printf (h, "%s=%s", INPUTLOCALE, kbname));
        GetKeyboardLayoutList (nLayout, phkl);

        for (int i=0; i < nLayout; i++)
        {
            if (hkl != phkl[i])  // get the alternate layouts
            {
                if (0 == ActivateKeyboardLayout (phkl[i], 0))
                {
                    if (!IS_IME_KBDLAYOUT(phkl[i]))  // use locale default
                        wsprintf (kbname, "%08x", LOWORD(phkl[i]));
                    ChkErr (Win32Printf (h, ",%s", kbname));
                }
                else if (FALSE != GetKeyboardLayoutName (kbname))
                    ChkErr (Win32Printf (h, ",%s", kbname));
            }
        }
        ChkErr (Win32Printf (h, "\r\n"));
    }

Err:
    ActivateKeyboardLayout (hkl, 0);  // restore current input locale
    if (phkl != NULL)
        delete [] phkl;
    return dwErr;
}

//+---------------------------------------------------------------------------
//
//  Function:   ScanSystem
//
//  Synopsis:   scan system settings
//
//  Arguments:
//
//  Returns:    Appropriate status code
//
//  History:    20-Sep-99   HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD ScanSystem()
{
  DWORD result = ERROR_SUCCESS;

  if (!CopySystem && !SchedSystem)
    goto cleanup;

#if 0
  result = ScanEnumerateShares (OutputFile);
  if (result != ERROR_SUCCESS)
    goto cleanup;
#else
  Win32Printf (OutputFile, (CHAR *) SHARES);
#endif

  if (DebugOutput)
       Win32Printf(LogFile, " Enumerating Net Resources\r\n");
  result = ScanEnumerateNetResources (OutputFile, RESOURCE_CONNECTED, NULL);
  if (result != ERROR_SUCCESS)
    goto cleanup;

  if (DebugOutput)
       Win32Printf(LogFile, " Enumerating Printers\r\n");
  result = ScanEnumeratePrinters (OutputFile);
  if (result != ERROR_SUCCESS)
    goto cleanup;

  if (DebugOutput)
       Win32Printf(LogFile, " Scanning RAS Settings\r\n");
  result = InitializeRasApi();
  if (result == ERROR_SUCCESS)
  {
      result = ScanRasSettings (OutputFile);
      if (result != ERROR_SUCCESS)
          goto cleanup;
  }

  if (Win9x)  // Accessibility settings on NT are registry compatible and forced
  {
    if (DebugOutput)
         Win32Printf(LogFile, " Scanning Accessibility options\r\n");
    result = ScanAccessibility (OutputFile);  // convert the settings
    if (result != ERROR_SUCCESS)
        goto cleanup;
  }

  if (DebugOutput)
       Win32Printf(LogFile, " Scanning Desktop\r\n");
  result = ScanDesktop (OutputFile);
  if (result != ERROR_SUCCESS)
    goto cleanup;

cleanup:
    if (result != ERROR_SUCCESS)
        LogFormatError (result);

    return result;
}