windows-server-2003/net/rras/cm/cmstp/install.cpp

//+----------------------------------------------------------------------------
//
// File:     install.cpp
//
// Module:   CMSTP.EXE
//
// Synopsis: This source file contains the code for installing CM profiles.
//
// Copyright (c) 1997-1999 Microsoft Corporation
//
// Author:   quintinb   Created     07/14/98
//
//+----------------------------------------------------------------------------

#include "cmmaster.h"
#include "installerfuncs.h"
#include "winuserp.h"
#include <aclapi.h>
#include <advpub.h>
#include "tunl_str.h"
#include "cmsecure.h"
#include "gppswithalloc.cpp"

//
//  This global var, contains the path to the source files to install such as the
//  cmp, cms, and inf.  (From the inf path passed in to InstallInf).
//
TCHAR g_szProfileSourceDir[MAX_PATH+1];

//  This is really ugly, we need to consolidate our platform detection code between CM and
//  the setup components.
BOOL IsNT()
{
    CPlatform plat;
    return plat.IsNT();
}

#define OS_NT (IsNT())
BOOL IsAtLeastNT5()
{
    CPlatform plat;
    return plat.IsAtLeastNT5();
}

#define OS_NT5 (IsAtLeastNT5())
#include "MemberOfGroup.cpp"

#include "cmexitwin.cpp"

//+----------------------------------------------------------------------------
//
// Function:  SetPermissionsOnWin2kExceptionUninstallRegKeys
//
// Synopsis:  This function sets the permissions on the uninstall registry keys
//            created by the Windows 2000 exception installer.  The function
//            gives Everyone read access, Local Administrators full control, and
//            the CREATOR OWNER full control.
//
// Arguments: None
//
// Returns:   HRESULT -- standard COM style error codes
//
// History:   quintinb Created     10/04/01
//
//+----------------------------------------------------------------------------
HRESULT SetPermissionsOnWin2kExceptionUninstallRegKeys()
{
    DWORD dwRes;
    HRESULT hr = S_OK;
    LPWSTR pszCmExceptionUninstallKey = L"MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\CMEXCEPT";

    PACL pNewAccessList = NULL;
    PSID pEveryoneSid = NULL;
    PSID pAdministratorsSid = NULL;
    PSID pCreatorSid = NULL;
    PSID pCurrentUserSid = NULL;
    SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
    SID_IDENTIFIER_AUTHORITY WorldSidAuthority = SECURITY_WORLD_SID_AUTHORITY;
    SID_IDENTIFIER_AUTHORITY CreatorSidAuthority = SECURITY_CREATOR_SID_AUTHORITY;
    EXPLICIT_ACCESS_W AccessEntryArray[3] = {0};
    PSECURITY_DESCRIPTOR pSecurityDescriptor = NULL;
    HANDLE pTokenHandle = NULL;
    PTOKEN_USER ptu = NULL;
    DWORD dwNeeded = 0;
    
    BOOL bRet;

    //
    //  Link to Advapi32.dll so that we can load the security functions we need from it
    //

    typedef BOOL (WINAPI *pfnAllocateAndInitializeSidSpec)(PSID_IDENTIFIER_AUTHORITY, BYTE, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, PSID);
    typedef DWORD (WINAPI* pfnSetEntriesInAclWSpec)(ULONG, PEXPLICIT_ACCESS_W, PACL, PACL *);
    typedef DWORD (WINAPI* pfnSetNamedSecurityInfoWSpec)(LPWSTR, SE_OBJECT_TYPE, SECURITY_INFORMATION, PSID, PSID, PACL, PACL);
    typedef PVOID (WINAPI* pfnFreeSidSpec)(PSID);
    typedef VOID (WINAPI* pfnBuildTrusteeWithSidWSpec)(PTRUSTEE_W, PSID);
    typedef BOOL (WINAPI* pfnOpenProcessTokenSpec)(HANDLE, DWORD, PHANDLE);
    typedef BOOL (WINAPI* pfnGetTokenInformationSpec)(HANDLE, TOKEN_INFORMATION_CLASS, LPVOID, DWORD, PDWORD);

    pfnAllocateAndInitializeSidSpec pfnAllocateAndInitializeSid = NULL;
    pfnSetEntriesInAclWSpec pfnSetEntriesInAclW = NULL;
    pfnSetNamedSecurityInfoWSpec pfnSetNamedSecurityInfoW = NULL;
    pfnFreeSidSpec pfnFreeSid = NULL;
    pfnBuildTrusteeWithSidWSpec pfnBuildTrusteeWithSidW = NULL;
    pfnOpenProcessTokenSpec pfnOpenProcessToken = NULL;
    pfnGetTokenInformationSpec pfnGetTokenInformation = NULL;

    HMODULE hAdvapi32 = LoadLibrary(TEXT("advapi32.dll"));

    if (hAdvapi32)
    {
        pfnAllocateAndInitializeSid = (pfnAllocateAndInitializeSidSpec)GetProcAddress(hAdvapi32, "AllocateAndInitializeSid");
        pfnSetEntriesInAclW = (pfnSetEntriesInAclWSpec)GetProcAddress(hAdvapi32, "SetEntriesInAclW");
        pfnSetNamedSecurityInfoW = (pfnSetNamedSecurityInfoWSpec)GetProcAddress(hAdvapi32, "SetNamedSecurityInfoW");
        pfnFreeSid = (pfnFreeSidSpec)GetProcAddress(hAdvapi32, "FreeSid");
        pfnBuildTrusteeWithSidW = (pfnBuildTrusteeWithSidWSpec)GetProcAddress(hAdvapi32, "BuildTrusteeWithSidW");
        pfnOpenProcessToken = (pfnOpenProcessTokenSpec)GetProcAddress(hAdvapi32, "OpenProcessToken");
        pfnGetTokenInformation = (pfnGetTokenInformationSpec)GetProcAddress(hAdvapi32, "GetTokenInformation");

        if (0 == (pfnOpenProcessToken && pfnGetTokenInformation && 
                  pfnAllocateAndInitializeSid && pfnSetEntriesInAclW && 
                  pfnSetNamedSecurityInfoW && pfnFreeSid && 
                  pfnBuildTrusteeWithSidW))
        {
            hr = HRESULT_FROM_WIN32(ERROR_PROC_NOT_FOUND);
            goto exit;
        }
    }
    else
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto exit;    
    }

    //
    //  Get the SID for Everyone
    //
    bRet = pfnAllocateAndInitializeSid (&WorldSidAuthority, 1, SECURITY_WORLD_RID, 
                                        0, 0, 0, 0, 0, 0, 0, &pEveryoneSid);

    if (!bRet || (NULL == pEveryoneSid))
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto exit;
    }

    //
    //  Get the SID for the Local Administrators group
    //
    bRet = pfnAllocateAndInitializeSid (&NtAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS,
                                        0, 0, 0, 0, 0, 0, &pAdministratorsSid);
    if (!bRet || (NULL == pAdministratorsSid))
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto exit;
    }

    //
    //  Get the SID the for CREATOR OWNER
    //
    bRet = pfnAllocateAndInitializeSid (&CreatorSidAuthority, 1, SECURITY_CREATOR_OWNER_RID,
                                        0, 0, 0, 0, 0, 0, 0, &pCreatorSid);

    if (!bRet || (NULL == pCreatorSid))
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto exit;
    }


    bRet = pfnOpenProcessToken(GetCurrentProcess(), TOKEN_READ  , &pTokenHandle);
    if (bRet && pTokenHandle)
    {
        bRet = pfnGetTokenInformation(pTokenHandle, TokenUser, NULL, 0, &dwNeeded);
        if (dwNeeded)
        {
            ptu = (PTOKEN_USER)CmMalloc(dwNeeded);
            if (ptu)
            {
                DWORD dwNeededAgain = 0;
                bRet = pfnGetTokenInformation(pTokenHandle, TokenUser, ptu, dwNeeded, &dwNeededAgain);
                if (bRet)
                {
                    pCurrentUserSid = ptu->User.Sid;
                }
            }
        }
        
        CloseHandle(pTokenHandle);
        pTokenHandle = NULL;
    }

    if (!bRet || (NULL == pCurrentUserSid))
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto exit;
    }


    //
    // Give Everyone generic read access
    //
    pfnBuildTrusteeWithSidW(&(AccessEntryArray[0].Trustee), pEveryoneSid);
    AccessEntryArray[0].grfInheritance = NO_INHERITANCE;
    AccessEntryArray[0].grfAccessMode = GRANT_ACCESS;
    AccessEntryArray[0].grfAccessPermissions = GENERIC_READ;

    //
    // Give the local Administrators group full control
    //
    pfnBuildTrusteeWithSidW(&(AccessEntryArray[1].Trustee), pAdministratorsSid);
    AccessEntryArray[1].grfInheritance = NO_INHERITANCE;
    AccessEntryArray[1].grfAccessMode = GRANT_ACCESS;
    AccessEntryArray[1].grfAccessPermissions = (STANDARD_RIGHTS_ALL | SPECIFIC_RIGHTS_ALL);

    //
    // Give current user full control
    //
    pfnBuildTrusteeWithSidW(&(AccessEntryArray[2].Trustee), pCurrentUserSid);
    AccessEntryArray[2].grfInheritance = NO_INHERITANCE; 
    AccessEntryArray[2].grfAccessMode = GRANT_ACCESS;
    AccessEntryArray[2].grfAccessPermissions = (STANDARD_RIGHTS_ALL | SPECIFIC_RIGHTS_ALL); 


    //
    // Build an access list from the access list entry.
    //

    dwRes = pfnSetEntriesInAclW(3, &(AccessEntryArray[0]), NULL, &pNewAccessList);
    
    if (ERROR_SUCCESS == dwRes)
    {
        //
        // Set the access-control information in the object's DACL.  Note that setting PROTECTED_DACL_SECURITY_INFORMATION
        // turns off the inherited permissions.
        //
        dwRes = pfnSetNamedSecurityInfoW(pszCmExceptionUninstallKey,                                            // name of the object
                                         SE_REGISTRY_KEY,                                                       // type of object
                                         (DACL_SECURITY_INFORMATION | PROTECTED_DACL_SECURITY_INFORMATION),     // type of information to set
                                         NULL,                                                                  // pointer to the new owner SID
                                         NULL,                                                                  // pointer to the new primary group SID
                                         pNewAccessList,                                                        // pointer to new DACL
                                         NULL);                                                                 // pointer to new SACL

    }

    hr = HRESULT_FROM_WIN32(dwRes);

exit:
    if (ptu)
    {
        CmFree(ptu);
        ptu = NULL;
    }

    if (pEveryoneSid && pfnFreeSid)
    {
        pfnFreeSid(pEveryoneSid);
    }

    if (pAdministratorsSid && pfnFreeSid)
    {
        pfnFreeSid(pAdministratorsSid);
    }

    if (pCreatorSid && pfnFreeSid)
    {
        pfnFreeSid(pCreatorSid);
    }

    if (pNewAccessList)
    {
        LocalFree(pNewAccessList);
    }

    if (pSecurityDescriptor)
    {
        LocalFree(pSecurityDescriptor);
    }

    if (hAdvapi32)
    {
        FreeLibrary(hAdvapi32);
    }

    return hr;
}

//+----------------------------------------------------------------------------
//
// Function:  CheckIeDllRequirements
//
// Synopsis:  This function checks to see if the browser agnostic dlls are of
//            a sufficient version for CM to work, or if we should copy the
//            dlls we carry in the package with us.
//
// Arguments: CPlatform* pPlat - a CPlatform object
//
// Returns:   BOOL - returns TRUE if all browser files meet the requirements, FALSE
//                   if any one of the files fails to meet what CM needs.
//
// History:   quintinb Created Header    5/24/99
//
//+----------------------------------------------------------------------------
BOOL CheckIeDllRequirements(CPlatform* pPlat)
{
    TCHAR szSysDir[MAX_PATH+1];
    TCHAR szDllToCheck[MAX_PATH+1];
    if(GetSystemDirectory(szSysDir, MAX_PATH))
    {
        if (pPlat->IsWin9x())
        {
            //
            //  Need Advapi32.dll to be version 4.70.0.1215 or greater.
            //
            const DWORD c_dwRequiredAdvapi32Version = (4 << c_iShiftAmount) + 70;
            const DWORD c_dwRequiredAdvapi32BuildNumber = 1215;

            MYVERIFY(CELEMS(szDllToCheck) > (UINT)wsprintf(szDllToCheck, TEXT("%s%s"), 
                szSysDir, TEXT("\\advapi32.dll")));
        
            CVersion AdvApi32Version(szDllToCheck);

            if ((c_dwRequiredAdvapi32Version > AdvApi32Version.GetVersionNumber()) ||
                ((c_dwRequiredAdvapi32Version == AdvApi32Version.GetVersionNumber()) && 
                 (c_dwRequiredAdvapi32BuildNumber > AdvApi32Version.GetBuildAndQfeNumber())))
            {
                return FALSE;
            }

            //
            //  Need comctl32.dll to be version 4.70.0.1146 or greater.
            //
            const DWORD c_dwRequiredComctl32Version = (4 << c_iShiftAmount) + 70;
            const DWORD c_dwRequiredComctl32BuildNumber = 1146;

            MYVERIFY(CELEMS(szDllToCheck) > (UINT)wsprintf(szDllToCheck, TEXT("%s%s"), 
                szSysDir, TEXT("\\comctl32.dll")));
        
            CVersion Comctl32Version(szDllToCheck);

            if ((c_dwRequiredComctl32Version > Comctl32Version.GetVersionNumber()) ||
                ((c_dwRequiredComctl32Version == Comctl32Version.GetVersionNumber()) && 
                 (c_dwRequiredComctl32BuildNumber > Comctl32Version.GetBuildAndQfeNumber())))
            {
                return FALSE;
            }

            //
            //  Need rnaph.dll to be version 4.40.311.0 or greater.
            //
            const DWORD c_dwRequiredRnaphVersion = (4 << c_iShiftAmount) + 40;
            const DWORD c_dwRequiredRnaphBuildNumber = (311 << c_iShiftAmount);

            MYVERIFY(CELEMS(szDllToCheck) > (UINT)wsprintf(szDllToCheck, TEXT("%s%s"), 
                szSysDir, TEXT("\\rnaph.dll")));
        
            CVersion RnaphVersion(szDllToCheck);
            if ((c_dwRequiredRnaphVersion > RnaphVersion.GetVersionNumber()) ||
                ((c_dwRequiredRnaphVersion == RnaphVersion.GetVersionNumber()) && 
                 (c_dwRequiredRnaphBuildNumber > RnaphVersion.GetBuildAndQfeNumber())))
            {
                return FALSE;
            }
        }

        //
        //  Need wininet.dll to be version 4.70.0.1301 or greater.
        //
        const DWORD c_dwRequiredWininetVersion = (4 << c_iShiftAmount) + 70;
        const DWORD c_dwRequiredWininetBuildNumber = 1301;

        MYVERIFY(CELEMS(szDllToCheck) > (UINT)wsprintf(szDllToCheck, TEXT("%s%s"), 
            szSysDir, TEXT("\\wininet.dll")));
    
        CVersion WininetVersion(szDllToCheck);

        if ((c_dwRequiredWininetVersion > WininetVersion.GetVersionNumber()) ||
            ((c_dwRequiredWininetVersion == WininetVersion.GetVersionNumber()) && 
             (c_dwRequiredWininetBuildNumber > WininetVersion.GetBuildAndQfeNumber())))
        {
            return FALSE;
        }
    }
    else
    {
        return FALSE;
    }

    return TRUE;
}

