windows-xp/Source/XPSP1/NT/base/ntsetup/oobe/msobcomm/misc.cpp

/*-----------------------------------------------------------------------------
    misc.cpp

    service functions

  History:
        1/7/98      DONALDM Moved to new ICW project and string
                    and nuked 16 bit stuff
-----------------------------------------------------------------------------*/

//#include <stdio.h>
#include "obcomglb.h"
#include <shlobj.h>
#include <winsock2.h>
#include <assert.h>
#include <ras.h>
#include <util.h>
#include <inetreg.h>
#include <userenv.h>
#include <userenvp.h>
#include <shlwapi.h>
#include <sddl.h>
extern "C"
{
#include <sputils.h>
}

#define DIR_SIGNUP L"signup"
#define DIR_WINDOWS L"windows"
#define DIR_SYSTEM L"system"
#define DIR_TEMP L"temp"
#define INF_DEFAULT L"SPAM SPAM SPAM SPAM SPAM SPAM EGGS AND SPAM"
const WCHAR cszFALSE[] = L"FALSE";
const WCHAR cszTRUE[]  = L"TRUE";

BOOL g_bGotProxy=FALSE;

//+----------------------------------------------------------------------------
// NAME: GetSz
//
//    Load strings from resources
//
//  Created 1/28/96,        Chris Kauffman
//+----------------------------------------------------------------------------

LPWSTR GetSz(DWORD dwszID)
{
    /*
    LPWSTR psz = szStrTable[iSzTable];

    iSzTable++;
    if (iSzTable >= MAX_STRINGS)
        iSzTable = 0;

    if (!LoadString(_Module.GetModuleInstance(), dwszID, psz, 512))
    {
        *psz = 0;
    }

    return (psz);
    */
    return (NULL);
}


//+---------------------------------------------------------------------------
//
//  Function:   ProcessDBCS
//
//  Synopsis:   Converts control to use DBCS compatible font
//              Use this at the beginning of the dialog procedure
//  
//              Note that this is required due to a bug in Win95-J that prevents
//              it from properly mapping MS Shell Dlg.  This hack is not needed
//              under winNT.
//
//  Arguments:  hwnd - Window handle of the dialog
//              cltID - ID of the control you want changed.
//
//  Returns:    ERROR_SUCCESS
//
//  History:    4/31/97 a-frankh    Created
//              5/13/97 jmazner     Stole from CM to use here
//----------------------------------------------------------------------------
void ProcessDBCS(HWND hDlg, int ctlID)
{
    HFONT hFont = NULL;

    /*if( IsNT() )
    {
        return;
    }*/

    hFont = (HFONT) GetStockObject(DEFAULT_GUI_FONT);
    if (hFont == NULL)
        hFont = (HFONT) GetStockObject(SYSTEM_FONT);
    if (hFont != NULL)
        SendMessage(GetDlgItem(hDlg, ctlID), WM_SETFONT, (WPARAM) hFont, MAKELPARAM(TRUE, 0));
}

// ############################################################################
//  StoreInSignUpReg
//
//  Created 3/18/96,        Chris Kauffman
// ############################################################################
HRESULT StoreInSignUpReg(LPBYTE lpbData, DWORD dwSize, DWORD dwType, LPCWSTR pszKey)
{
    HRESULT hr = ERROR_ACCESS_DENIED;
    HKEY hKey;

    hr = RegCreateKey(HKEY_LOCAL_MACHINE, SIGNUPKEY, &hKey);
    if (hr != ERROR_SUCCESS) goto StoreInSignUpRegExit;
    hr = RegSetValueEx(hKey, pszKey, 0,dwType,lpbData,dwSize);


    RegCloseKey(hKey);

StoreInSignUpRegExit:
    return hr;
}

HRESULT ReadSignUpReg(LPBYTE lpbData, DWORD *pdwSize, DWORD dwType, LPCWSTR pszKey)
{
    HRESULT hr = ERROR_ACCESS_DENIED;
    HKEY hKey = 0;

    hr = RegOpenKey(HKEY_LOCAL_MACHINE, SIGNUPKEY, &hKey);
    if (hr != ERROR_SUCCESS) goto ReadSignUpRegExit;
    hr = RegQueryValueEx(hKey, pszKey, 0,&dwType,lpbData,pdwSize);

ReadSignUpRegExit:
    if (hKey) RegCloseKey (hKey);
    return hr;
}


HRESULT DeleteSignUpReg(LPCWSTR pszKey)
{
    HRESULT hr = ERROR_ACCESS_DENIED;
    HKEY hKey = 0;

    hr = RegOpenKeyEx(HKEY_LOCAL_MACHINE, SIGNUPKEY, 0, KEY_ALL_ACCESS, &hKey);
    if (hr != ERROR_SUCCESS) goto ReadSignUpRegExit;
    hr = RegDeleteValue(hKey, pszKey);

ReadSignUpRegExit:
    if (hKey) RegCloseKey (hKey);
    return hr;
}