//+----------------------------------------------------------------------------
//
// Function:  WriteSingleUserProfileMappings
//
// Synopsis:  This function write the single user mappings key.
//
// Arguments: HINSTANCE hInstance - an Instance handle to load string resources with
//            LPCTSTR pszShortServiceName - short service name of the profile
//            LPCTSTR pszServiceName - Long service name of the profile
//
// Returns:   BOOL - TRUE if successful
//
// History:   quintinb Created     5/23/99
//
//+----------------------------------------------------------------------------
BOOL WriteSingleUserProfileMappings(LPCTSTR pszInstallDir, LPCTSTR pszShortServiceName, LPCTSTR pszServiceName)
{
    BOOL bReturn = FALSE;
    TCHAR szCmpFile [MAX_PATH+1];
    TCHAR szTemp [MAX_PATH+1];
    TCHAR szUserProfilePath [MAX_PATH+1];
    HKEY hKey = NULL;

    //
    //  Construct the Cmp Path
    //
    MYVERIFY(CELEMS(szCmpFile) > (UINT)wsprintf(szCmpFile, TEXT("%s\\%s.cmp"), 
        pszInstallDir, pszShortServiceName));

    //
    //  Figure out the User Profile directory
    //

    DWORD dwChars = ExpandEnvironmentStrings(TEXT("%AppData%"), szUserProfilePath, MAX_PATH);

    if (dwChars && (MAX_PATH >= dwChars))
    {
        //
        //  We want to do a lstrcmpi but with only so many chars.  Unfortunately this doesn't
        //  exist in Win32 so we will use lstrcpyn into a temp buffer and then use lstrcmpi.
        //
        lstrcpyn(szTemp, szCmpFile, lstrlen(szUserProfilePath) + 1);

        if (0 == lstrcmpi(szTemp, szUserProfilePath))
        {
            lstrcpy(szTemp, szCmpFile + lstrlen(szUserProfilePath));
            lstrcpy(szCmpFile, TEXT("%AppData%"));
            lstrcat(szCmpFile, szTemp);
        }
        else
        {
            CMASSERTMSG(FALSE, TEXT("Unable to build the Single User Mappings key value, exiting."));
            goto exit;
        }

        //
        //  Okay, now we need to write out the single user mappings key
        //
        DWORD dwDisposition;
        LONG lResult = RegCreateKeyEx(HKEY_CURRENT_USER, c_pszRegCmMappings, 0, NULL, 
                                      REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, NULL, 
                                      &hKey, &dwDisposition);

        if (ERROR_SUCCESS == lResult)
        {
            DWORD dwType = REG_SZ;
            DWORD dwSize = lstrlen(szCmpFile) + 1;

            if (ERROR_SUCCESS != RegSetValueEx(hKey, pszServiceName, NULL, dwType, 
                                               (CONST BYTE *)szCmpFile, dwSize))
            {
                CMASSERTMSG(FALSE, TEXT("Unable to write the Single User Mappings key value, exiting."));
                goto exit;
            }
            else
            {
                bReturn = TRUE;
            }
        }
    }
    else
    {
        CMASSERTMSG(FALSE, TEXT("Unable to expand the AppData String, exiting."));
        goto exit;
    }

exit:

    if (hKey)
    {
        MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
    }

    return bReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessPreferencesUI
//
// Synopsis:  This function processes messages for either of the two dialogs used
//            to ask the user if they want a desktop shortcut.  One dialog is for 
//            non-admins and only contains the shortcut question, the other dialog
//            is for local admins and also contains whether the admin wants the 
//            profile installed for all users or just for single users.
//
//
// History:   quintinb Created    2/19/98
//            quintinb Renamed from ProcessAdminUI to ProcessPreferencesUI and 
//                     added new functionality  6/9/8
//            quintinb removed mention of Start Menu Shortcut  2/17/99
//
//+----------------------------------------------------------------------------
BOOL APIENTRY ProcessPreferencesUI(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    int iUiChoices;
    HKEY hKey;
    DWORD dwSize;
    DWORD dwTemp;
    DWORD dwType;
    InitDialogStruct* pDialogArgs = NULL;

    switch (message)
    {

        case WM_INITDIALOG:
            //
            //  Look up the preferences for Desktop Shortcuts/Start Menu Links
            //  in the registry and set them accordingly.
            // 
            pDialogArgs = (InitDialogStruct*)lParam;

            if (pDialogArgs->bNoDesktopIcon)
            {
                MYVERIFY(0 != CheckDlgButton(hDlg, IDC_DESKTOP, FALSE));
            }
            else
            {
                if (ERROR_SUCCESS == RegCreateKeyEx(HKEY_CURRENT_USER, c_pszRegStickyUiDefault, 
                    0, NULL, REG_OPTION_NON_VOLATILE, KEY_READ, NULL, &hKey, &dwTemp))
                {
                    //
                    //  The default of whether a desktop shortcut should be created is stored in the
                    //  registry.  Get this value to populate the UI.  (default is off)
                    //
                    dwType = REG_DWORD;
                    dwSize = sizeof(DWORD);
                    dwTemp = 0;
                    RegQueryValueEx(hKey, c_pszRegDesktopShortCut, NULL, &dwType, (LPBYTE)&dwTemp, 
                        &dwSize);  //lint !e534
                    MYVERIFY(0 != CheckDlgButton(hDlg, IDC_DESKTOP, dwTemp));                    
                
                    MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
                }
            }

            //
            //  Set the Window Text to the Profile Name
            //
            MYVERIFY(FALSE != SetWindowText(hDlg, pDialogArgs->pszTitle));

            if (!(pDialogArgs->bSingleUser))
            {
                CheckDlgButton(hDlg, IDC_ALLUSERS, TRUE); //lint !e534 this will fail if using the nochoice UI
                
                //
                //  Set focus to the All user radio button
                //
                HWND hControl = GetDlgItem(hDlg, IDC_ALLUSERS);
                
                if (hControl)
                {
                    SetFocus(hControl);
                }
            }
            else
            {
                CheckDlgButton(hDlg, IDC_YOURSELF, TRUE); //lint !e534 this will fail if using the nochoice UI

                //
                //  Set focus to the Single user radio button
                //
                HWND hControl = GetDlgItem(hDlg, IDC_YOURSELF);
                
                if (hControl)
                {
                    SetFocus(hControl);
                }
            }

            //
            //  We return FALSE here but the focus is correctly set.
            //
            break;

        case WM_COMMAND:
            switch (LOWORD(wParam)) 
            {
                case IDOK:
                    //
                    //  Build the return value
                    //
                    if (IsDlgButtonChecked(hDlg, IDC_ALLUSERS) == BST_CHECKED)
                    {
                        iUiChoices = ALLUSERS;
                    }
                    else
                    {
                        iUiChoices = 0;
                    }
                    
                    if (IsDlgButtonChecked(hDlg, IDC_DESKTOP))
                    {
                        iUiChoices |= CREATEDESKTOPICON;
                    }

                    //
                    //  Make sure to save the users preferences for Desktop Icons
                    //  and Start Menu Links.
                    //

                    if (ERROR_SUCCESS == RegCreateKeyEx(HKEY_CURRENT_USER, c_pszRegStickyUiDefault, 
                        0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, &dwTemp))
                    {
                        //
                        //  Store the current state of whether we should create a desktop shortcut
                        //
                        dwTemp = IsDlgButtonChecked(hDlg, IDC_DESKTOP);
                        MYVERIFY(ERROR_SUCCESS == RegSetValueEx(hKey, c_pszRegDesktopShortCut, 0, 
                            REG_DWORD, (LPBYTE)&dwTemp, sizeof(DWORD)));
            
                        MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
                    }

                    MYVERIFY(FALSE != EndDialog(hDlg, iUiChoices));

                    return (TRUE);

                case IDCANCEL:
                    MYVERIFY(FALSE != EndDialog(hDlg, -1));
                    return TRUE;

                default:
                    break;
            }
            break;

        case WM_CLOSE:
            MYVERIFY(FALSE != EndDialog(hDlg, -1));
            return TRUE;
            
        default:
            return FALSE;
    }
    return FALSE;   
}



//+----------------------------------------------------------------------------
//
// Function:  InstallCm
//
// Synopsis:  This function calls LaunchInfSection on the appropriate
//            install section to install Connection Manager.  It also installs
//            the browser files as appropriate.
//
// Arguments: HINSTANCE hInstance - Instance handle for strings
//            LPCTSTR szInfPath - Full path to the inf
//
// Returns:   HRESULT - standard com codes, could return ERROR_SUCCESS_REBOOT_REQUIRED
//                      so the caller must check for this case and ask for a reboot
//                      if required.
//
// History:   quintinb Created    8/12/98
//            quintinb Moved Browser file installation code here, since it is
//                     part of the installation of CM.      10-2-98
//
//+----------------------------------------------------------------------------
HRESULT InstallCm(HINSTANCE hInstance, LPCTSTR szInfPath)
{
    HRESULT hr = E_UNEXPECTED;

    MYDBGASSERT((szInfPath) && (TEXT('\0') != szInfPath[0]));

    //
    //  Load the Cmstp Title just in case we need to show error messages.
    //

    TCHAR szTitle[MAX_PATH+1] = {TEXT("")};
    MYVERIFY(0 != LoadString(hInstance, IDS_CMSTP_TITLE, szTitle, MAX_PATH));
    MYDBGASSERT(TEXT('\0') != szTitle[0]);

    //
    //  Make sure that the Inf File exists
    //
    if (!FileExists(szInfPath))
    {
        CMTRACE1(TEXT("InstallCm -- Can't find %s, the inputted Inf file."), szInfPath);
        return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
    }

    CPlatform plat;
    TCHAR szInstallSection[MAX_PATH+1] = {TEXT("")};

    if (plat.IsNT())
    {
        MYVERIFY(CELEMS(szInstallSection) > (UINT)wsprintf(szInstallSection, 
            TEXT("DefaultInstall_NT")));
    }
    else
    {
        MYVERIFY(CELEMS(szInstallSection) > (UINT)wsprintf(szInstallSection, 
            TEXT("DefaultInstall")));    
    }

    hr = LaunchInfSection(szInfPath, szInstallSection, szTitle, TRUE);  // bQuiet = TRUE

    return hr;
}

//+----------------------------------------------------------------------------
//
// Function:  InstallWhistlerCmOnWin2k
//
// Synopsis:  This function uses the CM exception inf (cmexcept.inf) to install
//            the Whistler CM binaries on Win2k.
//
// Arguments: LPCSTR pszSourceDir - source directory for cmexcept.inf and CM
//                                  binaries, including the trailing slash.
//
// Returns:   HRESULT - standard com codes, could return ERROR_SUCCESS_REBOOT_REQUIRED
//                      which means the caller needs to request a reboot.
//
// History:   quintinb Created    02/09/2001
//
//+----------------------------------------------------------------------------
HRESULT InstallWhistlerCmOnWin2k(LPCSTR pszSourceDir)
{
    CPlatform cmplat;
    HRESULT hr = E_UNEXPECTED;
    LPSTR pszInfFile = NULL;
    LPCSTR c_pszExceptionInf = "cmexcept.inf";
    LPCSTR c_pszInstallSection = "DefaultInstall";
    LPCSTR c_pszUnInstallSection = "DefaultUninstall_NoPrompt";

    if (cmplat.IsNT5())
    {
        if (pszSourceDir && pszSourceDir[0])
        {
            DWORD dwSize = sizeof(CHAR)*(lstrlenA(pszSourceDir) + lstrlenA(c_pszExceptionInf) + 1);

            pszInfFile = (LPSTR)CmMalloc(dwSize);

            if (pszInfFile)
            {
                wsprintf(pszInfFile, "%s%s", pszSourceDir, c_pszExceptionInf);

                if (FileExists(pszInfFile))
                {
                    hr = CallLaunchInfSectionEx(pszInfFile, c_pszInstallSection, (ALINF_BKINSTALL | ALINF_QUIET));

                    if (FAILED(hr))
                    {
                        CMTRACE1(TEXT("InstallWhistlerCmOnWin2k -- CallLaunchInfSectionEx failed with hr=0x%x"), hr);

                        HRESULT hrTemp = CallLaunchInfSectionEx(pszInfFile, c_pszUnInstallSection, (ALINF_ROLLBKDOALL | ALINF_QUIET));

                        CMTRACE1(TEXT("InstallWhistlerCmOnWin2k -- Rolling back.  CallLaunchInfSectionEx returned hr=0x%x"), hrTemp);
                    }
                }
                else
                {
                    hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
                }
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }
        }
        else
        {
            hr = E_INVALIDARG;
        }
    }
    else
    {
        hr = HRESULT_FROM_WIN32(ERROR_INSTALL_PLATFORM_UNSUPPORTED); // kind of a double use of this error
    }

    CmFree(pszInfFile);

    return hr;
}

//+----------------------------------------------------------------------------
//
// Function:  UpdateCmpDataFromExistingProfile
//
// Synopsis:  This function enumerates all of the keys in all of the sections
//            of an existing cmp file and copies them to the cmp file to be
//            installed.  This function copies all of the data in the existing
//            cmp unless that data already exists in the cmp to install.  This
//            allows Admins to preseed cmp files and have their settings override
//            what the user currently has in their cmp.
//
// Arguments: LPCTSTR pszShortServiceName - Short Service name of the profile
//            LPCTSTR szCurrentCmp - Full path to the currently installed cmp
//            LPCTSTR szCmpToBeInstalled - Full path to the cmp to install 
//
// Returns:   BOOL - TRUE if the cmp is copied and updated properly
//
// History:   quintinb Created                              03/16/99
//            quintinb rewrote for Whistler bug 18021       03/05/00
//
//+----------------------------------------------------------------------------
BOOL UpdateCmpDataFromExistingProfile(LPCTSTR pszShortServiceName, LPCTSTR pszCurrentCmp, LPCTSTR pszCmpToBeInstalled)
{

    if((NULL == pszShortServiceName) && (TEXT('\0') == pszShortServiceName[0]) &&
       (NULL == pszCurrentCmp) && (TEXT('\0') == pszCurrentCmp[0]) &&
       (NULL == pszCmpToBeInstalled) && (TEXT('\0') == pszCmpToBeInstalled[0]))
    {
        CMASSERTMSG(FALSE, TEXT("UpdateCmpDataFromExistingProfile -- Invalid parameter."));
        return FALSE;
    }

    BOOL bReturn = FALSE;
    BOOL bExitLoop = FALSE;
    DWORD dwSize = MAX_PATH;
    DWORD dwReturnedSize;
    LPTSTR pszAllSections = NULL;
    LPTSTR pszAllKeysInCurrentSection = NULL;
    LPTSTR pszCurrentSection = NULL;
    LPTSTR pszCurrentKey = NULL;
    TCHAR szData[MAX_PATH+1];

    //
    //  First lets get all of the sections from the existing cmp
    //
    pszAllSections = (TCHAR*)CmMalloc(dwSize*sizeof(TCHAR));

    do
    {
        MYDBGASSERT(pszAllSections);

        if (pszAllSections)
        {
            dwReturnedSize = GetPrivateProfileString(NULL, NULL, TEXT(""), pszAllSections, dwSize, pszCurrentCmp);

            if (dwReturnedSize == (dwSize - 2))
            {
                //
                //  The buffer is too small, lets allocate a bigger one
                //
                dwSize = 2*dwSize;
                if (dwSize > 1024*1024)
                {
                    CMASSERTMSG(FALSE, TEXT("UpdateCmpDataFromExistingProfile -- Allocation above 1MB, bailing out."));
                    goto exit;
                }

                pszAllSections = (TCHAR*)CmRealloc(pszAllSections, dwSize*sizeof(TCHAR));                
            }
            else if (0 == dwReturnedSize)
            {
                //
                //  We got an error, lets exit.
                //
                CMASSERTMSG(FALSE, TEXT("UpdateCmpDataFromExistingProfile -- GetPrivateProfileString returned failure."));
                goto exit;
            }
            else
            {
                bExitLoop = TRUE;
            }
        }
        else
        {
            goto exit; 
        }

    } while (!bExitLoop);

    //
    //  Okay, now we have all of the sections in the existing cmp file.  Lets enumerate
    //  all of the keys in each section and see which ones need to be copied over.
    //
    
    pszCurrentSection = pszAllSections;
    dwSize = MAX_PATH;

    pszAllKeysInCurrentSection = (TCHAR*)CmMalloc(dwSize*sizeof(TCHAR));

    while (TEXT('\0') != pszCurrentSection[0])
    {
        //
        //  Get all of the keys in the current section
        //
        bExitLoop = FALSE;

        do
        {
            if (pszAllKeysInCurrentSection)
            {
                dwReturnedSize = GetPrivateProfileString(pszCurrentSection, NULL, TEXT(""), pszAllKeysInCurrentSection, 
                                                         dwSize, pszCurrentCmp);

                if (dwReturnedSize == (dwSize - 2))
                {
                    //
                    //  The buffer is too small, lets allocate a bigger one
                    //
                    dwSize = 2*dwSize;
                    if (dwSize > 1024*1024)
                    {
                        CMASSERTMSG(FALSE, TEXT("UpdateCmpDataFromExistingProfile -- Allocation above 1MB, bailing out."));
                        goto exit;
                    }

                    pszAllKeysInCurrentSection = (TCHAR*)CmRealloc(pszAllKeysInCurrentSection, dwSize*sizeof(TCHAR));

                }
                else if (0 == dwReturnedSize)
                {
                    //
                    //  We got an error, lets exit.
                    //
                    CMASSERTMSG(FALSE, TEXT("UpdateCmpDataFromExistingProfile -- GetPrivateProfileString returned failure."));
                    goto exit;
                }
                else
                {
                    bExitLoop = TRUE;
                }
            }
            else
            {
               goto exit; 
            }

        } while (!bExitLoop);

        //
        //  Now process all of the keys in the current section
        //
        pszCurrentKey = pszAllKeysInCurrentSection;

        while (TEXT('\0') != pszCurrentKey[0])
        {
            //
            //  Try to get the value of the key from the new cmp.  If it
            //  doesn't exist, then copy of the old cmp value.  If it
            //  does exist keep the new cmp value and ignore the old one.
            //
            dwReturnedSize = GetPrivateProfileString(pszCurrentSection, pszCurrentKey, TEXT(""), 
                                                     szData, MAX_PATH, pszCmpToBeInstalled);
            if (0 == dwReturnedSize)
            {
                //
                //  Then we have a value in the old profile that we don't have in the new profile.
                //
                dwReturnedSize = GetPrivateProfileString(pszCurrentSection, pszCurrentKey, TEXT(""), 
                                                         szData, MAX_PATH, pszCurrentCmp);

                if (dwReturnedSize)
                {
                    MYVERIFY(0 != WritePrivateProfileString(pszCurrentSection, pszCurrentKey, szData, pszCmpToBeInstalled));
                }
            }

            //
            //  Advance to the next key in pszAllKeysInCurrentSection
            //
            pszCurrentKey = pszCurrentKey + lstrlen(pszCurrentKey) + 1;
        }


        //
        //  Now advance to the next string in pszAllSections 
        //
        pszCurrentSection = pszCurrentSection + lstrlen(pszCurrentSection) + 1;
    }


    //
    //  Flush the updated cmp
    //
    WritePrivateProfileString(NULL, NULL, NULL, pszCmpToBeInstalled); //lint !e534 this call will return 0

    bReturn = TRUE;

exit:

    CmFree(pszAllSections);
    CmFree(pszAllKeysInCurrentSection);

    return bReturn;

}

//+----------------------------------------------------------------------------
//
// Function:  MigrateCmpData
//
// Synopsis:  This function checks to see if a profile of the same long service
//            and short service name is already installed.  If it is, it migrates
//            the existing cmp data to the cmp file that is to be installed.
//            If the same piece of data exists in both profiles the data in the
//            cmp to be installed wins (allows admins to pre-seed data in the
//            cmp and override what users have picked).
//
// Arguments: HINSTANCE hInstance - Instance handle for string resources
//            BOOL bInstallForAllUsers - whether this is an all users profile or not
//            LPCTSTR pszServiceName - ServiceName of the current profile
//            LPCTSTR pszShortServiceName - Short Service name of the current profile
//            BOOL bSilent - whether messages to the user can be displayed or not
//
// Returns:   int - returns -1 on error, otherwise TRUE or FALSE depending on if a same name
//                  profile was discovered
//
// History:   quintinb  Created     9/8/98
//
//+----------------------------------------------------------------------------
BOOL MigrateCmpData(HINSTANCE hInstance, BOOL bInstallForAllUsers, LPCTSTR pszServiceName, 
                    LPCTSTR pszShortServiceName, BOOL bSilent)
{
    //
    //  Check the parameters
    //
    if ((NULL == pszShortServiceName) || (TEXT('\0') == pszShortServiceName[0]) || 
        (NULL == pszServiceName) || (TEXT('\0') == pszServiceName[0]))
    {
        CMASSERTMSG(FALSE, TEXT("MigrateCmpData -- Invalid Parameter"));
        return FALSE;
    }

    BOOL bReturn = TRUE;
    DWORD dwSize = MAX_PATH;
    HKEY hKey = NULL;
    HKEY hBaseKey = bInstallForAllUsers ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
    TCHAR szExistingCmp[MAX_PATH+1];
    TCHAR szCmpToBeInstalled[MAX_PATH+1];
    TCHAR szFmtString[2*MAX_PATH+1] = TEXT("");
    TCHAR szMsg[2*MAX_PATH+1] = TEXT("");

    //
    //  Read the mappings value
    //
    LONG lResult = RegOpenKeyEx(hBaseKey, c_pszRegCmMappings, 0, KEY_READ, &hKey);

    if (ERROR_SUCCESS == lResult)
    {
        lResult = RegQueryValueEx(hKey, pszServiceName, NULL, NULL, (LPBYTE)szFmtString, &dwSize);

        if (ERROR_SUCCESS == lResult)
        {
            //
            //  Expand the path in case it contains environment vars
            //
            if (0 == ExpandEnvironmentStrings(szFmtString, szExistingCmp, MAX_PATH))
            {
                CMASSERTMSG(FALSE, TEXT("MigrateCmpData -- Unable to expand environment strings, not migrating cmp data."));
                goto exit;
            }

            //
            //  If the file doesn't exist we have nothing to get cmp settings from ... thus
            //  lets just happily exit.
            //
            if (!FileExists(szExistingCmp))
            {                
                goto exit;
            }

            //
            //  Check to make sure that the Short Service Names agree for the two profiles
            //
            
            CFileNameParts ExistingCmpParts(szExistingCmp);
            if (0 != lstrcmpi(pszShortServiceName, ExistingCmpParts.m_FileName))
            {
                if (!bSilent)
                {
                    MYVERIFY(0 != LoadString(hInstance, IDS_SAME_LS_DIFF_SS, szFmtString, CELEMS(szFmtString)));
                    
                    MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szFmtString, pszShortServiceName, 
                                                            ExistingCmpParts.m_FileName, pszServiceName));

                    MessageBox(NULL, szMsg, pszServiceName, MB_OK);
                }

                bReturn = -1;
                goto exit;
            }
            
            //
            //  Get the path of the cmp to install
            //
            MYVERIFY(CELEMS(szCmpToBeInstalled) > (UINT)wsprintf(szCmpToBeInstalled, 
                TEXT("%s%s.cmp"), g_szProfileSourceDir, pszShortServiceName));
            
            if (FALSE == UpdateCmpDataFromExistingProfile(pszShortServiceName, szExistingCmp, szCmpToBeInstalled))
            {
                bReturn = -1;
            }
        }
    }

exit:

    if (hKey)
    {
        RegCloseKey(hKey);
    }

    return bReturn;
}


//+----------------------------------------------------------------------------
//
// Function:  NeedCM10Upgrade
//
// Synopsis:  This function detects and prepares data for the same name upgrade of a CM 1.0 profile.
//            Thus if you pass in a short service name and a service name, the
//            function detects if this profile is already installed for all users.
//            If it is, then the function checks the profile version stamps in the cmp.
//            If the current version isn't already newer and the user isn't a non-admin
//            on NT5, then we prompt the user if they want to upgrade the current install.
//            If they choose to upgrade then this function migrates the cmp data and
//            finds the uninstall inf.
//
// Arguments: HINSTANCE hInstance - Instance handle for string resources
//            LPCTSTR pszServiceName - ServiceName of the current profile
//            LPCTSTR pszShortServiceName - Short Service name of the current profile
//            LPTSTR pszOldInfPath - Out param for the old inf path, if the same name
//                                     upgrade is needed.
//
// Returns:   int - returns -1 on error, otherwise TRUE or FALSE depending on if a same name
//                  profile was discovered
//
// History:   quintinb  Created     9/8/98
//
//+----------------------------------------------------------------------------
int NeedCM10Upgrade(HINSTANCE hInstance, LPCTSTR pszServiceName, LPCTSTR pszShortServiceName, 
                    LPTSTR pszOldInfPath, BOOL bSilent, CPlatform* plat)
{
    HKEY hKey = NULL;
    int iReturn = FALSE;
    TCHAR   szFmtString[2*MAX_PATH+1] = TEXT("");
    TCHAR   szMsg[2*MAX_PATH+1] = TEXT("");
    const int c_iCM12ProfileVersion = 4;

    MYDBGASSERT((NULL != pszShortServiceName) && (TEXT('\0') != pszShortServiceName[0]));
    MYDBGASSERT((NULL != pszServiceName) && (TEXT('\0') != pszServiceName[0]));

    if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, c_pszRegCmMappings, 0, 
        KEY_READ, &hKey))
    {
        int iCurrentCmpVersion;
        int iCmpVersionToInstall;
        TCHAR szCurrentCmp[MAX_PATH+1];
        TCHAR szCmpToBeInstalled[MAX_PATH+1];
        DWORD dwSize = MAX_PATH;

        if (ERROR_SUCCESS == RegQueryValueEx(hKey, pszServiceName, NULL, 
                                             NULL, (LPBYTE)szCurrentCmp, &dwSize))
        {
            //
            //  First check to see that the file really exists.  It is a somewhat probable case
            //  that the users will have deleted their Profile files but left the registry
            //  keys intact (they didn't uninstall it).  In fact, MSN 2.5 and 2.6 operate this
            //  way.   Thus if the cmp doesn't actually exist then we don't need a same name
            //  upgrade.
            //
            if (!FileExists(szCurrentCmp))
            {
                CMASSERTMSG(FALSE, TEXT("Detected a CM 1.0 Upgrade, but the cmp didn't exist.  Not Processing the upgrade."));
                iReturn = FALSE;
		goto exit;
            }

            //
            //  Check to make sure that the Short Service Names agree for the two profiles
            //
            
            CFileNameParts CurrentCmpParts(szCurrentCmp);
            if (0 != lstrcmpi(pszShortServiceName, CurrentCmpParts.m_FileName))
            {
                if (!bSilent)
                {
                    MYVERIFY(0 != LoadString(hInstance, IDS_SAME_LS_DIFF_SS, szFmtString, CELEMS(szFmtString)));
                    
                    MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szFmtString, pszShortServiceName, 
                                                            CurrentCmpParts.m_FileName, pszServiceName));

                    MessageBox(NULL, szMsg, pszServiceName, MB_OK);
                }

                iReturn = -1;
		goto exit;
            }

            //
            //  Then we have the same servicename profile installed as an all users install.
            //  Check the version number in the CMP.  If the same version or less then we want
            //  to run the same name upgrade.  If the current version is more recent, then
            //  we want to prevent the user from installing.
            //

            //
            //  Get Currently Installed Profile version
            //
            iCurrentCmpVersion = GetPrivateProfileInt(c_pszCmSectionProfileFormat, c_pszVersion, 
                0, szCurrentCmp);
            
            //
            //  Get the version of the profile to install
            //
            MYVERIFY(CELEMS(szCmpToBeInstalled) > (UINT)wsprintf(szCmpToBeInstalled, 
                TEXT("%s%s.cmp"), g_szProfileSourceDir, pszShortServiceName));
            
            iCmpVersionToInstall = GetPrivateProfileInt(c_pszCmSectionProfileFormat, c_pszVersion, 0, 
                szCmpToBeInstalled);

            if (iCurrentCmpVersion > iCmpVersionToInstall)
            {
                //
                //  We must not allow the install because a newer version of the profile format
                //  is already installed.
                //
                if (!bSilent)
                {
                    MYVERIFY(0 != LoadString(hInstance, IDS_NEWER_SAMENAME, szFmtString, CELEMS(szFmtString)));
                    MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szFmtString, pszServiceName));
                    MessageBox(NULL, szMsg, pszServiceName, MB_OK | MB_TOPMOST | MB_SYSTEMMODAL);
                }

                iReturn = -1;
		goto exit;
            }
            else if (iCurrentCmpVersion < c_iCM12ProfileVersion)
            {
                int iUserSelection = 0;

                //
                //  Make sure that this isn't a Non-Admin NT5 person trying to install
                //
                if (plat->IsAtLeastNT5() && !IsAdmin())
                {
                    CMASSERTMSG(!bSilent, TEXT("NeedCM10Upgrade -- NonAdmin trying to Same Name upgrade a profile, exiting!"));
                    if (!bSilent)
                    {
                        MYVERIFY(0 != LoadString(hInstance, IDS_GET_ADMIN, szFmtString, CELEMS(szFmtString)));
                        MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szFmtString, pszServiceName));
                        MessageBox(NULL, szMsg, pszServiceName, MB_OK);
                    }
                    
                    iReturn = -1;
                    goto exit;
                } 
                else
                {
                    //
                    //  Now prompt the user to make sure that they want to go ahead with the upgrade
                    //
                    if (!bSilent)
                    {
                        MYVERIFY(0 != LoadString(hInstance, IDS_UPGRADE_SAMENAME, szFmtString, CELEMS(szFmtString)));
                        MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szFmtString, pszServiceName));
                        iUserSelection = MessageBox(NULL, szMsg, pszServiceName, MB_YESNO | MB_TOPMOST | MB_SYSTEMMODAL);
                    }
                    else
                    {
                        //
                        //  Assume yes with Silent Same Name Upgrade
                        //

                        iUserSelection = IDYES;
                    }
                }

                if (IDYES == iUserSelection)
                {
                    if (UpdateCmpDataFromExistingProfile(pszShortServiceName, szCurrentCmp, szCmpToBeInstalled))
                    {                    
                        CFileNameParts FileParts(szCurrentCmp);
                        if (0 != GetSystemDirectory(szFmtString, MAX_PATH)) // use szFmtString as a temp
                        {
                            MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, TEXT("%s\\%s.inf"), szFmtString, FileParts.m_FileName));
                            if (FileExists(szMsg))
                            {
                                lstrcpy(pszOldInfPath, szMsg);
                            }
                            else
                            {
                                //
                                //  Not in the system directory, try profile dir.
                                //
                                MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, 
                                    TEXT("%s%s%s\\%s.inf"), FileParts.m_Drive, 
                                    FileParts.m_Dir, FileParts.m_FileName, 
                                    FileParts.m_FileName));
                                
                                if (FileExists(szMsg))
                                {
                                    lstrcpy(pszOldInfPath, szMsg);
                                }
                                else
                                {
                                    CMASSERTMSG(FALSE, TEXT("Unable to locate the profile INF -- old profile won't be uninstalled but installation will continue."));
                                    pszOldInfPath[0] = TEXT('\0');
                                }

                            }
                        }
                    }
                    else
                    {
                        CMASSERTMSG(FALSE, TEXT("Couldn't copy cmp file for same name upgrade.  Exiting."));
                        iReturn = -1;
                        goto exit;
                    }

                    iReturn = TRUE;
                    goto exit;
                }
                else
                {
                    iReturn = -1;
                    goto exit;
                }
            }
            else
            {
                //
                //  Then either the version numbers are the same or the version to install is newer but
                //  the existing profile is at least a 1.2 profile.
                //
                iReturn = FALSE;
		goto exit;
            }
        }
    }