// ############################################################################
//  GetDataFromISPFile
//
//  This function will read a specific piece of information from an ISP file.
//
//  Created 3/16/96,        Chris Kauffman
// ############################################################################
HRESULT GetDataFromISPFile
(
    LPWSTR pszISPCode,
    LPWSTR pszSection,
    LPWSTR pszDataName,
    LPWSTR pszOutput,
    DWORD cchOutput)
{
    LPWSTR   pszTemp;
    HRESULT hr = ERROR_SUCCESS;
    WCHAR    szTempPath[MAX_PATH];
    //WCHAR    szBuff256[256];

    *pszOutput = L'\0'; // since lstrlen(pszOutput) is used later when
                        // pszOutput may be otherwise still uninitialized

    // Locate ISP file
    if (!SearchPath(NULL, pszISPCode, INF_SUFFIX,MAX_PATH,szTempPath,&pszTemp))
    {
        //wsprintf(szBuff256, L"Can not find:%s%s (%d) (connect.exe)", pszISPCode,INF_SUFFIX,GetLastError());
        ////AssertMsg(0, szBuff256);
        //lstrcpyn(szTempPath, pszISPCode, MAX_PATH);
        //lstrcpyn(&szTempPath[lstrlen(szTempPath)], INF_SUFFIX, MAX_PATH-lstrlen(szTempPath));
        //wsprintf(szBuff256, GetSz(IDS_CANTLOADINETCFG), szTempPath);
        ////MessageBox(NULL, szBuff256, GetSz(IDS_TITLE),MB_MYERROR);
        hr = ERROR_FILE_NOT_FOUND;
    } else if (!GetPrivateProfileString(pszSection, pszDataName, INF_DEFAULT,
        pszOutput, (int)cchOutput, szTempPath))
    {
        //TraceMsg(TF_GENERAL, L"ICWHELP: %s not specified in ISP file.\n", pszDataName);
        hr = ERROR_FILE_NOT_FOUND;
    }

    // 10/23/96 jmazner Normandy #9921
    // CompareString does _not_ have same return values as lsrtcmp!
    // Return value of 2 indicates strings are equal.
    //if (!CompareString(LOCALE_SYSTEM_DEFAULT, 0, INF_DEFAULT,lstrlen(INF_DEFAULT),pszOutput,lstrlen(pszOutput)))
    if (2 == CompareString(LOCALE_SYSTEM_DEFAULT, 0, INF_DEFAULT,lstrlen(INF_DEFAULT),pszOutput,lstrlen(pszOutput)))
    {
        hr = ERROR_FILE_NOT_FOUND;
    }

    if (hr != ERROR_SUCCESS && cchOutput)
        *pszOutput = L'\0'; // I suppose if CompareString fails, this is not
                            // redundant with the first *pszOutput = L'\0';.
    return hr;
}

// ############################################################################
//  GetINTFromISPFile
//
//  This function will read a specific integer from an ISP file.
//
//
// ############################################################################
HRESULT GetINTFromISPFile
(
    LPWSTR   pszISPCode,
    LPWSTR   pszSection,
    LPWSTR   pszDataName,
    int far *lpData,
    int     iDefaultValue
)
{
    LPWSTR   pszTemp;
    HRESULT hr = ERROR_SUCCESS;
    WCHAR    szTempPath[MAX_PATH];
    //WCHAR    szBuff256[256];

    // Locate ISP file
    if (!SearchPath(NULL, pszISPCode, INF_SUFFIX,MAX_PATH,szTempPath,&pszTemp))
    {
        //wsprintf(szBuff256, L"Can not find:%s%s (%d) (connect.exe)", pszISPCode,INF_SUFFIX,GetLastError());
        ////AssertMsg(0, szBuff256);
        //lstrcpyn(szTempPath, pszISPCode, MAX_PATH);
        //lstrcpyn(&szTempPath[lstrlen(szTempPath)], INF_SUFFIX, MAX_PATH-lstrlen(szTempPath));
        //wsprintf(szBuff256, GetSz(IDS_CANTLOADINETCFG), szTempPath);
        //MessageBox(NULL, szBuff256, GetSz(IDS_TITLE),MB_MYERROR);
        hr = ERROR_FILE_NOT_FOUND;
    }

    *lpData = GetPrivateProfileInt(pszSection,
                                   pszDataName,
                                   iDefaultValue,
                                   szTempPath);
    return hr;
}


//+-------------------------------------------------------------------
//
//  Function:   IsNT
//
//  Synopsis:   findout If we are running on NT
//
//  Arguements: none
//
//  Return:     TRUE -  Yes
//              FALSE - No
//
//--------------------------------------------------------------------
BOOL IsNT ()
{
    OSVERSIONINFO  OsVersionInfo;

    ZeroMemory(&OsVersionInfo, sizeof(OSVERSIONINFO));
    OsVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    GetVersionEx(&OsVersionInfo);
    return (VER_PLATFORM_WIN32_NT == OsVersionInfo.dwPlatformId);

}  //end of IsNT function call

//+-------------------------------------------------------------------
//
//  Function:   IsNT4SP3Lower
//
//  Synopsis:   findout If we are running on NTSP3 or lower
//
//  Arguements: none
//
//  Return:     TRUE -  Yes
//              FALSE - No
//
//--------------------------------------------------------------------

BOOL IsNT4SP3Lower()
{
    return FALSE;
}