exit:
    if (hKey)
    {
        MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
    }

    return iReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  MeetsMinimumProfileInstallVersion
//
// Synopsis:  Because of problems with previous profile installers (namely 1.0),
//            we built in minimum install requirements for profiles.  Thus we
//            look under the Connection Manager App Paths key for a minimum profile
//            version, a minimum build number, and a minimum profile format version.
//            If the profile trying to install doesn't meet any of these requirements,
//            then the function returns FALSE and the install is failed.
//
// Arguments: DWORD dwInstallerVersionNumber - current installer version number
//            DWORD dwInstallerBuildNumber - current installer build number
//            LPCTSTR pszInfFile - path to the inf to get the profile format version number
//
// Returns:   BOOL - TRUE if all the version requirements are met
//
// History:   quintinb Created Header    5/24/99
//
//+----------------------------------------------------------------------------
BOOL MeetsMinimumProfileInstallVersion(DWORD dwInstallerVersionNumber, 
                                       DWORD dwInstallerBuildNumber, LPCTSTR pszInfFile)
{
    const TCHAR* const c_pszRegMinProfileVersion = TEXT("MinProfileVersion");
    const TCHAR* const c_pszRegMinProfileBuildNum = TEXT("MinProfileBuildNum");
    const TCHAR* const c_pszRegMinProfileFmtVersion = TEXT("MinProfileFmtVersion");

    HKEY hKey = NULL;
    BOOL bReturn = TRUE;
    DWORD dwTemp;

    //
    //  First check the format version.
    //
    if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, c_pszRegCmAppPaths, 0, KEY_READ, &hKey))
    {
        DWORD dwSize = sizeof(DWORD);
        DWORD dwType = 0;

        if (ERROR_SUCCESS == RegQueryValueEx(hKey, c_pszRegMinProfileFmtVersion, NULL, 
            &dwType, (LPBYTE)&dwTemp, &dwSize))
        {
            //
            //  Get the profile format version from the cmp file
            //
            DWORD dwFormatVersion;
            CFileNameParts InfParts(pszInfFile);
            TCHAR szCmpFile[MAX_PATH+1];

            MYVERIFY(CELEMS(szCmpFile) > (UINT)wsprintf(szCmpFile, TEXT("%s%s%s%s"), 
                InfParts.m_Drive, InfParts.m_Dir, InfParts.m_FileName, c_pszCmpExt));

            dwFormatVersion = (DWORD)GetPrivateProfileInt(c_pszCmSectionProfileFormat, 
                c_pszVersion, -1, szCmpFile);

            if (dwTemp > dwFormatVersion)
            {
                bReturn = FALSE;
                goto exit;
            }
        }

        //
        //  Next Check the profile version (equivalent to the version number of the 
        //  CM bits the profile was built with)
        //

        dwSize = sizeof(DWORD);

        if (ERROR_SUCCESS == RegQueryValueEx(hKey, c_pszRegMinProfileVersion, NULL, 
            &dwType, (LPBYTE)&dwTemp, &dwSize))
        {
            //
            //  If the minimum version number from the registry is higher than the
            //  version number listed here, fail the install.
            //
            if (dwTemp > dwInstallerVersionNumber)
            {
                bReturn = FALSE;
                goto exit;
            }
        }

        //
        //  Next Check the profile build number (equivalent to the build number of the 
        //  CM bits the profile was built with)
        //

        dwSize = sizeof(DWORD);

        if (ERROR_SUCCESS == RegQueryValueEx(hKey, c_pszRegMinProfileBuildNum, NULL, 
            &dwType, (LPBYTE)&dwTemp, &dwSize))
        {
            //
            //  If the minimum version number from the registry is higher than the
            //  version number listed here, fail the install.
            //
            if (dwTemp > dwInstallerBuildNumber)
            {
                bReturn = FALSE;
                goto exit;
            }
        }
    }

exit:

    if (hKey)
    {
        MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
    }

    return bReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  UninstallExistingCmException
//
// Synopsis:  This function looks for the cmexcept.inf file in the %windir%\inf
//            directory.  If this file exists, then we uninstall the
//            existing exception before we install the new one.  This prevents
//            the rollback information from being lost.
//
// Arguments: none
//
// Returns:   BOOL - returns TRUE if the installer needs to uninstall the
//                   existing CM exception install and FALSE if the install
//                   can continue without it.
//
// History:   quintinb Created      11/1/98
//
//+----------------------------------------------------------------------------
HRESULT UninstallExistingCmException()
{
    HRESULT hr = E_UNEXPECTED;
    LPCSTR c_pszCmExceptInfRelative = TEXT("\\Inf\\cmexcept.inf");
    LPCSTR c_pszUnInstallSection = "DefaultUninstall_NoPrompt";

    UINT uNumChars = GetWindowsDirectoryA(NULL, 0);

    if (uNumChars)
    {
        uNumChars = uNumChars + lstrlenA(c_pszCmExceptInfRelative);

        LPSTR pszPathToCmExceptInf = (LPSTR)CmMalloc(sizeof(CHAR)*(uNumChars + 1));

        if (pszPathToCmExceptInf)
        {
            if (GetWindowsDirectoryA(pszPathToCmExceptInf, uNumChars))
            {
                lstrcatA(pszPathToCmExceptInf, c_pszCmExceptInfRelative);

                if (FileExists(pszPathToCmExceptInf))
                {
                    //
                    //  We have an exception inf in the directory so we need to uninstall it.  Were the
                    //  bits already on the machine newer than the bits we have in the cab, then we wouldn't
                    //  be installing.  If the bits on the machine don't match the version that the inf says,
                    //  then we are better uninstalling those bits and putting them in a known state anyway.
                    //
                    hr = CallLaunchInfSectionEx(pszPathToCmExceptInf, c_pszUnInstallSection, ALINF_ROLLBKDOALL);

                    CMTRACE1(TEXT("UninstallExistingCmException -- CM Exception inf found, uninstalling.  CallLaunchInfSectionEx returned hr=0x%x"), hr);
                }
                else
                {
                    hr = S_FALSE; // nothing to delete
                }            
            }

            CmFree(pszPathToCmExceptInf);
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }
    }

    return hr;
}

//+----------------------------------------------------------------------------
//
// Function:  CheckCmAndIeRequirements
//
// Synopsis:  This function checks the CM and IE requirements for a profile
//            and returns whether the CM should be installed, whether profile
//            migration should occur, and most importantly if the install should
//            exit now because of insufficient requirements.
//
// Arguments: BOOL* pbInstallCm -   tells if CM should be installed or not
//            BOOL* pbMigrateExistingProfiles - tells if profile migration should occur
//            LPCTSTR szInfFile - the inf file to install
//            LPCTSTR szServiceName - The Service name, used as a title
//
// Returns:   BOOL - returns TRUE if the install should continue, FALSE if
//                   if the install should be failed.
//
// History:   quintinb Created      11/1/98
//
//+----------------------------------------------------------------------------
BOOL CheckCmAndIeRequirements(HINSTANCE hInstance, BOOL* pbInstallCm, 
                              BOOL* pbMigrateExistingProfiles, LPCTSTR szInfFile, 
                              BOOL bNoSupportFiles, LPCTSTR szServiceName, BOOL bSilent)
{
    CmVersion   CmVer;
    CPlatform   plat;
    BOOL        bReturn;
    BOOL        bCMRequired;
    TCHAR       szMsg[2*MAX_PATH+1];
    TCHAR       szTemp[MAX_PATH+1];
    TCHAR       szString[MAX_PATH+1];
    DWORD dwInstallerBuildNumber = 0;
    DWORD dwInstallerVersionNumber = 0;


    //
    //  The inf file tells us if we included the CM bits
    //
    if (plat.IsNT5())
    {
        //
        //  We now need to check to see if we need to install the Windows XP bits on
        //  Windows 2000.  Thus we check the inf to see if this profile includes the CM
        //  bits or not.  Note that we never want to install the IE support files on
        //  Win2k so set bIERequired to TRUE.
        //
        bCMRequired = !GetPrivateProfileInt(c_pszCmakStatus, TEXT("IncludeCMCode"), 0, szInfFile);
    }
    else if (CmIsNative())
    {
        //
        //  CM and IE are required on Windows XP and any platforms with the Native
        //  regkey set except NT5 and Win98 SE as they are special cases.
        //
        bCMRequired = TRUE;
    }
    else
    {
        bCMRequired = !GetPrivateProfileInt(c_pszCmakStatus, TEXT("IncludeCMCode"), 
            0, szInfFile);
    }

    //
    //  Now try to get the version numbers from the profile INF
    //
    dwInstallerBuildNumber = (DWORD)GetPrivateProfileInt(c_pszSectionCmDial32, 
        c_pszVerBuild, ((VER_PRODUCTBUILD << c_iShiftAmount) + VER_PRODUCTBUILD_QFE), 
        szInfFile);

    dwInstallerVersionNumber = (DWORD)GetPrivateProfileInt(c_pszSectionCmDial32, 
        c_pszVersion, (HIBYTE(VER_PRODUCTVERSION_W) << c_iShiftAmount) + (LOBYTE(VER_PRODUCTVERSION_W)), 
        szInfFile);

    //
    //  First check to see if we have any install minimums in the registry.  If these
    //  minimums exist and our profile doesn't meet those minimums then we must
    //  throw an error message and exit.
    //
    if (!MeetsMinimumProfileInstallVersion(dwInstallerVersionNumber, 
                                           dwInstallerBuildNumber, szInfFile))
    {
        if (!bSilent)
        {
            MYVERIFY(0 != LoadString(hInstance, IDS_PROFILE_TOO_OLD, szMsg, MAX_PATH));
            MessageBox(NULL, szMsg, szServiceName, MB_OK | MB_ICONERROR);
        }

        return FALSE;
    }

    //
    //  Should we migrate existing profiles?  Always try to migrate if we find all user
    //  profiles already on the machine.
    //
    *pbMigrateExistingProfiles = AllUserProfilesInstalled();

    //
    //  Do CM bits exist on the machine?
    //
    if (CmVer.IsPresent())
    {
        if ((dwInstallerVersionNumber < CmVer.GetVersionNumber()) ||
                 (dwInstallerBuildNumber < CmVer.GetBuildAndQfeNumber()))
        {
            //
            //  If the CM bits on the machine are newer than the bits we have in the cab,
            //  then we only want to install the profile files and not the CM bits themselves.
            //

            *pbInstallCm = FALSE;
            bReturn = TRUE;        
        }
        else
        {
            //
            //  Then the CM bits on the machine are older than the bits in the cab or
            //  the two versions match.  Either way, we should install the bits in the
            //  cab unless this is Win2k where we never want to re-install the same
            //  version of CM bits as we will lose our rollback information.
            //

            if (bCMRequired)
            {
                if ((dwInstallerVersionNumber == CmVer.GetVersionNumber()) &&
                   (CmVer.GetBuildNumber() > c_CmMin13Version))
                {
                    //
                    //  Then the builds have the same major and minor version number
                    //  and should be considered in the same "Version Family".  Note
                    //  that we also check for a minimum build number because 7.00 is
                    //  the version number for the CM 1.0 release in NT4 SP4 and we want CM
                    //  profiles to not install on NT5 Beta2 Bits.
                    //

                    *pbInstallCm = FALSE;
                    bReturn = TRUE;                                    
                }
                else
                {
                    MYVERIFY(CELEMS(szString) > (UINT)wsprintf(szString, TEXT("%u.%u.%u.%u"), 
                        HIWORD(dwInstallerVersionNumber), LOWORD(dwInstallerVersionNumber), 
                        HIWORD(dwInstallerBuildNumber), LOWORD(dwInstallerBuildNumber)));

                    if (!bSilent)
                    {
                        MYVERIFY(0 != LoadString(hInstance, IDS_CM_OLDVERSION, szTemp, MAX_PATH));
                        MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szTemp, szString));
                        MessageBox(NULL, szMsg, szServiceName, MB_OK);
                    }
                    return FALSE;
                }
            }
            else
            {
                if ((dwInstallerVersionNumber == CmVer.GetVersionNumber()) &&
                    (dwInstallerBuildNumber == CmVer.GetBuildAndQfeNumber()))
                {
                    //
                    //  Don't reinstall the CM bits if they are the same version
                    //  and we are on Win2k.  Doing so will overwrite the version of
                    //  CM ready for rollback.
                    //
                    *pbInstallCm = !(plat.IsNT5());
                    bReturn = TRUE;           
                }
                else if (plat.IsNT5() && (FALSE == IsAdmin()))
                {
                    //
                    //  If this is Win2k and we need to install the CM binaries via the exception installer,
                    //  then the user must be an Administrator to do so.  Since this user isn't, fail
                    //  the install and give the user a warning message.
                    //

                    if (!bSilent)
                    {
                        MYVERIFY(0 != LoadString(hInstance, IDS_CANNOT_INSTALL_CM, szMsg, 2*MAX_PATH));
                        
                        MessageBox(NULL, szMsg, szServiceName, MB_OK | MB_ICONEXCLAMATION);
                    }

                    return FALSE;
                }
                else
                {
                    //
                    //  If this is Win2k, we need to make sure we aren't doing a cross language install.
                    //  Basically, we want to ensure that we aren't installing English CM bits on a native
                    //  German machine for instance.  If so, fail the install and inform the user why.
                    //
                    if (plat.IsNT5())
                    {
                        const TCHAR* const c_pszCmstp = TEXT("cmstp.exe");
                        CFileNameParts InfFileParts(szInfFile);
                        DWORD dwLen = lstrlen(InfFileParts.m_Drive) + lstrlen(InfFileParts.m_Dir) + lstrlen(c_pszCmstp);

                        if (MAX_PATH >= dwLen)
                        {
                            wsprintf(szTemp, TEXT("%s%s%s"), InfFileParts.m_Drive, InfFileParts.m_Dir, c_pszCmstp);
                            
                            CVersion CmstpVer(szTemp);
                            DWORD dwExistingCmLcid = CmVer.GetLCID();                            
                            DWORD dwCmstpLcid = CmstpVer.GetLCID();

                            if (FALSE == ArePrimaryLangIDsEqual(dwExistingCmLcid, dwCmstpLcid))
                            {
                                if (!bSilent)
                                {
                                    MYVERIFY(0 != LoadString(hInstance, IDS_CROSS_LANG_INSTALL, szMsg, 2*MAX_PATH));
                        
                                    MessageBox(NULL, szMsg, szServiceName, MB_OK | MB_ICONEXCLAMATION);
                                }

                                return FALSE;
                            }
                        }
                    }

                    //
                    //  Now check to see if installing CM is going to have an effect on CMAK
                    //
                    CmakVersion CmakVer;

                    if (CmakVer.Is121Cmak() || CmakVer.Is122Cmak())
                    {
                        //
                        //  Then the Win2k or IEAK5 version of CMAK is installed.  Installing
                        //  the Whistler version of CM will break this version of CMAK.  We
                        //  need to ask the user if they wish to continue the install and break
                        //  CMAK or abort the install and leave it as is.
                        //
                        if (bSilent)
                        {
                            return FALSE;
                        }
                        else
                        {
                            MYVERIFY(0 != LoadString(hInstance, IDS_INSTCM_WITH_OLD_CMAK, szMsg, 2*MAX_PATH));

                            if (IDNO == MessageBox(NULL, szMsg, szServiceName, MB_YESNO | MB_DEFBUTTON2 | MB_ICONEXCLAMATION))
                            {
                                return FALSE;                        
                            }
                        }
                    }

                    *pbInstallCm = TRUE;
                    bReturn = TRUE;
                }
            }
        }
    }
    else
    {
        if (bCMRequired)
        {
            //
            //  This is an error because we need CM bits but don't have any on
            //  the machine or in the cab (or its Whistler and we won't install them).
            //
            if (!bSilent)
            {
                MYVERIFY(0 != LoadString(hInstance, IDS_CM_NOTPRESENT, szMsg, MAX_PATH));
                MessageBox(NULL, szMsg, szServiceName, MB_OK);
            }

            return FALSE;
        }
        else
        {
            MYDBGASSERT(FALSE == plat.IsNT5()); // we shouldn't be in this state on Win2k but it is probably
                                                // better for the user if we install.

            *pbInstallCm = TRUE;
            bReturn = TRUE;
        }
    }

    if (!bNoSupportFiles)
    {
        if (!CheckIeDllRequirements(&plat))
        {
            if (!bSilent)
            {
                MYVERIFY(0 != LoadString(hInstance, IDS_NO_SUPPORTFILES, szMsg, MAX_PATH));
                MessageBox(NULL, szMsg, szServiceName, MB_OK);
            }
            return FALSE;        
        }
    }

    return bReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  GetInstallOptions
//
// Synopsis:  This function decides if the profile should be installed for all
//            users or the current user only, as well as whether the user prefers
//            a desktop icon, a start menu link, both, or neither.
//
// Arguments: OUT BOOL* pbInstallForAllUsers - should the profile be installed for all users
//            OUT BOOL* pbCreateDesktopIcon - should a desktop icon be created (if NT5)
//            IN BOOL bCM10Upgrade - is this profile upgrading an older same name profile
//            IN BOOL bNoNT5Shortcut - whether the user specified a switch saying they didn't want an NT5 Shortcut
//            IN BOOL bSilentSingleUser - whether the user specified a switch saying they wanted a silent Single User install
//            IN BOOL bSilentAllUser - whether the user specified a switch saying they wanted a silent ALL User install
//
// Returns:   TRUE if the install should continue, FALSE otherwise
//
// History:   quintinb Created    11/1/98
//
//+----------------------------------------------------------------------------
BOOL GetInstallOptions(HINSTANCE hInstance, BOOL* pbInstallForAllUsers, 
                       BOOL* pbCreateDesktopIcon, BOOL bCM10Upgrade, BOOL bNoNT5Shortcut, 
                       BOOL bSingleUser, BOOL bSilent, LPTSTR pszServiceName)
{
    //
    //  We will only allow NT5 users who are administrators to have a choice of how 
    //  the profile is installed.  If the user is on a legacy platform then the profile 
    //  will be installed for all users just as before.  If the profile is installed by 
    //  an NT5 user that is not an admin, it will be installed just for them.  If they 
    //  are an admin then they can choose if they want the profile available to all users
    //  or just for themselves.  If we are on NT5 we also allow the user to choose if 
    //  they want a Desktop Shortcut or not.
    //
    INT_PTR iUiReturn;
    CPlatform   plat;

    if (plat.IsWin9x() || plat.IsNT4())
    {
        //
        //  Legacy install, force to all users (ignore SingleUser flag because not supported).
        //
        *pbInstallForAllUsers = TRUE;
    }
    else
    {
        int iDialogID;
        
        if (bSilent)
        {
            *pbCreateDesktopIcon = !bNoNT5Shortcut;

            if (IsAdmin() && !bSingleUser)
            {
                *pbInstallForAllUsers = TRUE;
            }            
            else
            {
                *pbInstallForAllUsers = FALSE;
            }
        }
        else
        {
            if (IsAdmin())
            {
                //
                //  The user is a local admin, we need to prompt to see if they want to install 
                //  the profile for themselves or for all users.  However, if we are doing a
                //  same name upgrade, then we always do an all users install and don't give the
                //  admin any choice.
                //
                if (bCM10Upgrade)
                {
                    iDialogID = IDD_NOCHOICEUI;         
                }
                else
                {
                    iDialogID = IDD_ADMINUI;
                }
            }
            else
            {
                //
                //  Just a normal user, but we still need to prompt for whether they want 
                //  a desktop shortcut
                //
                if (bCM10Upgrade)
                {
                    CMASSERTMSG(FALSE, TEXT("Non-Admin NT5 made it to UI choice section.  Check CM 1.0 upgrade code."));
                    return FALSE;
                }
                else
                {
                    iDialogID = IDD_NOCHOICEUI;         
                }
            }

            InitDialogStruct DialogArgs;
            DialogArgs.pszTitle = pszServiceName;
            DialogArgs.bNoDesktopIcon = bNoNT5Shortcut;
            DialogArgs.bSingleUser = bSingleUser;

            iUiReturn = DialogBoxParam(hInstance, MAKEINTRESOURCE(iDialogID), NULL, 
                (DLGPROC)ProcessPreferencesUI, (LPARAM)&DialogArgs);

            if (-1 == iUiReturn)
            {
                // then we had an error or the user hit cancel.  Either way bail.
                return FALSE;
            }
            else
            {
                *pbInstallForAllUsers = (BOOL)(iUiReturn & ALLUSERS) || bCM10Upgrade;
                *pbCreateDesktopIcon = (BOOL)(iUiReturn & CREATEDESKTOPICON);
            }
        }
    }
    return TRUE;
}

BOOL VerifyProfileOverWriteIfExists(HINSTANCE hInstance, LPCTSTR pszCmsFile, LPCTSTR pszServiceName, 
                                    LPCTSTR pszShortServiceName, LPTSTR pszOldInfPath, BOOL bSilent)
{
    TCHAR szTmpServiceName [MAX_PATH+1] = TEXT("");
    TCHAR szDisplayMsg[3*MAX_PATH+1] = TEXT("");
    TCHAR szTemp [2*MAX_PATH+1] = TEXT("");
    int iRet;

    if (FileExists(pszCmsFile))
    {
        //
        //  If the file exists then we want to make sure that the service name is the same.
        //  If the Long Service Names are the same then we have a re-install.
        //  If they aren't the same then we need to prompt the user and find out whether to
        //  abandon the install or continue and overwrite it.
        //

        MYVERIFY(0 != GetPrivateProfileString(c_pszCmSection, c_pszCmEntryServiceName, 
            TEXT(""), szTmpServiceName, CELEMS(szTmpServiceName), pszCmsFile));

        if (0 != lstrcmp(szTmpServiceName, pszServiceName))
        {
            //
            //  If the install is silent, we will assume they know what they are doing
            //  and we will overwrite.  Otherwise prompt the user to see what they want
            //  us to do.
            //
            if (!bSilent)
            {
                MYVERIFY(0 != LoadString(hInstance, IDS_SAME_SS_DIFF_LS, szTemp, 2*MAX_PATH));

                MYVERIFY(CELEMS(szDisplayMsg) > (UINT)wsprintf(szDisplayMsg, szTemp, pszServiceName, 
                    szTmpServiceName, pszShortServiceName));
            
                MessageBox(NULL, szDisplayMsg, pszServiceName, MB_OK | MB_TOPMOST | MB_SYSTEMMODAL);
            }

            return FALSE;
        }
    }

    return TRUE;
}


//+----------------------------------------------------------------------------
//
// Function:  PresharedKeyPINDlgProc
//
// Synopsis:  This function obtains the PIN to be used for the Pre-Shared key
//
// History:   SumitC    29-Mar-2001         Created
//
//+----------------------------------------------------------------------------
BOOL APIENTRY PresharedKeyPINDlgProc(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    static PresharedKeyPINStruct * pPSKArgs;

    switch (message)
    {
        case WM_INITDIALOG:
            pPSKArgs = (PresharedKeyPINStruct*)lParam;
            break;

        case WM_COMMAND:
            switch (LOWORD(wParam)) 
            {
                case IDOK:
                    MYDBGASSERT(pPSKArgs);
                    if (pPSKArgs && pPSKArgs->szPIN)
                    {
                        GetDlgItemText(hDlg, IDC_PSK_PIN, pPSKArgs->szPIN, c_dwMaxPresharedKeyPIN);
                    }
                    MYVERIFY(FALSE != EndDialog(hDlg, 1));
                    return TRUE;

                case IDCANCEL:
                    MYVERIFY(FALSE != EndDialog(hDlg, -1));
                    return TRUE;

                default:
                    break;
            }
            break;

        case WM_CLOSE:
            MYVERIFY(FALSE != EndDialog(hDlg, -1));
            return TRUE;
            
        default:
            return FALSE;
    }
    return FALSE;   
}