// ############################################################################
HRESULT ClearProxySettings()
{
    /*
    HINSTANCE hinst = NULL;
    FARPROC fp;
    HRESULT hr = ERROR_SUCCESS;

    hinst = LoadLibrary(L"INETCFG.DLL");
    if (hinst)
    {
        fp = GetProcAddress(hinst, "InetGetProxy");
        if (!fp)
        {
            hr = GetLastError();
            goto ClearProxySettingsExit;
        }
        //hr = ((PFNINETGETPROXY)fp)(&g_bProxy, NULL, 0,NULL,0);
        if (hr == ERROR_SUCCESS)
            g_bGotProxy = TRUE;
        else
            goto ClearProxySettingsExit;

        if (g_bProxy)
        {
            fp = GetProcAddress(hinst, "InetSetProxy");
            if (!fp)
            {
                hr = GetLastError();
                goto ClearProxySettingsExit;
            }
            ((PFNINETSETPROXY)fp)(FALSE, (LPCSTR)NULL, (LPCSTR)NULL);
        }
    } else {
        hr = GetLastError();
    }

ClearProxySettingsExit:
    if (hinst)
        FreeLibrary(hinst);
    return hr;
    */
    return ERROR_SUCCESS;
}

// ############################################################################
HRESULT RestoreProxySettings()
{
    /*
    HINSTANCE hinst = NULL;
    FARPROC fp;
    HRESULT hr = ERROR_SUCCESS;

    hinst = LoadLibrary(L"INETCFG.DLL");
    if (hinst && g_bGotProxy)
    {
        fp = GetProcAddress(hinst, "InetSetProxy");
        if (!fp)
        {
            hr = GetLastError();
            goto RestoreProxySettingsExit;
        }
        ((PFNINETSETPROXY)fp)(g_bProxy, (LPCSTR)NULL, (LPCSTR)NULL);
    } else {
        hr = GetLastError();
    }

RestoreProxySettingsExit:
    if (hinst)
        FreeLibrary(hinst);
    return hr;
    */
    return ERROR_SUCCESS;
}

// ############################################################################
BOOL FSz2Dw(LPCWSTR pSz, LPDWORD dw)
{
    DWORD val = 0;
    while (*pSz && *pSz != L'.')
    {
        if (*pSz >= L'0' && *pSz <= L'9')
        {
            val *= 10;
            val += *pSz++ - L'0';
        }
        else
        {
            return FALSE;  //bad number
        }
    }
    *dw = val;
    return (TRUE);
}

// ############################################################################
LPWSTR GetNextNumericChunk(LPWSTR psz, LPWSTR pszLim, LPWSTR* ppszNext)
{
    LPWSTR pszEnd;

    // init for error case
    *ppszNext = NULL;
    // skip non numerics if any to start of next numeric chunk
    while(*psz<L'0' || *psz>L'9')
    {
        if(psz >= pszLim) return NULL;
        psz++;
    }
    // skip all numerics to end of country code
    for(pszEnd=psz; *pszEnd>=L'0' && *pszEnd<=L'9' && pszEnd<pszLim; pszEnd++)
        ;
    // zap whatever delimiter there was to terminate this chunk
    *pszEnd++ = L'\0';
    // return ptr to next chunk (pszEnd now points to it)
    if(pszEnd<pszLim)
        *ppszNext = pszEnd;
        
    return psz; // return ptr to start of chunk
}

// ############################################################################
// BOOL FSz2DwEx(PCSTR pSz, DWORD *dw)
// Accepts -1 as a valid number. currently this is used for LCID, since all langs has a LDID == -1
BOOL FSz2DwEx(LPCWSTR pSz, DWORD far *dw)
{
    DWORD val = 0;
    BOOL    bNeg = FALSE;
    while (*pSz)
    {
        if( *pSz == L'-' )
        {
            bNeg = TRUE;
            pSz++;
        }
        else if ((*pSz >= L'0' && *pSz <= L'9'))
        {
            val *= 10;
            val += *pSz++ - L'0';
        }
        else
        {
            return FALSE;  //bad number
        }
    }
    if(bNeg)
        val = 0 - val;

    *dw = val;
    return (TRUE);
}

// ############################################################################
// BOOL FSz2WEx(PCSTR pSz, WORD *w)
//Accepts -1 as a valid number. currently this is used for LCID, since all langs has a LDID == -1
BOOL FSz2WEx(LPCWSTR pSz, WORD far *w)
{
    DWORD dw;
    if (FSz2DwEx(pSz, &dw))
    {
        *w = (WORD)dw;
        return TRUE;
    }
    return FALSE;
}

// ############################################################################
// BOOL FSz2W(PCSTR pSz, WORD *w)
BOOL FSz2W(LPCWSTR pSz, WORD far *w)
{
    DWORD dw;
    if (FSz2Dw(pSz, &dw))
    {
        *w = (WORD)dw;
        return TRUE;
    }
    return FALSE;
}

// ############################################################################
WORD Sz2W (LPCWSTR szBuf)
{
    DWORD dw;
    if (FSz2Dw(szBuf, &dw))
    {
        return (WORD)dw;
    }
    return 0;
}

// ############################################################################
// BOOL FSz2B(PCSTR pSz, BYTE *pb)
BOOL FSz2BOOL(LPCWSTR pSz, BOOL far *pbool)
{
    if (lstrcmpi(cszFALSE, pSz) == 0)
    {
        *pbool = (BOOL)FALSE;
    }
    else
    {
        *pbool = (BOOL)TRUE;
    }
    return TRUE;
}

// ############################################################################
// BOOL FSz2B(PCSTR pSz, BYTE *pb)
BOOL FSz2B(LPCWSTR pSz, BYTE far *pb)
{
    DWORD dw;
    if (FSz2Dw(pSz, &dw))
    {
        *pb = (BYTE)dw;
        return TRUE;
    }
    return FALSE;
}

BOOL FSz2SPECIAL(LPCWSTR pSz, BOOL far *pbool, BOOL far *pbIsSpecial, int far *pInt)
{
    // See if the value is a BOOL (TRUE or FALSE)
    if (lstrcmpi(cszFALSE, pSz) == 0)
    {
        *pbool = FALSE;
        *pbIsSpecial = FALSE;
    }
    else if (lstrcmpi(cszTRUE, pSz) == 0)
    {
        *pbool = (BOOL)TRUE;
        *pbIsSpecial = FALSE;
    }
    else
    {
        // Not a BOOL, so it must be special
        *pbool = (BOOL)FALSE;
        *pbIsSpecial = TRUE;
        *pInt = _wtoi(pSz);
    }
    return TRUE;
}

// ############################################################################
int FIsDigit( int c )
{
    WCHAR szIn[2];
    WORD rwOut[2];
    szIn[0] = (WCHAR)c;
    szIn[1] = L'\0';
    GetStringTypeEx(LOCALE_USER_DEFAULT, CT_CTYPE1, szIn,-1,rwOut);
    return rwOut[0] & C1_DIGIT;

}

// ############################################################################
LPBYTE MyMemSet(LPBYTE dest, int c, size_t count)
{
    LPVOID pv = dest;
    LPVOID pvEnd = (LPVOID)(dest + (WORD)count);
    while (pv < pvEnd)
    {
        *(LPINT)pv = c;
        //((WORD)pv)++;
        pv=((LPINT)pv)+1;
    }
    return dest;
}

// ############################################################################
LPBYTE MyMemCpy(LPBYTE dest, const LPBYTE src, size_t count)
{
    LPBYTE pbDest = (LPBYTE)dest;
    LPBYTE pbSrc = (LPBYTE)src;
    LPBYTE pbEnd = (LPBYTE)((DWORD_PTR)src + (DWORD_PTR)count);
    while (pbSrc < pbEnd)
    {
        *pbDest = *pbSrc;
        pbSrc++;
        pbDest++;
    }
    return dest;
}

// ############################################################################
BOOL ShowControl(HWND hDlg, int idControl, BOOL fShow)
{
    HWND hWnd;

    if (NULL == hDlg)
    {
        ////AssertMsg(0, L"Null Param");
        return FALSE;
    }


    hWnd = GetDlgItem(hDlg, idControl);
    if (hWnd)
    {
        ShowWindow(hWnd, fShow ? SW_SHOW : SW_HIDE);
    }

    return TRUE;
}

BOOL isAlnum(WCHAR c)
{
    if ((c >= L'0' && c <= L'9')  ||
        (c >= L'a' && c <= L'z')  ||
        (c >= L'A' && c <= L'Z') )
        return TRUE;
    return FALSE;
}


// ############################################################################
BOOL FShouldRetry2(HRESULT hrErr)
{
    BOOL bRC;

    if (hrErr == ERROR_LINE_BUSY ||
        hrErr == ERROR_VOICE_ANSWER ||
        hrErr == ERROR_NO_ANSWER ||
        hrErr == ERROR_NO_CARRIER ||
        hrErr == ERROR_AUTHENTICATION_FAILURE ||
        hrErr == ERROR_PPP_TIMEOUT ||
        hrErr == ERROR_REMOTE_DISCONNECTION ||
        hrErr == ERROR_AUTH_INTERNAL ||
        hrErr == ERROR_PROTOCOL_NOT_CONFIGURED ||
        hrErr == ERROR_PPP_NO_PROTOCOLS_CONFIGURED)
    {
        bRC = TRUE;
    } else {
        bRC = FALSE;
    }

    return bRC;
}



//+----------------------------------------------------------------------------
//
//  Function:   FCampusNetOverride
//
//  Synopsis:   Detect if the dial should be skipped for the campus network
//
//  Arguments:  None
//
//  Returns:    TRUE - overide enabled
//
//  History:    8/15/96 ChrisK  Created
//
//-----------------------------------------------------------------------------
#if defined(PRERELEASE)
BOOL FCampusNetOverride()
{
    HKEY hkey = NULL;
    BOOL bRC = FALSE;
    DWORD dwType = 0;
    DWORD dwSize = 0;
    DWORD dwData = 0;

    if (ERROR_SUCCESS != RegOpenKey(HKEY_LOCAL_MACHINE,
        L"Software\\Microsoft\\ISignup\\Debug", &hkey))
        goto FCampusNetOverrideExit;

    dwSize = sizeof(dwData);
    if (ERROR_SUCCESS != RegQueryValueEx(hkey, L"CampusNet", 0,&dwType,
        (LPBYTE)&dwData, &dwSize))
        goto FCampusNetOverrideExit;

    ////AssertMsg(REG_DWORD == dwType, L"Wrong value type for CampusNet.  Must be DWORD.\r\n");
    bRC = (0 != dwData);

    if (bRC)
    {
        if (IDOK != MessageBox(NULL, L"DEBUG ONLY: CampusNet will be used.", L"Testing Override",MB_OKCANCEL))
            bRC = FALSE;
    }
FCampusNetOverrideExit:
    if (hkey)
        RegCloseKey(hkey);

    return bRC;
}
#endif //PRERELEASE