//+----------------------------------------------------------------------------
//
// Function:  GetPINforPresharedKey
//
// Synopsis:  Asks the user for a PIN (to be used to decrypt the pre-shared key)
//
// Arguments: [hInstance]  - used for bringing up dialogs
//            [ppszPIN]    - ptr to where to put Pre-Shared Key PIN
//
// Returns:   LRESULT (ERROR_SUCCESS if we got a PIN,
//                     ERROR_INVALID_DATA if user cancelled out of PIN dialog,
//                     ERROR_INVALID_PARAMETER if params are bad (this is a coding issue)
//
// History:   3-Apr-2001    SumitC      Created
//
//-----------------------------------------------------------------------------
LRESULT GetPINforPresharedKey(HINSTANCE hInstance, LPTSTR * ppszPIN)
{
    LRESULT lRet = ERROR_SUCCESS;
    
    MYDBGASSERT(hInstance);
    MYDBGASSERT(ppszPIN);

    if (NULL == hInstance || NULL == ppszPIN)
    {
        return ERROR_INVALID_PARAMETER;
    }
    
    *ppszPIN = NULL;

    //
    //  Get the PIN
    //
    PresharedKeyPINStruct PresharedKeyPINArgs = {0};

    INT_PTR iUiReturn = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_PRESHAREDKEY_PIN), NULL, 
        (DLGPROC)PresharedKeyPINDlgProc, (LPARAM)&PresharedKeyPINArgs);

    if (-1 == iUiReturn)
    {
        lRet = ERROR_INVALID_DATA;  // caller maps to appropriate error message.
    }
    else
    {
        DWORD dwLen = lstrlen(PresharedKeyPINArgs.szPIN);
        if (0 == dwLen)
        {
            lRet = ERROR_INVALID_DATA;  // caller maps to appropriate error message.
        }
        else
        {
            *ppszPIN = (LPTSTR) CmMalloc((dwLen + 1) * sizeof(TCHAR));
            if (*ppszPIN)
            {
                lstrcpy(*ppszPIN, PresharedKeyPINArgs.szPIN);
            }
        }
    }

    return lRet;
}


//+----------------------------------------------------------------------------
//
// Function:  DecryptPresharedKeyUsingPIN
//
// Synopsis:  Given an encoded preshared key and a PIN to be used for decoding,
//            performs the decoding job.
//
// Arguments: [pszEncodedPresharedKey] - encoded Preshared key
//            [pszPreSharedKeyPIN]     - the PIN
//            [ppszPreSharedKey]       - ptr to buffer to place Pre-Shared Key
//
// Returns:   LRESULT (ERROR_SUCCESS successfully decoded
//                     ERROR_INVALID_PARAMETER if params are bad (this is a coding issue)
//                     other errors as encountered while calling crypto APIs
//
// History:   3-Apr-2001    SumitC      Created
//
//-----------------------------------------------------------------------------
LRESULT DecryptPresharedKeyUsingPIN(LPCTSTR pszEncodedPresharedKey,
                                    LPCTSTR pszPresharedKeyPIN,
                                    LPTSTR * ppszPresharedKey)
{
    LRESULT lRet = ERROR_BADKEY;

    if (lstrlen(pszPresharedKeyPIN) < c_dwMinPresharedKeyPIN)
    {
        CMTRACE(TEXT("DecryptPresharedKeyUsingPIN - PIN is too short"));
        return lRet;
    }
    if (lstrlen(pszPresharedKeyPIN) > c_dwMaxPresharedKeyPIN)
    {
        CMTRACE(TEXT("DecryptPresharedKeyUsingPIN - PIN is too long"));
        return lRet;
    }

    //
    //  Init Cmsecure
    //
    InitSecure(FALSE);      // use secure, not fast encryption

    //
    //  decrypt to get Preshared key
    //
    if (pszEncodedPresharedKey && pszPresharedKeyPIN)
    {
        DWORD dwLen = 0;

        if (FALSE == DecryptString((LPBYTE)pszEncodedPresharedKey,
                                   lstrlen(pszEncodedPresharedKey) * sizeof(TCHAR),
                                   (LPSTR)pszPresharedKeyPIN,
                                   (LPBYTE *)ppszPresharedKey,
                                   &dwLen,
                                   (PFN_CMSECUREALLOC)CmMalloc,
                                   (PFN_CMSECUREFREE)CmFree))
        {
            CMTRACE1(TEXT("DecryptPresharedKeyUsingPIN - DecryptString failed with %d"), GetLastError());
            lRet = ERROR_BADKEY;
        }
        else
        {
            lRet = ERROR_SUCCESS;
            CMASSERTMSG(dwLen, TEXT("DecryptString succeeded, but pre-shared key retrieved was 0 bytes?"));
        }
    }

    //
    //  Deinit cmsecure
    //
    DeInitSecure();

    return lRet;
}