//+----------------------------------------------------------------------------
//  Function    CopyUntil
//
//  Synopsis    Copy from source until destination until running out of source
//              or until the next character of the source is the chend character
//
//  Arguments   dest - buffer to recieve characters
//              src - source buffer
//              lpdwLen - length of dest buffer
//              chend - the terminating character
//
//  Returns     FALSE - ran out of room in dest buffer
//
//  Histroy     10/25/96    ChrisK  Created
//-----------------------------------------------------------------------------
static BOOL CopyUntil(LPWSTR *dest, LPWSTR *src, LPDWORD lpdwLen, WCHAR chend)
{
    while ((L'\0' != **src) && (chend != **src) && (0 != *lpdwLen))
    {
        **dest = **src;
        (*lpdwLen)--;
        (*dest)++;
        (*src)++;
    }
    return (0 != *lpdwLen);
}



//+---------------------------------------------------------------------------
//
//  Function:   GenericMsg
//
//----------------------------------------------------------------------------
void GenericMsg
(
    HWND    hwnd,
    UINT    uId,
    LPCWSTR  lpszArg,
    UINT    uType
)
{
    WCHAR szTemp[MAX_STRING + 1];
    WCHAR szMsg[MAX_STRING + MAX_PATH + 1];
    LPWSTR psz;

    //Assert( lstrlen( GetSz(uId) ) <= MAX_STRING );

    psz = GetSz( (DWORD)uId );
    if (psz) {
        lstrcpy( szTemp, psz );
    }
    else {
        szTemp[0] = '\0';
    }

    if (lpszArg)
    {
        //Assert( lstrlen( lpszArg ) <= MAX_PATH );
        wsprintf(szMsg, szTemp, lpszArg);
    }
    else
    {
        lstrcpy(szMsg, szTemp);
    }
    //MessageBox(hwnd,
    //          szMsg,
    //           GetSz(IDS_TITLE),
    //           uType);
}

//=--------------------------------------------------------------------------=
// MakeWideFromAnsi
//=--------------------------------------------------------------------------=
// given a string, make a BSTR out of it.
//
// Parameters:
//    LPWSTR         - [in]
//    BYTE          - [in]
//
// Output:
//    LPWSTR        - needs to be cast to final desired result
//
// Notes:
//
LPWSTR MakeWideStrFromAnsi
(
    LPSTR psz,
    BYTE  bType
)
{
    LPWSTR pwsz = NULL;
    int i;

    // arg checking.
    //
    if (!psz)
        return NULL;

    // compute the length of the required BSTR
    //
    i =  MultiByteToWideChar(CP_ACP, 0, psz, -1, NULL, 0);
    if (i <= 0) return NULL;

    // allocate the widestr
    //
    switch (bType) {
      case STR_BSTR:
        // -1 since it'll add it's own space for a NULL terminator
        //
        pwsz = (LPWSTR) SysAllocStringLen(NULL, i - 1);
        break;
      case STR_OLESTR:
        pwsz = (LPWSTR) CoTaskMemAlloc(BYTES_REQUIRED_BY_CCH(i));
        break;
      //default:
        ////AssertMsg(0, L"Bogus String Type.");
    }

    if (!pwsz) return NULL;
    MultiByteToWideChar(CP_ACP, 0, psz, -1, pwsz, i);
    pwsz[i - 1] = 0;
    return pwsz;
}

//=--------------------------------------------------------------------------=
// MakeWideStrFromResId
//=--------------------------------------------------------------------------=
// given a resource ID, load it, and allocate a wide string for it.
//
// Parameters:
//    WORD            - [in] resource id.
//    BYTE            - [in] type of string desired.
//
// Output:
//    LPWSTR          - needs to be cast to desired string type.
//
// Notes:
//
LPWSTR MakeWideStrFromResourceId
(
    WORD    wId,
    BYTE    bType
)
{
    //int i;

    CHAR szTmp[512] = "0";

    // load the string from the resources.
    //
    //i = LoadString(_Module.GetModuleInstance(), wId, szTmp, 512);
    //if (!i) return NULL;

    return MakeWideStrFromAnsi(szTmp, bType);
}

//=--------------------------------------------------------------------------=
// MakeWideStrFromWide
//=--------------------------------------------------------------------------=
// given a wide string, make a new wide string with it of the given type.
//
// Parameters:
//    LPWSTR            - [in]  current wide str.
//    BYTE              - [in]  desired type of string.
//
// Output:
//    LPWSTR
//
// Notes:
//
LPWSTR MakeWideStrFromWide
(
    LPWSTR pwsz,
    BYTE   bType
)
{
    LPWSTR pwszTmp = NULL;
    int i;

    if (!pwsz) return NULL;

    // just copy the string, depending on what type they want.
    //
    switch (bType) {
      case STR_OLESTR:
        i = lstrlenW(pwsz);
        pwszTmp = (LPWSTR)CoTaskMemAlloc(BYTES_REQUIRED_BY_CCH(i+1));
        if (!pwszTmp) return NULL;
        memcpy(pwszTmp, pwsz, (BYTES_REQUIRED_BY_CCH(i+1)));
        break;

      case STR_BSTR:
        pwszTmp = (LPWSTR)SysAllocString(pwsz);
        break;
    }

    return pwszTmp;
}

HRESULT
GetCommonAppDataDirectory(
    LPWSTR              szDirectory,
    DWORD               cchDirectory
    )
{
    assert(MAX_PATH <= cchDirectory);
    if (MAX_PATH > cchDirectory)
    {
        return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
    }

    return SHGetFolderPath(NULL,  // hwndOwner
                           CSIDL_COMMON_APPDATA,
                           NULL,  // hAccessToken
                           SHGFP_TYPE_CURRENT,
                           szDirectory
                           );
}

const LPWSTR            cszPhoneBookPath =
                            L"Microsoft\\Network\\Connections\\Pbk";
const LPWSTR            cszDefPhoneBook = L"rasphone.pbk";
HRESULT
GetDefaultPhoneBook(
    LPWSTR              szPhoneBook,
    DWORD               cchPhoneBook
    )
{
    WCHAR               rgchDirectory[MAX_PATH];
    int                 cch;
    HRESULT             hr = GetCommonAppDataDirectory(rgchDirectory, MAX_PATH);

    if (FAILED(hr))
    {
        return hr;
    }

    if (cchPhoneBook < (DWORD)(lstrlen(rgchDirectory) + lstrlen(cszPhoneBookPath) + lstrlen(cszDefPhoneBook) + 3)
        )
    {
        return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
    }

    cch = wsprintf(szPhoneBook, L"%s\\%s\\%s",
                   rgchDirectory, cszPhoneBookPath, cszDefPhoneBook
                   );
    assert(cch ==  lstrlen(rgchDirectory) + lstrlen(cszPhoneBookPath) +
                   lstrlen(cszDefPhoneBook) + 2
           );

    return hr;
}

BOOL
INetNToW(
    struct in_addr      inaddr,
    LPWSTR              szAddr
    )
{
    USES_CONVERSION;

    LPSTR               sz = inet_ntoa(inaddr);

    if (NULL != sz)
    {
        lstrcpy(szAddr, A2W(sz));
    }

    return (NULL != sz);

}   //  INetNToW


#ifndef REGSTR_VAL_NONETAUTODIAL
#define REGSTR_VAL_NONETAUTODIAL                        L"NoNetAutodial"
#endif

LONG
SetAutodial(
    IN HKEY hUserRoot,              // HKEY_CURRENT_USER or other user hive root
    IN AUTODIAL_TYPE eType,         // Type of autodial for the connectoid
    IN LPCWSTR szConnectoidName,    // NULL terminated string of connectoid name
    IN BOOL bSetICWCompleted        // set ICW completed flag or not
    )
    
/*++

Routine Description:
    
    Set a particular per-user registry settings to default an autodial
    connectoid to the name specified and always dial the autodial connection, and/or
    set the ICW completed flag

Return Value:

    WIN32 Error code, i.e. ERROR_SUCCESS on success, -1 or other non-zero value
    on failure.

Note:

    Despite the name, this function sets ICW Completed flag if bSetICWCompleted
    is true and do not set autodial if szConnectoidName is NULL.

--*/

{
    LONG  ret = -1;
    HKEY  hKey = NULL;
    DWORD dwRet = -1;

    if (bSetICWCompleted)
    {
        if (ERROR_SUCCESS == RegCreateKey( hUserRoot,
                                           ICWSETTINGSPATH,
                                           &hKey) )
        {
            DWORD dwCompleted = 1;
            
            ret = RegSetValueEx( hKey,
                                 ICWCOMPLETEDKEY,
                                 0,
                                 REG_DWORD,
                                 (CONST BYTE*)&dwCompleted,
                                 sizeof(dwCompleted) );
            TRACE1(L"Setting ICW Completed key 0x%08lx", ret);
            
            RegCloseKey(hKey);
        }
    }
    // Set the name if given, else do not change the entry.
    if (szConnectoidName)
    {
        // Set the name of the connectoid for autodial.
        // HKCU\RemoteAccess\InternetProfile
        if (ERROR_SUCCESS == RegCreateKey( hUserRoot,
                                           REGSTR_PATH_REMOTEACCESS,
                                           &hKey) )
        {
            ret = RegSetValueEx( hKey,
                                 REGSTR_VAL_INTERNETPROFILE,
                                 0,
                                 REG_SZ,
                                 (BYTE*)szConnectoidName,
                                 BYTES_REQUIRED_BY_SZ(szConnectoidName) );
            TRACE2(L"Setting IE autodial connectoid to %s 0x%08lx", szConnectoidName, ret);
            
            RegCloseKey(hKey);
        }

        hKey = NULL;
        if (ERROR_SUCCESS == ret)
        {
            // Set setting in the registry that indicates whether autodialing is enabled.
            // HKCU\Software\Microsoft\Windows\CurrentVersion\InternetSettings\EnableAutodial
            if (ERROR_SUCCESS == RegCreateKey( hUserRoot,
                                               REGSTR_PATH_INTERNET_SETTINGS,
                                               &hKey) )
            {
                DWORD dwValue;

                dwValue = (eType == AutodialTypeAlways || eType == AutodialTypeNoNet) ? 1 : 0;
                ret = RegSetValueEx( hKey,
                                     REGSTR_VAL_ENABLEAUTODIAL,
                                     0, 
                                     REG_DWORD,
                                     (BYTE*)&dwValue,
                                     sizeof(DWORD) );
                TRACE1(L"Enable/Disable IE Autodial 0x%08lx", ret);

                
                dwValue = (eType == AutodialTypeNoNet) ? 1 : 0;
                ret = RegSetValueEx( hKey,
                                     REGSTR_VAL_NONETAUTODIAL,
                                     0,
                                     REG_DWORD,
                                     (BYTE*)&dwValue,
                                     sizeof(DWORD) );
                TRACE1(L"Setting Autodial mode 0x%08lx", ret);
                
                RegCloseKey(hKey);
            }
        }

    }

    return ret;
}