//+----------------------------------------------------------------------------
//
// Function:  SetThisConnectionAsDefault
//
// Synopsis:  This function loads inetcfg.dll and calls the InetSetAutodial
//            entry on the given service name.  Thus this function sets the
//            given servicename as the IE default connection.
//
// Arguments: LPCSTR pszServiceName - Long service name of the connection to set
//
// Returns:   BOOL - TRUE if successful
//
// History:   quintinb Created    03/04/00
//
//+----------------------------------------------------------------------------
BOOL SetThisConnectionAsDefault(LPSTR pszServiceName)
{
    BOOL bReturn = FALSE;
    typedef HRESULT (WINAPI *pfnInetSetAutodialProc)(BOOL, LPSTR);

    if (pszServiceName && (TEXT('\0') != pszServiceName[0]))
    {
        CDynamicLibrary CnetCfg;

        if (CnetCfg.Load(TEXT("inetcfg.dll")))
        {
            pfnInetSetAutodialProc pfnInetSetAutodial = (pfnInetSetAutodialProc)CnetCfg.GetProcAddress("InetSetAutodial");

            if (pfnInetSetAutodial)
            {
                HRESULT hr = pfnInetSetAutodial(TRUE, pszServiceName); // TRUE == fEnable
                bReturn = SUCCEEDED(hr);
            }
        }
    }

    return bReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  GetPreSharedKey
//
// Synopsis:  This function does all the grunt work of getting a PreSharedKey
//            out of the profile and decrypting it if one exists.
//
// Arguments: LPCSTR pszCmpFile - full path to the cmp file
//
// Returns:   HRESULT -- S_OK on success
//                       S_FALSE if the profile doesn't contain a PSK
//                       E_XXX otherwise
//
// History:   quintinb Created    09/14/01
//
//+----------------------------------------------------------------------------
HRESULT GetPreSharedKey(HINSTANCE hInstance, LPCTSTR pszCmpFile, LPCTSTR pszServiceName, LPTSTR* ppszPreSharedKey, BOOL bSilent)
{
    //
    //  Check input parameters
    //
    if ((NULL == pszCmpFile) || (TEXT('\0') == pszCmpFile[0]) || (NULL == ppszPreSharedKey) || (NULL == pszServiceName) || (TEXT('\0') == pszServiceName[0]))
    {
        CMASSERTMSG(FALSE, TEXT("GetPreSharedKey -- Invalid parameter passed."));
        return E_INVALIDARG;
    }

    HRESULT hrReturn = S_OK;
    TCHAR szTemp[2*MAX_PATH+1];
    CPlatform   plat;

    //
    //  Check to see if we have a Pre-shared Key
    //
    if (FileExists(pszCmpFile))
    {
        LPTSTR pszPresharedKey = GetPrivateProfileStringWithAlloc(c_pszCmSection, c_pszCmEntryPresharedKey, TEXT(""), pszCmpFile);

        if (pszPresharedKey && (TEXT('\0') != pszPresharedKey[0]))
        {
            //
            //  Okay, we potentially have a PSK.  If we are on Win2k or a downlevel system without the SafeNet client,
            //  then we need to warn the user that their connection might not work and ask them if they wish to continue
            //  anyway.
            //
            UINT uMessageId = 0;

            if (plat.IsNT5()) // NT5 only
            {
                uMessageId = IDS_PSK_NEEDS_XP;
            }
            else if (plat.IsNT4() || plat.IsWin9x()) // downlevel without SafeNet
            {
                SafeNetLinkageStruct SnLinkage = {0};

                if (!IsSafeNetClientAvailable() || !LinkToSafeNet(&SnLinkage)) // UnLinkFromSafeNet needs to be called if we hit this
                {
                    uMessageId = IDS_PSK_NEEDS_SAFENET;
                }

                UnLinkFromSafeNet(&SnLinkage);
            }
            // else it is WinXP+ or downlevel with SafeNet and everything should work just nicely...

            if (uMessageId)
            {
                //
                //  Now show the user the error message unless we are in silent mode.  Either way we aren't going to do anything
                //  more with the PSK string since the user's OS cannot handle pre-shared keys.
                //
                int iMessageReturn = IDNO;

                if (!bSilent && LoadString(hInstance, uMessageId, szTemp, sizeof(szTemp)))
                {
                    iMessageReturn = MessageBox(NULL, szTemp, pszServiceName, MB_YESNO | MB_ICONWARNING);
                }

                if (IDYES == iMessageReturn)
                {
                    //
                    //  Okay, we are continuing but we cannot do anything with the PSK, so set the return code to S_FALSE.
                    //
                    hrReturn = S_FALSE;
                }
                else
                {
                    //
                    //  The user decided to bail or we are in silent mode and needed to show a warning.
                    //
                    hrReturn = E_ABORT;
                }

                //
                //  We cannot do anything with the PSK so let's free it.  We will erase it from the cmp below.
                //
                CmFree(pszPresharedKey);
                pszPresharedKey = NULL;

            }
            else
            {
                //
                //  Okay, we have a PSK and it needs further processing such as decryption and/or handing off to RAS/SafeNet.
                //

                CMTRACE(TEXT("Got a pre-shared key"));

                BOOL bEncrypted = (BOOL) GetPrivateProfileInt(c_pszCmSection, c_pszCmEntryKeyIsEncrypted, FALSE, pszCmpFile);

                if (bEncrypted)
                {
                    CMTRACE(TEXT("Pre-shared key is encrypted"));

                    if (bSilent)
                    {
                        //
                        //  If we are in silent mode, then we cannot exactly ask the user for a PIN.  Thus we will have to abort.
                        //
                        CmFree(pszPresharedKey);
                        hrReturn = E_ABORT;
                    }
                    else
                    {
                        LPTSTR pszPresharedKeyPIN = NULL;
                        LRESULT lRet = GetPINforPresharedKey(hInstance, &pszPresharedKeyPIN);

                        if ((ERROR_SUCCESS == lRet) && pszPresharedKeyPIN)
                        {
                            //
                            //  The Pre-shared key is encoded
                            //
                            LPTSTR pszPresharedKeyDecoded = NULL;
                            lRet = DecryptPresharedKeyUsingPIN(pszPresharedKey, pszPresharedKeyPIN, &pszPresharedKeyDecoded);

                            if (ERROR_SUCCESS == lRet)
                            {
                                *ppszPreSharedKey = pszPresharedKeyDecoded;
                            }
                            else
                            {
                                *ppszPreSharedKey = NULL;
                                lRet = ERROR_BADKEY;
                            }
                        }

                        CmFree(pszPresharedKey);
                        CmFree(pszPresharedKeyPIN);

                        if (ERROR_SUCCESS != lRet)
                        {
                            switch (lRet)
                            {
                            case ERROR_INVALID_DATA:
                                MYVERIFY(0 != LoadString(hInstance, IDS_PSK_GOTTA_HAVE_IT, szTemp, CELEMS(szTemp)));
                                break;
                            case ERROR_BADKEY:
                                MYVERIFY(0 != LoadString(hInstance, IDS_PSK_INCORRECT_PIN, szTemp, CELEMS(szTemp)));
                                break;
                            default:
                                MYVERIFY(0 != LoadString(hInstance, IDS_UNEXPECTEDERR, szTemp, CELEMS(szTemp)));
                                MYDBGASSERT(0);
                                break;
                            }

                            MessageBox(NULL, szTemp, pszServiceName, MB_OK | MB_ICONEXCLAMATION);
                            hrReturn = E_ACCESSDENIED;
                        }
                    }
                }
                else
                {
                    //
                    //  Nothing to decode, just save the PSK buffer
                    //
                    *ppszPreSharedKey = pszPresharedKey;
                }

                //
                //  Write to the cmp file that we need to delete this PSK on uninstall.  If we never get fully
                //  installed then the cmp file gets deleted anyway so no big deal.  Note that we do this here
                //  so that it is in the cmp file before we copy it to the profile directory.
                //
                if (SUCCEEDED(hrReturn) && (plat.IsNT4() || plat.IsWin9x()))
                {
                    WritePrivateProfileString(c_pszCmSection, c_pszDeletePskOnUninstall, TEXT("1"), pszCmpFile);
                }
            }

            //
            //  Erase the PSK from the cmp file
            //
            WritePrivateProfileString(c_pszCmSection, c_pszCmEntryPresharedKey, NULL, pszCmpFile);
            WritePrivateProfileString(c_pszCmSection, c_pszCmEntryKeyIsEncrypted, NULL, pszCmpFile);
        }
        else
        {
            CmFree(pszPresharedKey);
            hrReturn = S_FALSE;
        }
    }

    return hrReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  InstallInf
//
// Synopsis:  This is the driver code for installing a CM profile.
//
// Arguments: HINSTANCE hInstance - Instance handle for resources
//            LPCTSTR szInfFile - INF file to install
//            BOOL bNoSupportFiles - forces browser files not to be checked for
//            BOOL bNoLegacyIcon - Don't install with a legacy Icon
//            BOOL bNoNT5Shortcut - Don't give the user a NT5 Desktop Shortcut
//            BOOL bSilent - Install the profile silently
//            BOOL bSingleUser - Install the profile for the current user only
//                               Note that single user is the default now even for
//                               Admins.  Non-Admins always get single user installs.
//            BOOL bSetAsDefault - set as the default connection once installed
//            CNamedMutex* pCmstpMutex - pointer to the cmstp mutex object so 
//                                       that it can be released once the profile is launched
//
// Returns:   HRESULT - standard COM error codes
//
// History:   quintinb Created    7/14/98
//            quintinb added support for new switches (252872)    11/20/98
//
//+----------------------------------------------------------------------------
HRESULT InstallInf(HINSTANCE hInstance, LPCTSTR szInfFile, BOOL bNoSupportFiles, 
                BOOL bNoLegacyIcon, BOOL bNoNT5Shortcut, BOOL bSilent, 
                BOOL bSingleUser, BOOL bSetAsDefault, CNamedMutex* pCmstpMutex)
{
    CPlatform   plat;

    BOOL bMigrateExistingProfiles;
    BOOL bInstallCm;
    BOOL bMustReboot = FALSE;
    BOOL bCM10Upgrade = FALSE;
    HRESULT hrReturn = S_OK;
    HRESULT hrTemp = S_OK;
    BOOL bInstallForAllUsers;
    BOOL bCreateDesktopIcon = FALSE;

    HKEY hKey = NULL;

    DWORD dwSize;
    DWORD dwType;
    TCHAR szInstallDir[MAX_PATH+1];
    TCHAR szTemp[2*MAX_PATH+1];
    TCHAR szCmsFile[MAX_PATH+1];
    TCHAR szOldInfPath[MAX_PATH+1];
    TCHAR szServiceName[MAX_PATH+1];
    TCHAR szShortServiceName[MAX_PATH+1];
    TCHAR szTitle[MAX_PATH+1];
    LPTSTR pszPhonebook = NULL;
    LPTSTR pszCmpFile = NULL;
    LPTSTR pszPresharedKey = NULL;

//CMASSERTMSG(FALSE, TEXT("Attach the Debugger now!"));
    MYDBGASSERT((szInfFile) && (TEXT('\0') != szInfFile[0]));

    CFileNameParts InfParts(szInfFile);
    wsprintf(g_szProfileSourceDir, TEXT("%s%s"), InfParts.m_Drive, InfParts.m_Dir);

    MYVERIFY(0 != LoadString(hInstance, IDS_CMSTP_TITLE, szTitle, CELEMS(szTitle)));
    MYDBGASSERT(TEXT('\0') != szTitle[0]);

    //
    //  Get the ServiceName and ShortServicename from the inf file
    //

    MYVERIFY(0 != GetPrivateProfileString(c_pszInfSectionStrings, c_pszCmEntryServiceName, 
        TEXT(""), szServiceName, CELEMS(szServiceName), szInfFile));

    MYVERIFY(0 != GetPrivateProfileString(c_pszInfSectionStrings, c_pszShortSvcName, 
        TEXT(""), szShortServiceName, CELEMS(szShortServiceName), szInfFile));

    if ((TEXT('\0') == szServiceName[0]) || (TEXT('\0') == szShortServiceName[0]))
    {
        CMASSERTMSG(FALSE, TEXT("Either the ServiceName or the ShortServiceName are empty, exiting."));
        hrReturn = E_FAIL;
        goto exit;
    }

    //
    //  If this is NT5, check the New Connection Wizard Policy to see if the user is allowed to
    //  create new connections.  If not, then don't let them install.
    //
    if (plat.IsAtLeastNT5())
    {
        LPTSTR c_pszNewPolicy = TEXT("NC_NewConnectionWizard");
        LPTSTR c_pszConnectionsPoliciesKey = TEXT("Software\\Policies\\Microsoft\\Windows\\Network Connections");

        //
        //  Administrators and all Authenticated users have access to install profiles
        //  by default.  Non-Authenticated users don't have access to install profiles
        //  because they don't have permission to start Rasman.  Thus, even if we
        //  allowed them to try to install, it would fail when we couldn't create a
        //  connectoid for the profile.
        //
        DWORD dwAllowedToInstall = IsAuthenticatedUser() || IsAdmin();

        //
        //  Now we need to check the policy registry key to see if someone has overriden
        //  the default behavior.  If so, then we will honor it by setting dwAllowedToInstall
        //  to the value of the policy key.  Note that we even check the registry key for
        //  authenticated users (an Admin could enable installation for all users, but users
        //  that weren't Authenticated, namely guests, wouldn't be able to The default is to allow Users, Power Users (who are users), and Admins to install
        //  connections.  However the policy may be setup so that they cannot.  Lets assume they
        //  can and then check the regkey.
        //
        if (dwAllowedToInstall)
        {
            LONG lResult = RegOpenKeyEx(HKEY_CURRENT_USER, c_pszConnectionsPoliciesKey, 
                                        0, KEY_READ, &hKey);

            if (ERROR_SUCCESS == lResult)
            {
                dwSize = sizeof(dwAllowedToInstall);

                lResult = RegQueryValueEx(hKey, c_pszNewPolicy, NULL, 
                                          NULL, (LPBYTE)&dwAllowedToInstall, &dwSize);                
                RegCloseKey(hKey);
            }
        }

        if (!dwAllowedToInstall)
        {
            //
            //  The user isn't allowed to create new connections, thus they aren't allowed to install
            //  CM connections.  Throw an error message about permissions and exit.
            //
            MYVERIFY(0 != LoadString(hInstance, IDS_INSTALL_NOT_ALLOWED, szTemp, CELEMS(szTemp)));
            MessageBox(NULL, szTemp, szServiceName, MB_OK);
            hrReturn = E_ACCESSDENIED;
            goto exit;
        }
    }

    if (!CheckCmAndIeRequirements(hInstance, &bInstallCm, &bMigrateExistingProfiles, 
        szInfFile, bNoSupportFiles, szServiceName, bSilent))
    {
        hrReturn = E_FAIL;
        goto exit;
    }

    //
    //  Check to see if we have a same name upgrade
    //
    
    bCM10Upgrade = NeedCM10Upgrade(hInstance, szServiceName, szShortServiceName, 
                                   szOldInfPath, bSilent, &plat);

    if (-1 == bCM10Upgrade)
    {
        //
        //  if NeedCM10Upgrade returned -1 then either an error occurred or
        //  the user decided not to upgrade.  Either way, bail.
        //
        hrReturn = S_FALSE;
        goto exit;
    }

    //
    //  Check to see if a Pre-shared Key is present and if a PIN is required
    //
    pszCmpFile = szTemp;    // re-use szTemp to save stack space and not get into trouble on Win9x
    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(pszCmpFile, TEXT("%s%s.cmp"), 
        g_szProfileSourceDir, szShortServiceName));

    hrReturn = GetPreSharedKey(hInstance, pszCmpFile, szServiceName, &pszPresharedKey, bSilent);
 
    if (FAILED(hrReturn))
    {
        goto exit;
    }

    //
    //  Throw the UI to get user install options, unless we are in silent mode
    //
    if (!GetInstallOptions(hInstance, &bInstallForAllUsers, &bCreateDesktopIcon, 
        bCM10Upgrade, bNoNT5Shortcut, bSingleUser, bSilent, szServiceName))
    {
        hrReturn = S_FALSE;
        goto exit;    
    }

    //
    //  Get the installation path
    //

    ZeroMemory(szInstallDir, sizeof(szInstallDir));

    if (bInstallForAllUsers)
    {
        //
        //  Install for All Users
        //

        if (!GetAllUsersCmDir(szInstallDir, hInstance))
        {
            hrReturn = E_FAIL;
            goto exit; 
        }
    }
    else
    {
        //
        //  Install only for the current user
        //
        
        GetPrivateCmUserDir(szInstallDir, hInstance);   //lint !e534

        if (TEXT('\0') == szInstallDir[0])
        {
            hrReturn = E_FAIL;
            goto exit;        
        }
    }

    MYVERIFY(CELEMS(szCmsFile) > (UINT)wsprintf(szCmsFile, TEXT("%s\\%s\\%s.cms"), 
        szInstallDir, szShortServiceName, szShortServiceName));

    //
    //  Check for two profiles with the same Short Service Name and different Long Service
    //  Names
    //
    if (!VerifyProfileOverWriteIfExists(hInstance, szCmsFile, 
         szServiceName, szShortServiceName, szOldInfPath, bSilent))
    {
        hrReturn = S_FALSE;
        goto exit;
    }

    //  Now Migrate users old cm profiles (to have full paths to their CMP files in the 
    //  desktop GUID) if necessary
    //
    if (bMigrateExistingProfiles)
    {
        //
        //  Ignore the return here for now.  Not much we can do about it at this stage.
        //  Should we give them an error?
        //
        MYVERIFY(SUCCEEDED(MigrateOldCmProfilesForProfileInstall(hInstance, g_szProfileSourceDir)));
    }

    if (bCM10Upgrade)
    {
        //
        //  Uninstall the current profile so that we can install the newer version.  Note
        //  that we don't want to use the uninstall string because it might call for
        //  cmstp.exe which is already running.  Thus uninstall by calling UninstallProfile
        //  directly.  Note that we do not delete the credentials on a same name upgrade
        //  profile uninstall.
        //

        if (szOldInfPath[0])
        {
            RemoveShowIconFromRunPostSetupCommands(szOldInfPath);

            MYVERIFY(SUCCEEDED(UninstallProfile(hInstance, szOldInfPath, FALSE))); // bCleanUpCreds == FALSE
        }
    }
    else
    {
        //
        //  We need to check if we are installing over another profile of the same name.
        //  If so, then we want to recover the cmp data unless this is a CM 1.0 upgrade
        //  in which case we have already done this as part of that upgrade code.
        //
        if (-1 == MigrateCmpData(hInstance, bInstallForAllUsers, szServiceName, szShortServiceName, bSilent))
        {
            hrReturn = S_FALSE;
            goto exit;        
        }
    }

    //
    //  In order to keep MSN's online setup working we need to keep the all user install 
    //  registry key (used to communicate the path to the inf) in the same place that it was
    //  for the Win98 SE/Beta3 release.  The Single user reg key location had to be moved to 
    //  allow plain old users to install profiles.
    //
    HKEY hBaseKey;
    LPTSTR pszRegInfCommKeyPath;

    if (bInstallForAllUsers)
    {
        hBaseKey = HKEY_LOCAL_MACHINE;
        pszRegInfCommKeyPath = (LPTSTR)c_pszRegCmAppPaths;
    }
    else
    {
        hBaseKey = HKEY_CURRENT_USER;
        pszRegInfCommKeyPath = (LPTSTR)c_pszRegCmRoot;
    }


    //
    //  Now create the install dir and the reg key to communicate this info to the inf file.
    //
    if (TEXT('\0') != szInstallDir[0])
    {
        //
        //  Create the full path to the installation directory.
        //
        MYVERIFY(FALSE != CreateLayerDirectory(szInstallDir));

        //
        //  Make sure the CM directory is writable by all users so that phonebook updates can take place.
        //
        if (bInstallForAllUsers && plat.IsAtLeastNT5())
        {
            MYVERIFY(AllowAccessToWorld(szInstallDir));
        }

        //
        //  Create the Profile subdirectory too, that way we avoid profile
        //  install problems on Win98 -- NTRAID 376878
        //
        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s"), szInstallDir, szShortServiceName));
        MYVERIFY(FALSE != CreateLayerDirectory(szTemp));

        //
        //  We now need to write the registry key that the inf will use as the
        //  installation directory.  See the CustomDestination section of the 
        //  profile inf to see where this ties in.
        //
        if (plat.IsWin9x())
        {
            //
            //  Then we need to use the Short Name in the regkey or the inf will not install properly
            //
            MYVERIFY(0 != GetShortPathName(szInstallDir, szTemp, CELEMS(szTemp)));

            lstrcpyn(szInstallDir, szTemp, MAX_PATH);       // szTemp is larger than szInstallDir, we only use MAX_PATH chars
        }

        if (ERROR_SUCCESS != RegCreateKey(hBaseKey, pszRegInfCommKeyPath, &hKey))
        {
            CMASSERTMSG(FALSE, TEXT("InstallInf -- Unable to create the Inf Communication Key"));
            MYVERIFY(0 != LoadString(hInstance, IDS_UNEXPECTEDERR, szTemp, CELEMS(szTemp)));
            MessageBox(NULL, szTemp, szServiceName, MB_OK);
            hrReturn = E_FAIL;
            goto exit;
        }

        //
        //  We now need to create the value with our szInstallDir string.
        //
        
        dwType = REG_SZ;
        dwSize = lstrlen(szInstallDir);
        if (ERROR_SUCCESS != RegSetValueEx(hKey, c_pszProfileInstallPath, NULL, dwType, 
            (CONST BYTE *)szInstallDir, dwSize))
        {
            CMASSERTMSG(FALSE, TEXT("InstallInf -- Unable to set the Profile Install Path value."));
            MYVERIFY(0 != LoadString(hInstance, IDS_UNEXPECTEDERR, szTemp, CELEMS(szTemp)));
            MessageBox(NULL, szTemp, szServiceName, MB_OK);

            MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
            hrReturn = E_FAIL;
            goto exit;
        }

        MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
    }
    else
    {
        CMASSERTMSG(FALSE, TEXT("InstallInf -- Unable to resolve the Install Directory."));
        MYVERIFY(0 != LoadString(hInstance, IDS_UNEXPECTEDERR, szTemp, CELEMS(szTemp)));
        MessageBox(NULL, szTemp, szServiceName, MB_OK);
        hrReturn = E_FAIL;
        goto exit;
    }

    //
    //  Install the Profile Files and create the mappings entry
    //

    if (bInstallForAllUsers)
    {
        hrTemp = LaunchInfSection(szInfFile, TEXT("DefaultInstall"), szTitle, bSilent);
        MYDBGASSERT(SUCCEEDED(hrTemp));
        bMustReboot = ((HRESULT)ERROR_SUCCESS_REBOOT_REQUIRED == hrTemp) ? TRUE: bMustReboot;

        //
        //  Still launch this for Legacy (read MSN online setup reasons, perhaps others)
        //
        hrTemp = LaunchInfSection(szInfFile, TEXT("Xnstall_AllUser"), szTitle, bSilent);
        MYDBGASSERT(SUCCEEDED(hrTemp));
        bMustReboot = ((HRESULT)ERROR_SUCCESS_REBOOT_REQUIRED == hrTemp) ? TRUE: bMustReboot;
    }
    else
    {
        hrTemp = LaunchInfSection(szInfFile, TEXT("DefaultInstall_SingleUser"), szTitle, bSilent);
        MYDBGASSERT(SUCCEEDED(hrTemp));
        bMustReboot = ((HRESULT)ERROR_SUCCESS_REBOOT_REQUIRED == hrTemp) ? TRUE: bMustReboot;

        //
        //  Still launch this for Legacy (I doubt anyone is using this but kept 
        //  for consistency with All User which at least MSN was using)
        //
        hrTemp = LaunchInfSection(szInfFile, TEXT("Xnstall_Private"), szTitle, bSilent);
        MYDBGASSERT(SUCCEEDED(hrTemp));
        bMustReboot = ((HRESULT)ERROR_SUCCESS_REBOOT_REQUIRED == hrTemp) ? TRUE: bMustReboot;

        //
        //  Write the single user mappings key in code since parsing is involved.
        //

        if (!WriteSingleUserProfileMappings(szInstallDir, szShortServiceName, szServiceName))
        {
            CMASSERTMSG(FALSE, TEXT("InstallInf -- WriteSingleUserProfileMappings Failed."));
            MYVERIFY(0 != LoadString(hInstance, IDS_UNEXPECTEDERR, szTemp, CELEMS(szTemp)));
            MessageBox(NULL, szTemp, szServiceName, MB_OK);
            hrReturn = E_FAIL;
            goto exit;            
        }
    }

    //
    //  Install the CM bits as necessary
    //
    if (bInstallCm)
    {
        MYDBGASSERT(FALSE == plat.IsNT51());

        //
        //  First, we must extract the CM binaries from the binaries
        //  executable/cab to the cmbins sub dir.
        //
        wsprintf(szTemp, TEXT("%scmbins\\"), g_szProfileSourceDir);

        hrTemp = ExtractCmBinsFromExe(g_szProfileSourceDir, szTemp);

        if (SUCCEEDED(hrTemp))
        {
            TCHAR szSource [MAX_PATH+1] = {0};
            TCHAR szDest [MAX_PATH+1] = {0};

            if (plat.IsNT5())
            {
                //
                //  Copy cmexcept.cat to the cmbins dir
                //
                MYVERIFY(CELEMS(szDest) > (UINT)wsprintf(szDest, TEXT("%s%s"), szTemp, TEXT("cmexcept.cat")));
                MYVERIFY(CELEMS(szSource) > (UINT)wsprintf(szSource, TEXT("%s%s"), g_szProfileSourceDir, TEXT("cmexcept.cat")));
        
                MYVERIFY(CopyFile(szSource, szDest, FALSE)); // FALSE == bFailIfExists


                //
                //  Check to see if we need to uninstall a previous CM exception inf
                //  and uninstall it as necessary.
                //
                hrTemp = UninstallExistingCmException();
                MYDBGASSERT((S_OK == hrTemp) || (S_FALSE == hrTemp));

                //
                //  Finally, install the CM bits
                //
                hrTemp = InstallWhistlerCmOnWin2k(szTemp);

                if (FAILED(hrTemp))
                {
                    if (!bSilent)
                    {
                        MYVERIFY(0 != LoadString(hInstance, IDS_WIN2K_CM_INSTALL_FAILED, szTemp, CELEMS(szTemp)));
                        
                        MessageBox(NULL, szTemp, szServiceName, MB_OK | MB_ICONEXCLAMATION);
                    }                
                }
                else
                {
                    //
                    //  Make sure to set permissions on the registry keys to avoid issues with non Admins uninstalling
                    //  the CM binaries.  If user's have permissions to the uninstall registry keys but not to
                    //  files in system32 we can get ourselves in a wierd state.  Fix this by locking down the reg permissions.
                    //
                    hrTemp = SetPermissionsOnWin2kExceptionUninstallRegKeys();
                    MYVERIFY(SUCCEEDED(hrTemp));
                }
            }
            else
            {
                //
                //  Okay, we need to copy the instcm.inf file to the cmbins dir and then
                //  call InstallCm
                //
                LPCTSTR ArrayOfFileNames[] = {
                                                TEXT("cnet16.dll"),
                                                TEXT("ccfg95.dll"),
                                                TEXT("cmutoa.dll"),
                                                TEXT("instcm.inf") // instcm.inf must be last so it is given to InstallCm correctly.
                };

                for (int i = 0; i < (sizeof(ArrayOfFileNames)/sizeof(LPCTSTR)); i++)
                {
                    MYVERIFY(CELEMS(szDest) > (UINT)wsprintf(szDest, TEXT("%s%s"), szTemp, ArrayOfFileNames[i]));
                    MYVERIFY(CELEMS(szSource) > (UINT)wsprintf(szSource, TEXT("%s%s"), g_szProfileSourceDir, ArrayOfFileNames[i]));
            
                    MYVERIFY(CopyFile(szSource, szDest, FALSE)); // FALSE == bFailIfExists
                }

                hrTemp = InstallCm(hInstance, szDest);
            }

            MYDBGASSERT(SUCCEEDED(hrTemp));
            bMustReboot = ((HRESULT)ERROR_SUCCESS_REBOOT_REQUIRED == hrTemp) ? TRUE: bMustReboot;
        }
        else
        {
            CMASSERTMSG(FALSE, TEXT("InstallInf -- ExtractCmBinsFromExe failed!"));
        }
    }

    //
    //  Now Create the Connectoid. Even if it fails, continue to install. 
    //
    if (GetPhoneBookPath(szInstallDir, &pszPhonebook, bInstallForAllUsers))
    {
       BOOL bReturn = WriteCmPhonebookEntry(szServiceName, pszPhonebook, szCmsFile);

       if (!bReturn && plat.IsAtLeastNT5())
       {
           CMASSERTMSG(FALSE, TEXT("CMSTP Failed to create a pbk entry on NT5, exiting."));
           hrReturn = E_FAIL;
           goto exit;      
       }

       if (bInstallForAllUsers && plat.IsAtLeastNT5())
       {        
           MYVERIFY(AllowAccessToWorld(pszPhonebook));
       }
    }
    else if (plat.IsAtLeastNT5())
    {
        CMASSERTMSG(FALSE, TEXT("CMSTP Failed to get a pbk path on NT5, exiting."));
        hrReturn = E_FAIL;
        goto exit;
    }

    //
    //  Now we have all the files installed and the pbk entry written,
    //  finally create the desktop shortcut/GUID
    //
    if ((plat.IsWin9x()) || (plat.IsNT4()))
    {
        //
        //  If we have a Legacy install, then we need to create a desktop icon
        //
        if  (!bNoLegacyIcon)
        {
            hrTemp = LaunchInfSection(szInfFile, TEXT("Xnstall_Legacy"), szTitle, bSilent);
            MYDBGASSERT(SUCCEEDED(hrTemp));
            bMustReboot = ((HRESULT)ERROR_SUCCESS_REBOOT_REQUIRED == hrTemp) ? TRUE: bMustReboot;
        }
    }
    else
    {
        //
        //  Create a desktop shortcut if necessary
        //
        DeleteNT5ShortcutFromPathAndName(hInstance, szServiceName, 
            bInstallForAllUsers ? CSIDL_COMMON_DESKTOPDIRECTORY : CSIDL_DESKTOPDIRECTORY);

        if (bCreateDesktopIcon)
        {
            HRESULT hr = CreateNT5ProfileShortcut(szServiceName, pszPhonebook, bInstallForAllUsers);
            MYVERIFY(SUCCEEDED(hr));
        }
    }

    //
    //  The profile is now basically installed.  Before doing any post install commands, lets check to see
    //  if the caller asked us to set this connection as the default connection.  If so, then
    //  lets set it here.
    //
    if (bSetAsDefault)
    {
        MYVERIFY(SetThisConnectionAsDefault(szServiceName));
    }

    //
    //  if we have a preshared key, give it to RAS
    //
    if (pszPresharedKey)
    {
        if (plat.IsAtLeastNT51())
        {
            pfnRasSetCredentialsSpec pfnSetCredentials;

            hrReturn = E_FAIL;

            if (FALSE == GetRasApis(NULL, NULL, NULL, NULL, NULL, &pfnSetCredentials))
            {
                CMASSERTMSG(FALSE, TEXT("CMSTP Failed to get RAS API RasSetCredentials, exiting."));
                goto exit;      
            }
        
            if (lstrlen(pszPresharedKey) > PWLEN)
            {
                CMASSERTMSG(FALSE, TEXT("preshared key is larger than RasSetCredentials can handle!"));
                goto exit;      
            }

            RASCREDENTIALS * pRasCreds = NULL;

            pRasCreds = (RASCREDENTIALS *) CmMalloc(sizeof(RASCREDENTIALS));
            if (NULL == pRasCreds)
            {
                hrReturn = E_OUTOFMEMORY;
                goto exit;
            }

            pRasCreds->dwSize = sizeof(RASCREDENTIALS);
            pRasCreds->dwMask = RASCM_PreSharedKey;
            lstrcpyn(pRasCreds->szPassword, pszPresharedKey, lstrlen(pszPresharedKey) + 1);
            
            if (0 != pfnSetCredentials(pszPhonebook, szServiceName, pRasCreds, FALSE))    // FALSE => set the credentials
            {
               CMASSERTMSG(FALSE, TEXT("CMSTP RasSetCredentials failed, exiting."));
               CmFree(pRasCreds);
               goto exit;
            }

            CmFree(pRasCreds);
            hrReturn = S_OK;
        }
        else if ((plat.IsNT4() || plat.IsWin9x()))
        {
           SafeNetLinkageStruct SnLinkage = {0};

            if (IsSafeNetClientAvailable() && LinkToSafeNet(&SnLinkage))
            {
                DATA_BLOB DataBlob = {0};
                DataBlob.cbData = (lstrlen(pszPresharedKey) + 1)*sizeof(TCHAR);
                DataBlob.pbData = (BYTE*)pszPresharedKey;
            
                if (FALSE == SnLinkage.pfnSnPolicySet(SN_L2TPPRESHR, (void*)&DataBlob))
                {
                   CMASSERTMSG(FALSE, TEXT("CMSTP SnPolicySet failed, exiting."));
                    UnLinkFromSafeNet(&SnLinkage);
                   goto exit;            
                }

                //
                //  Now call SnPolicyReload so the SafeNet driver will take the settings changes
                //
                if (FALSE == SnLinkage.pfnSnPolicyReload())
                {
                    //
                    //  Then we need to ask the user to reboot after finishing the install for the changes to take affect.
                    //
                    bMustReboot = TRUE;
                }
            }
            else
            {
                CMTRACE(TEXT("CMSTP tried to set PSK but SafeNet interface unavailable."));
            }

            UnLinkFromSafeNet(&SnLinkage);
        }
     }

    //
    //  Do any postinstall cmds here
    //
    LPTSTR pszPostInstallSection;

    if (bInstallForAllUsers)
    {
        pszPostInstallSection = TEXT("PostInstall");
    }
    else
    {
        pszPostInstallSection = TEXT("PostInstall_Single");
    }

    hrTemp = LaunchInfSection(szInfFile, pszPostInstallSection, szTitle, bSilent);
    MYDBGASSERT(SUCCEEDED(hrTemp));
    bMustReboot = ((HRESULT)ERROR_SUCCESS_REBOOT_REQUIRED == hrTemp) ? TRUE: bMustReboot;

    //
    //  Delete the temporary reg key that we used to communicate the install path to the inf
    //
    if (ERROR_SUCCESS == RegOpenKeyEx(hBaseKey, pszRegInfCommKeyPath, 
                                      0, KEY_ALL_ACCESS, &hKey))
    {
        MYVERIFY(ERROR_SUCCESS == RegDeleteValue(hKey, c_pszProfileInstallPath));
        MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
    }
    else
    {
        CMASSERTMSG(FALSE, TEXT("Unable to delete the ProfileInstallPath temporary Reg value."));
    }

    //
    //  Refresh the desktop so that any GUID or shortcut changes will appear
    //
    RefreshDesktop();

    //
    //  For Win98 and Millennium, we write an App Compatibility flag in order to
    //  fix SetForegroundWindow.  Refer also to Q135788 for more details of the
    //  original fix (which requires this extra code on Win9x to actually work).
    //
    //  This fixes Whistler bugs 41696 and 90576.
    //
    if (plat.IsWin98())
    {
        if (!WriteProfileString(TEXT("Compatibility95"), TEXT("CMMON32"), TEXT("0x00000002")))
        {
            CMTRACE(TEXT("InstallInf - failed to write app compat entry for CMMON32 to fix SetForegroundWindow"));
        }
    }

    //
    //  We are finally completed.  If we need to reboot, show the user the reboot prompt.
    //  Otherwise, show the user a completion message.
    //

    if (bMustReboot)
    {
        MYVERIFY(0 != LoadString(hInstance, IDS_REBOOT_MSG, szTemp, CELEMS(szTemp)));

        int iRes = MessageBoxEx(NULL,
                                szTemp,
                                szServiceName,
                                MB_YESNO | MB_DEFBUTTON1 | MB_ICONWARNING | MB_SETFOREGROUND,
                                LANG_USER_DEFAULT);

        if (IDYES == iRes) 
        {
            //
            // Shutdown Windows
            //
            DWORD dwReason = plat.IsAtLeastNT51() ? (SHTDN_REASON_MAJOR_APPLICATION | SHTDN_REASON_MINOR_INSTALLATION) : 0;

            MyExitWindowsEx(EWX_REBOOT, dwReason);
        }
    }
    else if (!bSilent)
    {
        //
        //  Instead of giving the user a message box, we will launch the profile
        //  for them. (NTRAID 201307)
        //

        if (plat.IsAtLeastNT5())
        {
            pCmstpMutex->Unlock();  //NTRAID 310478

        }

        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s.cmp"), 
            szInstallDir, szShortServiceName));

        LaunchProfile(szTemp, szServiceName, pszPhonebook, bInstallForAllUsers);
    }

exit:

    CmFree(pszPresharedKey);
    CmFree(pszPhonebook);
    return hrReturn;
}