LONG
SetUserAutodial(
    IN LPWSTR szProfileDir,     // Directory containing a user's ntuser.dat file
    IN AUTODIAL_TYPE eType,     // type of autodial for the connectoid
    IN LPCWSTR szConnectoidName,// NULL terminated string of connectoid name
    IN BOOL bSetICWCompleted    // set the ICW completed key or not
    )

/*++

Routine Description:

    Modified a user profile, specified by the profile directory, to enable
    autodial. SE_BACKUP_NAME and SE_RESTORE_NAME privileges are required to
    load and unload a user hive.

Return Value:

    WIN32 Error code, i.e. ERROR_SUCCESS on success, -1 or other non-zero value
    on failure.

--*/

{
    const WCHAR OOBE_USER_HIVE[] = L"OOBEUSERHIVE";

    HKEY  hUserHive = NULL;
    WCHAR szProfilePath[MAX_PATH+1] = L"";
    LONG  ret = -1;

    lstrcpyn(szProfilePath, szProfileDir, MAX_CHARS_IN_BUFFER(szProfilePath));
    pSetupConcatenatePaths(szProfilePath,
                           L"\\NTUSER.DAT",
                           MAX_CHARS_IN_BUFFER(szProfilePath),
                           NULL);
    ret = RegLoadKey(HKEY_USERS, OOBE_USER_HIVE, szProfilePath);
    if (ret == ERROR_SUCCESS)
    {
        ret = RegOpenKeyEx( HKEY_USERS,
                            OOBE_USER_HIVE,
                            0,
                            KEY_WRITE,                                
                            &hUserHive );
        if (ERROR_SUCCESS == ret)
        {
            ret = SetAutodial(hUserHive, eType, szConnectoidName, bSetICWCompleted);
            RegCloseKey(hUserHive);
            TRACE1(L"Autodial set %s", szProfilePath);
        }
        else
        {
            TRACE2(L"RegOpenKey %s failed %d", szProfilePath, ret);
        }
        RegUnLoadKey(HKEY_USERS, OOBE_USER_HIVE);
    }
    else
    {
        TRACE2(L"RegLoadKey %s failed %d", szProfilePath, ret);
    }
    
    return ret;
}

BOOL
MyGetUserProfileDirectory(
    IN     LPWSTR szUser,           // a user account name
    OUT    LPWSTR szUserProfileDir, // buffer to receive null terminate string
    IN OUT LPDWORD pcchSize         // input the buffer size in TCHAR, including terminating NULL
    )

/*++

Routine Description:

    This function does what the SDK function GetUserProfileDirectory does,
    except that it accepts a user account name instead of handle to a user
    token.

Return Value:

    TRUE  - Success

    FALSE - Failure

--*/

{
    PSID          pSid = NULL;
    DWORD         cbSid = 0;
    LPWSTR        szDomainName = NULL;
    DWORD         cbDomainName = 0;
    SID_NAME_USE  eUse = SidTypeUser;
    BOOL          bRet;
    
    bRet = LookupAccountName(NULL,
                             szUser,
                             NULL,
                             &cbSid,
                             NULL,
                             &cbDomainName,
                             &eUse);

    if (!bRet && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
    {
        pSid = (PSID) LocalAlloc(LPTR, cbSid);
        szDomainName = (LPWSTR) LocalAlloc(LPTR, cbDomainName * sizeof(TCHAR));
        
        if (pSid && szDomainName)
        {
            bRet = LookupAccountName(NULL,
                                     szUser,
                                     pSid,
                                     &cbSid,
                                     szDomainName,
                                     &cbDomainName,
                                     &eUse);
        }

    }
    
    if (bRet && SidTypeUser == eUse)
    {
        bRet = GetUserProfileDirFromSid(pSid, szUserProfileDir, pcchSize);
        if (!bRet)
        {
            TRACE1(L"GetUserProfileDirFromSid (%d)", GetLastError());
        }
    }
    else
    {
        if (SidTypeUser == eUse)
        {
            TRACE2(L"LookupAccountName %s (%d)", szUser, GetLastError());
        }
    }
    
    if (pSid)
    {
        LocalFree(pSid);
        pSid = NULL;
    }

    if (szDomainName)
    {
        LocalFree(szDomainName);
        szDomainName = NULL;
    }

    return bRet;
}

BOOL EnumBuildInAdministrators(
    OUT LPWSTR* pszAlias // list of name delimited by null, double null-terminated
    )
    
/*++

Routine Description:

    List all the build-in administrator accounts created by Windows Setup.

Return Value:

    TRUE  - Success

    FALSE - Failure

--*/

{
    WCHAR     szReservedAdmins[MAX_PATH * 2]  = L"";
    PWCHAR    p = NULL;
    DWORD     len;
    BOOL      ret = FALSE;
    HINSTANCE hInstance = NULL;

    if (pszAlias != NULL)
    {
        *pszAlias = NULL;

        hInstance = LoadLibraryEx(OOBE_MAIN_DLL, NULL, LOAD_LIBRARY_AS_DATAFILE);

        if (hInstance != NULL)
        {
            
            len = LoadString(hInstance,
                             566, // IDS_ACCTLIST_RESERVEDADMINS in OOBE_MAIN_DLL
                             szReservedAdmins,
                             MAX_CHARS_IN_BUFFER(szReservedAdmins));
            if (len)
            {
                DWORD cbSize;
                
                p = StrChr(szReservedAdmins, L'|');
                while ( p )
                {
                    PWCHAR t = CharNext(p);
                    *p = L'\0';
                    p = StrChr(t, L'|');
                }

                cbSize = sizeof(WCHAR) * (len + 1);
                // Make sure we have enough space for 
                // double NULL terminate the return value
                *pszAlias = (LPWSTR) GlobalAlloc(GPTR, cbSize + sizeof(WCHAR));
                if (*pszAlias)
                {
                    CopyMemory(*pszAlias, szReservedAdmins, cbSize);
                    // double NULL terminate the string
                    (*pszAlias)[cbSize / sizeof(WCHAR)] = L'\0';
                    ret = TRUE;
                }
            }

            FreeLibrary(hInstance);
        }
    }

    return ret;

}


BOOL
SetMultiUserAutodial(
    IN AUTODIAL_TYPE eType,     // type of autodial for the connectoid
    IN LPCWSTR szConnectoidName,// NULL terminated string of connectoid name
    IN BOOL bSetICWCompleted    // set the ICW completed key or not
    )
{
    BOOL             bSucceed = TRUE;
    LONG             lRet = ERROR_SUCCESS;
    WCHAR            szProfileDir[MAX_PATH+1] = L"";
    DWORD            dwSize;
    LPWSTR           szAdmins = NULL;

    // SYSTEM
    lRet = SetAutodial(HKEY_CURRENT_USER, eType, szConnectoidName, bSetICWCompleted);
    if (lRet != ERROR_SUCCESS)
    {
        bSucceed = FALSE;
    }

    pSetupEnablePrivilege(SE_BACKUP_NAME, TRUE);
    pSetupEnablePrivilege(SE_RESTORE_NAME, TRUE);

    // Default User, which will apply to any new user profiles created
    // afterward.
    dwSize = MAX_CHARS_IN_BUFFER(szProfileDir);
    if (GetDefaultUserProfileDirectory(szProfileDir, &dwSize))
    {
        lRet = SetUserAutodial(szProfileDir, eType, szConnectoidName, bSetICWCompleted);
        if (lRet != ERROR_SUCCESS)
        {
            bSucceed = FALSE;
        }
    }

    // Built-in Administrators, e.g. Administrator.
    if (EnumBuildInAdministrators(&szAdmins))
    {
        LPWSTR szAdmin = szAdmins;
        while (*szAdmin)
        {
            // MAX_CHARS_IN_BUFFER excludes the terminating NULL
            dwSize = MAX_CHARS_IN_BUFFER(szProfileDir) + 1;
            if (MyGetUserProfileDirectory(szAdmin, szProfileDir, &dwSize))
            {
                lRet = SetUserAutodial(szProfileDir, eType, szConnectoidName, bSetICWCompleted);
                if (lRet != ERROR_SUCCESS)
                {
                    bSucceed = FALSE;
                }
            }
            szAdmin += (lstrlen(szAdmin) + 1);
        }
        GlobalFree(szAdmins);
    }
    
    return bSucceed;

}



BOOL
SetDefaultConnectoid(
    IN AUTODIAL_TYPE eType,            // type of autodial for the connectoid
    IN LPCWSTR       szConnectoidName  // null terminated autodial connectoid name
    )

/*++

Routine Description:

    Set the default autodial connectoid for SYSTEM, Default User and 
    build-in administrators. Assume that this function is run in System
    context, i.e. it is SYSTEM who runs OOBE.

Return Value:

    TRUE  - Success to set all user accounts

    FALSE - Failure to set any one of the user accounts
    
--*/

{
    BOOL             bSucceed = TRUE;
    LONG             lRet = ERROR_SUCCESS;
    RASAUTODIALENTRY adEntry;


    //
    // IE on WinXP use Ras autodial address, instead of its own registry
    // key for autodial connection name, but it keeps using its own registry
    // key for autodial mode.
    //
    ZeroMemory(&adEntry, sizeof(RASAUTODIALENTRY));
    adEntry.dwSize = sizeof(RASAUTODIALENTRY);
    lstrcpyn(adEntry.szEntry, szConnectoidName, 
             sizeof(adEntry.szEntry)/sizeof(WCHAR)
             );
    lRet = RasSetAutodialAddress(NULL,
                                 NULL,
                                 &adEntry,
                                 sizeof(RASAUTODIALENTRY),
                                 1
                                 );
    TRACE2(L"Setting default autodial connectoid to %s %d\n",
           szConnectoidName, lRet);

    if (lRet != ERROR_SUCCESS)
    {
        bSucceed = FALSE;
        return bSucceed;
    }

    bSucceed = SetMultiUserAutodial(eType, szConnectoidName, FALSE);
    
    return bSucceed;
}