windows-xp/Source/XPSP1/NT/net/rras/cm/profwiz/profwiz.cpp

//+----------------------------------------------------------------------------
//
// File:     profwiz.cpp
//
// Module:   CMAK.EXE
//
// Synopsis: Main code for CMAK
//
// Copyright (c) 1998-1999 Microsoft Corporation
//
// Author:   a-frankh   Created                         05/15/97
//           quintinb   Updated header and made a       08/07/98  
//                      few other changes
//
//+----------------------------------------------------------------------------

#include "cmmaster.h"
#include "cmsecure.h"

// linkdll is needed because of cmsecure
#include "linkdll.h" // LinkToDll and BindLinkage
#include "linkdll.cpp" // LinkToDll and BindLinkage

//
//  Include HasSpecifiedAccessToFileOrDir
//
#ifndef CreateFileU
    #ifdef UNICODE
    #define CreateFileU CreateFileW
    #else
    #define CreateFileU CreateFileA
    #endif
#endif

#include "hasfileaccess.cpp"
#include "gppswithalloc.cpp"

//
//  Globals
//

//
//  This global specifies what the return value of CMAK should be.  Note that if the user
//  cancels the wizard this value isn't used and FALSE (0) is returned by the wizard code.
//
int g_iCMAKReturnVal = CMAK_RETURN_CANCEL;

//
//  This was added for shipping with IEAK.  If the /o command line switch is specified this
//  bool is set to true and we don't show the finish dialog (either one).
//
BOOL g_bIEAKBuild = FALSE;
const TCHAR* const g_szBadFilenameChars = TEXT("!@#$%^&*(){}[]+=,;:?/\\'\"`~|<>. ");
const TCHAR* const g_szBadLongServiceNameChars = TEXT("*/\\:?\"<>|[]");
const TCHAR* const c_pszDoNotShowLcidMisMatchDialog = TEXT("DoNotShowLcidMisMatchDialog");


TCHAR g_szInfFile[MAX_PATH+1]; // full path/filename of working inf file
TCHAR g_szCmakdir[MAX_PATH+1]; // full path of working inf file (includes ending slash)
TCHAR g_szOsdir[MAX_PATH+1]; // full path of platform branch (includes ending slash)
TCHAR g_szSedFile[MAX_PATH+1]; // full path of working sed file
TCHAR g_szCmsFile[MAX_PATH+1];
TCHAR g_szCmpFile[MAX_PATH+1];
TCHAR g_szSupportDir[MAX_PATH+1]; // full path of support files are located
TCHAR g_szTempDir[MAX_PATH+1];
TCHAR g_szLastBrowsePath[MAX_PATH+1] = {0};

TCHAR g_szShortServiceName[MAX_PATH+1];
TCHAR g_szLongServiceName[MAX_PATH+1];
TCHAR g_szBrandBmp[MAX_PATH+1];
TCHAR g_szPhoneBmp[MAX_PATH+1];
TCHAR g_szLargeIco[MAX_PATH+1];
TCHAR g_szSmallIco[MAX_PATH+1];
TCHAR g_szTrayIco[MAX_PATH+1];
TCHAR g_szPhonebk[MAX_PATH+1];
TCHAR g_szRegion[MAX_PATH+1];
TCHAR g_szHelp[MAX_PATH+1];
TCHAR g_szOutdir[MAX_PATH+1];
TCHAR g_szUrl[MAX_PATH+1];
TCHAR g_szOutExe[MAX_PATH+1];
TCHAR g_szSvcMsg[MAX_PATH+1];
TCHAR g_szPrefix[MAX_PATH+1];
TCHAR g_szSuffix[MAX_PATH+1];
TCHAR g_szLicense[MAX_PATH+1];
TCHAR g_szPhoneName[MAX_PATH+1];
TCHAR g_szAppTitle[MAX_PATH+1];
TCHAR g_szCmProxyFile[MAX_PATH+1];
TCHAR g_szCmRouteFile[MAX_PATH+1];
TCHAR g_szVpnFile[MAX_PATH+1];

BOOL g_bNewProfile = TRUE;
BOOL g_bUseTunneling = FALSE;
BOOL g_bUseSamePwd = FALSE;
BOOL g_bUpdatePhonebook = FALSE;
BOOL g_bPresharedKeyNeeded = FALSE;

#ifdef _WIN64
BOOL g_bIncludeCmCode = FALSE; // don't include CM code on IA64
#else
TCHAR g_szCmBinsTempDir[MAX_PATH+1] = {0};
BOOL g_bIncludeCmCode = TRUE;
#endif

HINSTANCE g_hInstance;

ListBxList * g_pHeadDunEntry=NULL;
ListBxList * g_pTailDunEntry=NULL;

ListBxList * g_pHeadVpnEntry=NULL;
ListBxList * g_pTailVpnEntry=NULL;


ListBxList * g_pHeadProfile=NULL;
ListBxList * g_pTailProfile=NULL;
ListBxList * g_pHeadExtra=NULL;
ListBxList * g_pTailExtra=NULL;
ListBxList * g_pHeadMerge=NULL;
ListBxList * g_pTailMerge=NULL;
ListBxList * g_pHeadRefs=NULL;
ListBxList * g_pTailRefs=NULL;
ListBxList * g_pHeadRename=NULL;
ListBxList * g_pTailRename=NULL;

CustomActionList* g_pCustomActionList = NULL;

IconMenu * g_pHeadIcon;
IconMenu * g_pTailIcon;

IconMenu DlgEditItem; //global used to pass info to/from dialogs

//+----------------------------------------------------------------------------
//
// Function:  TextIsRoundTripable
//
// Synopsis:  Tests to see if the passed in text is convertables from Unicode
//            to ANSI and then back to Unicode again.  If so returns TRUE,
//            else FALSE.
//
// Arguments: LPCTSTR pszCharBuffer - string to test
//            BOOL bDisplayError - whether to display an error message or not
//                                 if the text isn't roundtripable
//
// Returns:   BOOL - TRUE if the roundtrip was success
//
// History:   quintinb Created Header    6/16/99
//
//+----------------------------------------------------------------------------
BOOL TextIsRoundTripable(LPCTSTR pszCharBuffer, BOOL bDisplayError)
{

    LPWSTR pszUnicodeBuffer = NULL;
    BOOL bRoundTrip = FALSE;

    MYDBGASSERT(pszCharBuffer);

    if (pszCharBuffer)
    {
        LPSTR pszAnsiBuffer = WzToSzWithAlloc(pszCharBuffer);

        if (pszAnsiBuffer)
        {
            pszUnicodeBuffer = SzToWzWithAlloc(pszAnsiBuffer);
            if (pszUnicodeBuffer && (0 == lstrcmp(pszCharBuffer, pszUnicodeBuffer)))
            {
                //
                //  Then we were able to round trip the strings successfully
                //  Set bRoundTrip to TRUE so that we don't throw an error.
                //
                bRoundTrip = TRUE;
            }

            CmFree(pszUnicodeBuffer);
            CmFree(pszAnsiBuffer);
        }

        if (!bRoundTrip && bDisplayError)
        {
            //
            //  Throw an error message.
            //

            LPTSTR pszTmp = CmLoadString(g_hInstance, IDS_CANNOT_ROUNDTRIP);

            if (pszTmp)
            {
                DWORD dwSize = lstrlen(pszTmp) + lstrlen(pszCharBuffer) + 1;
                LPTSTR pszMsg = (LPTSTR)CmMalloc(dwSize*sizeof(TCHAR));

                if (pszMsg)
                {
                    wsprintf(pszMsg, pszTmp, pszCharBuffer);
                    MessageBox(NULL, pszMsg, g_szAppTitle, MB_OK | MB_ICONERROR | MB_TASKMODAL);
                    CmFree(pszMsg);
                }

                CmFree(pszTmp);
            }
        }
    }

    return bRoundTrip;
}

//+----------------------------------------------------------------------------
//
// Function:  GetTextFromControl
//
// Synopsis:  This is a wrapper function that sends a WM_GETTEXT message to 
//            the control specified by the input parameters.  Once the text
//            is retrieved from the control, we convert it to ANSI and then
//            back to UNICODE so that we can compare the original Unicode 
//            string to the round-tripped string.  If these are not equal we 
//            throw an error message, if bDisplayError is TRUE, and return
//            a failure value (-1).  It is up to the caller to take appropriate
//            behavior (preventing the user from continuing, etc.)
//
// Arguments: IN HWND hDlg - HWND of the dialog the control is on
//            IN int nCtrlId - ID of the control to get text from
//            OUT LPTSTR pszCharBuffer - out buffer to hold the returned TEXT
//            IN DWORD dwCharInBuffer - numbers of chars in out buffer
//            BOOL bDisplayError - if TRUE display an error message if 
//                                 the text isn't roundtripable
//
// Returns:   LONG - the number of chars copied to the output buffer or -1 on error
//
// History:   quintinb Created     6/15/99
//
//+----------------------------------------------------------------------------
LRESULT GetTextFromControl(IN HWND hDlg, IN int nCtrlId, OUT LPTSTR pszCharBuffer, IN DWORD dwCharInBuffer, BOOL bDisplayError)
{
    LRESULT lResult = 0;

    if (hDlg && nCtrlId && pszCharBuffer && dwCharInBuffer)
    {
        lResult = SendDlgItemMessage(hDlg, nCtrlId, WM_GETTEXT, (WPARAM)dwCharInBuffer, (LPARAM)pszCharBuffer);
#ifdef UNICODE
        //
        //  We want to make sure that we can convert the strings to MBCS.  If we cannot then we are not
        //  going to be able to store the string in the our ANSI data files (.cms, .cmp, .inf, etc.).
        //  Thus we need to convert the string to MBCS and then back to UNICODE.  We will then compare the original
        //  string to the resultant string and see if they match.
        //
        
        if (TEXT('\0') != pszCharBuffer[0])
        {
            if (!TextIsRoundTripable(pszCharBuffer, bDisplayError))
            {
                //
                //  Set the return code to an error value.
                //

                lResult = -1;
            }
        }
#endif
    }
    else
    {
        CMASSERTMSG(FALSE, TEXT("Bad Parameter passed to GetTextFromControl!"));
    }

    return lResult;
}

//+----------------------------------------------------------------------------
//
// Function:  FreeIconMenu
//
// Synopsis:  This function frees the linked list of status area menu icons.
//
// Arguments: None
//
// Returns:   Nothing
//
// History:   quintinb Created Header    05/09/00
//
//+----------------------------------------------------------------------------
void FreeIconMenu()
{
    IconMenu * LoopPtr;
    IconMenu * TmpPtr;

    if (g_pHeadIcon == NULL)
    {
        return;
    }
    LoopPtr = g_pHeadIcon;
    while( LoopPtr != NULL)
    {
        TmpPtr = LoopPtr;
    
        LoopPtr = LoopPtr->next;

        CmFree(TmpPtr);
    }
    g_pHeadIcon = NULL;
    g_pTailIcon = NULL;
}

//+----------------------------------------------------------------------------
//
// Function:  ReferencedDownLoad
//
// Synopsis:  This function opens each referenced cms file to check and see if it has a
//            PBURL.  If so, then this files is considered to do PB downloads and should
//            cause the top level profile to run the cmdl connect action. 
//
// Arguments: None
//
// Returns:   BOOL - returns whether referenced profiles need cmdl
//
// History:   quintinb Created    2/2/98
//
//+----------------------------------------------------------------------------
BOOL ReferencedDownLoad()
{
    ListBxList * ptrMergeProfile = NULL;
    TCHAR szRefCmsFile[MAX_PATH+1];
    TCHAR szPbUrl[MAX_PATH+1];
    
    if (NULL == g_pHeadMerge)
    {
        return FALSE;
    }
    else
    {
        //
        //  Enumerate the referenced profiles to try to find one that has a PBURL field.
        //

        ptrMergeProfile = g_pHeadMerge;
        
        while (NULL != ptrMergeProfile)
        {
            //
            //  Let's try the profile directory for the merged profile in order to get the most up to date version.  This
            //  is where CMAK will pull it from if available.  If not, we will fall back to the one in the temp directory.
            //
            MYVERIFY(CELEMS(szRefCmsFile) > (UINT)wsprintf(szRefCmsFile, TEXT("%s%s\\%s.cms"), g_szOsdir, ptrMergeProfile->szName, ptrMergeProfile->szName));

            if (!FileExists(szRefCmsFile))
            {
                //
                //  Next check to see if the merged cms file exists in the temp dir
                //
                MYVERIFY(CELEMS(szRefCmsFile) > (UINT)wsprintf(szRefCmsFile, TEXT("%s\\%s.cms"), g_szTempDir, ptrMergeProfile->szName));
            }

            GetPrivateProfileString(c_pszCmSectionIsp, c_pszCmEntryIspUrl, TEXT(""), szPbUrl, MAX_PATH, szRefCmsFile);     //lint !e534

            if (TEXT('\0') != szPbUrl[0])
            {
                //
                //  Only takes one phonebook with a URL to enable referenced downloads
                //

                return TRUE;
            }

            ptrMergeProfile = ptrMergeProfile->next;
        }

    }

    return FALSE;
}


//+----------------------------------------------------------------------------
//
// Function:  SetWindowLongWrapper
//
// Synopsis:  This function is an error checking wrapper for the Windows API
//            SetWindowLong.  This function returns the value that is being 
//            overwritten by this call (if you set a the window long to a value
//            you are overwriting the previous value that it contained.  This
//            previous value is the value returned by the API).  If there is an
//            error then this function returns 0.  However, the previous value
//            could have been 0.  The only way to distinguish the two cases (an 
//            actual error and the previous value being zero) is to call SetLastError
//            with a zero value.  Then you can call GetLastError after the call and if
//            the returned error code isn't zero then we know we have an error.  All
//            of this functionality is combined in this function.
//
// Arguments: HWND hWnd - handle of window to set the long var in
//            int nIndex - offset of value to set
//            LONG dwNewLong - new value 
//
// Returns:   BOOL - Returns TRUE if the call succeeded
//
// History:   quintinb Created    1/7/98
//
//+----------------------------------------------------------------------------
BOOL SetWindowLongWrapper(HWND hWnd, int nIndex, LONG dwNewLong )
{
    DWORD dwError;

    SetLastError(0);
    SetWindowLongPtr(hWnd, nIndex, (LONG_PTR)dwNewLong); //lint !e534
    dwError = GetLastError();

    return (0 == dwError);

}
 
//+---------------------------------------------------------------------------
//
//  Function:       CopyFileWrapper
//
//  Synopsis:       Bundles disk full Error Handling with standard CopyFile functionality
//          
//  Arguments:      lpExistingFileName -- source file of copy
//                  lpNewFileName -- destination file of copy
//                  bFailIfExists -- flag to tell copy to fail if file already exists
//  
//  Assumptions:    This function assumes that the two filename parameters contain the
//                  fully qualified path to the source and destination files.
//                      
//  Returns:        TRUE if copy was sucessful, FALSE on an error
//
//  History:        quintinb    created     11/7/97
//
//----------------------------------------------------------------------------

BOOL CopyFileWrapper(LPCTSTR lpExistingFileName, LPCTSTR lpNewFileName, BOOL bFailIfExists)
{

    DWORD dwError;
    int nMessageReturn = 0;
    TCHAR szMsg[2*MAX_PATH+1];
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szPath[MAX_PATH+1];

    do {

        if (!CopyFile(lpExistingFileName, lpNewFileName, bFailIfExists))
        {
            //
            //  The CopyFile failed, best check error codes
            //

            dwError = GetLastError();

            switch(dwError)
            {

            case ERROR_HANDLE_DISK_FULL:
            case ERROR_DISK_FULL:

                if (0 == GetFilePath(lpNewFileName, szPath))
                {
                    _tcscpy(szPath, lpNewFileName);
                }

                MYVERIFY(0 != LoadString(g_hInstance, IDS_DISKFULL, szTemp, MAX_PATH));
                MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szTemp, szPath));

                nMessageReturn = MessageBox(NULL, szMsg, g_szAppTitle, MB_RETRYCANCEL | MB_ICONERROR 
                    | MB_TASKMODAL);
                if (nMessageReturn != IDRETRY)
                {
                    return FALSE;
                }
                break;

            default:
                //
                //  Replaces the functionality of the FileAccessErr function so all the file
                //  errors are trapped in one place.  This function still exits for special 
                //  cases.
                //
                MYVERIFY(0 != LoadString(g_hInstance, IDS_NOACCESS, szTemp, MAX_PATH));
                
                MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szTemp, lpNewFileName));

                MessageBox(NULL ,szMsg, g_szAppTitle, MB_OK | MB_ICONERROR | MB_TASKMODAL 
                    | MB_TOPMOST );

                return FALSE;
            }
        } else {
            nMessageReturn = 0;
        }

    } while (IDRETRY == nMessageReturn);

    return TRUE;

}

//+---------------------------------------------------------------------------
//
//  Function:       CheckDiskSpaceForCompression
//
//  Synopsis:       Checks to see if there is sufficient disk space for compressing
//                  the files listed in the passed in sed file.  To do this, uses a simplistic
//                  algorithm of adding up the disk space used by all the files listed in the 
//                  strings section of the SED file, under the FILE<num> entries.  If there is 
//                  at least dwBytes (space taken up by all the files in the SED) of space left 
//                  on the partition containing the SED file, then the function returns true.
//                  Otherwise false is returned, indicating that there may not be enough space left.
//          
//  Arguments:      szSed -- the full path to the SED file to look for filenames in
//                          
//  Returns:        TRUE if sufficient space to continue, FALSE if not sure or probably
//                  not enough
//
//  Assumptions:    That the partition we are checking for diskspace on is the partition of
//                  the current directory.
//
//  History:        quintinb    created     11/10/97
//
//----------------------------------------------------------------------------
BOOL CheckDiskSpaceForCompression (LPCTSTR szSed)
{
    TCHAR szKey[MAX_PATH+1];
    TCHAR szFileName[MAX_PATH+1];
    DWORD dwBytes = 0;
    DWORD dwChars;
   
    //
    //  Calculate the amount of space taken up by the files listed in the SED
    //
    int nCount = 0;
    
    do 
    {       
        MYVERIFY(CELEMS(szKey) > (UINT)wsprintf(szKey, TEXT("FILE%d"), nCount));

        dwChars = GetPrivateProfileString(c_pszInfSectionStrings, szKey, TEXT(""), 
                                                szFileName, MAX_PATH, szSed);
        
        if (0 != dwChars)
        {
            HANDLE hFile = CreateFile(szFileName, GENERIC_READ, FILE_SHARE_READ, 
                                      NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

            if (INVALID_HANDLE_VALUE != hFile)
            {
                dwBytes += GetFileSize(hFile, NULL);
                MYVERIFY(0 != CloseHandle(hFile));
            }
        }

        nCount++;
    } while (0 != dwChars); 

    //
    // Now that we know how much space the files in the SED take up, we should see how much space is on
    // the partition.
    //
    DWORD dwFreeClusters;
    DWORD dwBytesPerSector;
    DWORD dwSectorsPerCluster;
    DWORD dwTotalClusters;
    DWORD dwModulus;
    if (GetDiskFreeSpace(NULL, &dwSectorsPerCluster, &dwBytesPerSector, 
                         &dwFreeClusters, &dwTotalClusters))
    {
        //
        // Because dwSectorsPerCluster*dwBytesPerSector*dwFreeClusters could very easily
        // overflow a 32 bit value, we will calculate the total size of the files to compress
        // in clusters (dwBytes/(dwSectorsPerCluster*dwBytesPerSector)) and compare 
        // against the dwFreeClusters value.
        //
        DWORD dwSizeInSectors = dwBytes / dwBytesPerSector;
        dwModulus = dwBytes % dwBytesPerSector;

        if (dwModulus)
        {
            dwSizeInSectors++; //  we want to round up if it didn't divide evenly
        }

        DWORD dwSizeInClusters = dwSizeInSectors / dwSectorsPerCluster;
        dwModulus = dwSizeInSectors % dwSectorsPerCluster;

        if (dwModulus)
        {
            dwSizeInClusters++; //  we want to round up if it didn't divide evenly
        }

        if (dwFreeClusters > dwSizeInClusters)
        {
            return TRUE;
        }
        else
        {
            return FALSE;
        }
    }
    else
    {
        return FALSE;
    }

}

//+----------------------------------------------------------------------------
//
// Function:  ProcessBold
//
// Synopsis:  This function makes the IDC_LBLTITLE static text control bold
//            on the WM_INITDIALOG message and releases the bold on WM_DESTROY.
//            This function is usually placed at the top of a window procedure
//            so that these messages are handled automatically.  Note that the
//            function doesn't otherwise affect the processing of these messages
//            by the original window procedure.
//
// Arguments: HWND hDlg - dialog window handle to process messages for
//            UINT message - message to handle
//
// Returns:   Nothing
//
// History:   quintinb Created Header    05/09/00
//
//+----------------------------------------------------------------------------
void ProcessBold(HWND hDlg, UINT message)
{
    switch (message)
    {
        case WM_INITDIALOG: 
            MYVERIFY(ERROR_SUCCESS == MakeBold(GetDlgItem(hDlg, IDC_LBLTITLE), TRUE));
            break;

        case WM_DESTROY:
            MYVERIFY(ERROR_SUCCESS == ReleaseBold(GetDlgItem(hDlg, IDC_LBLTITLE)));
            break;
        default:
            break;
    }
}

//+---------------------------------------------------------------------------
//
//  Function:   SetDefaultGUIFont
//
//  Synopsis:   Sets the font of the control to be the Default GUI Font.
//
//  Arguments:  hwnd - Window handle of the dialog
//              message - message from the dialog box procedure
//              cltID - ID of the control you want changed.
//
//  Returns:    ERROR_SUCCESS
// 
//  History:    4/31/97 a-frankh    Created
//              quintinb  Renamed from ProcessDBCS and cleaned up 
//----------------------------------------------------------------------------
void SetDefaultGUIFont(HWND hDlg, UINT message, int ctlID)
{
    HFONT hFont = NULL;

    switch (message)
    {
        case WM_INITDIALOG:
            hFont = (HFONT) GetStockObject(DEFAULT_GUI_FONT);

            if (hFont == NULL)
            {
                hFont = (HFONT) GetStockObject(SYSTEM_FONT);
            }

            if (hFont != NULL)
            {
                SendMessage(GetDlgItem(hDlg, ctlID), WM_SETFONT, (WPARAM) hFont, MAKELPARAM(TRUE, 0)); //lint !e534 WM_SETFONT doesn't return anything
            }

            break;
        default:
            break;
    }

}

//+----------------------------------------------------------------------------
//
// Function:  IsAlpha
//
// Synopsis:  Determines if the current platform is Alpha.
//
// Arguments: None
//
// Returns:   static BOOL - TRUE if the current platform is Alpha
//
// History:   nickball    Created    10/11/97
//
//+----------------------------------------------------------------------------
static BOOL IsAlpha()
{
    SYSTEM_INFO sysinfo;

    ZeroMemory(&sysinfo, sizeof(sysinfo));
    GetSystemInfo(&sysinfo);

    return (sysinfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_ALPHA);
}

//+----------------------------------------------------------------------------
//
// Function:  ShowMessage
//
// Synopsis:  Simple helper function to handle message display
//
// Arguments: HWND hDlg - Parent window handle
//            int strID - Resource ID of the string to be displayed
//            int mbtype - The type of messagebox (MB_OK, etc.)
//
// Returns:   static int - User response to message box
//
// History:   nickball    Created Header    10/11/97
//            quintinb    Changed strID and mbtype to UINTs for LINT 1-5-98
//            quintinb    Change to use CmLoadString  6/17/99 
//
//+----------------------------------------------------------------------------
int ShowMessage(HWND hDlg, UINT strID, UINT mbtype)
{
    int iReturn = 0;

    LPTSTR pszMsg = CmLoadString(g_hInstance, strID);
    
    if (pszMsg)
    {
        iReturn = MessageBox(hDlg, pszMsg, g_szAppTitle, mbtype);
    }

    CmFree(pszMsg);

    return iReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  GetFileName
//
// Synopsis:  Get just the filename from a full path and filename
//
// Arguments: LPCTSTR lpPath    - Ptr to the full name and path
//            LPTSTR lpFileName - Ptr to the buffer the hold the extracted name
//
// Returns:   Nothing
//
// History:   nickball    Created Header    10/11/97
//            quintinb    modified to fix bug with URL's  7-15-98
//
//+----------------------------------------------------------------------------
void GetFileName(LPCTSTR lpPath, LPTSTR lpFileName)
{
    LPTSTR pch;

    pch = _tcsrchr(lpPath, _T('\\'));
    if (NULL == pch)
    {
        //
        //  Catch paths like c:temp.inf
        //
        if (_istalpha(lpPath[0]) && (_T(':') == lpPath[1])) //lint !e732
        {
            pch = (TCHAR*)&(lpPath[1]);
        }
    }

    if (NULL == pch)
    {
        _tcscpy(lpFileName, lpPath);
    }
    else
    {
        pch = CharNext(pch);
        _tcscpy(lpFileName, pch);
    }
}
//+----------------------------------------------------------------------------
//
// Function:  GetFilePath
//
// Synopsis:  Get just the full path from a full path and filename
//
// Arguments: LPCTSTR lpFullPath    - Ptr to the full name and path
//            LPTSTR lpPath - Ptr to the buffer the hold the extracted path
//
// Returns:   either 0 or the number of chars copied into the return buffer
//
// History:   quintinb   Created        11/11/97    
//
//+----------------------------------------------------------------------------
int GetFilePath(LPCTSTR lpFullPath, LPTSTR lpPath)
{
    LPTSTR pch;

    _tcscpy(lpPath, lpFullPath);

    // first find the last \ char in the
    // string

    pch = _tcsrchr(lpPath,_T('\\'));

    // if this is null, look for a path similar to
    // c:junk

    if (pch == NULL)
    {
        pch = _tcsrchr(lpPath,_T(':'));
        if (NULL != pch)
        {
            pch = CharNext(pch);
            _tcscpy(pch, TEXT("\\"));
            pch = CharNext(pch);
            *pch = TEXT('\0');
            return _tcslen(lpPath);
        } else {
            lpPath[0] = TEXT('\0');
            return 0;
        }
    } else {
        *pch = TEXT('\0');
        return _tcslen(lpPath);

    }
}

//+----------------------------------------------------------------------------
//
// Function:  GetName
//
// Synopsis:  Extracts filename from a full path and file name and returns a p
//            tointer to the result.
//
// Arguments: LPCTSTR lpPath - Ptr to the full name and path
//
// Returns:   LPTSTR - Ptr to the static buffer containing the result of the extraction.
//
// History:   nickball    Created Header    10/11/97
//
//+----------------------------------------------------------------------------
LPTSTR GetName(LPCTSTR lpPath) 
{
    static TCHAR szStr[MAX_PATH+1];
    GetFileName(lpPath,szStr);
    return szStr;
}

BOOL GetShortFileName(LPTSTR lpFile, LPTSTR lpShortName)
{
    HANDLE hFile;
    WIN32_FIND_DATA FindData;
    TCHAR szPath[MAX_PATH+1];

    GetFileName(lpFile,lpShortName);
    hFile = FindFirstFile(lpFile,&FindData);
    if (hFile == INVALID_HANDLE_VALUE)
    {
        //
        // Not found, try looking from OS dir as the root, because 
        // the filename may be a relative path from a CMS file entry.
        //
        
        MYVERIFY(0 != GetCurrentDirectory(MAX_PATH,szPath));
        MYVERIFY(0 != SetCurrentDirectory(g_szOsdir));

        hFile = FindFirstFile(lpFile,&FindData);
        MYVERIFY(0 != SetCurrentDirectory(szPath));
    }

    if (hFile != INVALID_HANDLE_VALUE)
    {
        if (*FindData.cAlternateFileName)
        {
            if (_tcsicmp(lpShortName,FindData.cAlternateFileName) != 0)
            {
                _tcscpy(lpShortName,FindData.cAlternateFileName);
            }
        }
        MYVERIFY(0 != FindClose(hFile));
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

//+----------------------------------------------------------------------------
//
// Function:  GetBaseName
//
// Synopsis:  Extracts the base filename (no extension) from a full filename 
//            and path
//
// Arguments: LPTSTR lpPath - The full path and filename
//            LPTSTR lpFileName - The buffer to receive the extracted base name.
//
// Returns:   Nothing
//
// History:   nickball    Created Header    10/11/97
//
//+----------------------------------------------------------------------------
void GetBaseName(LPTSTR lpPath,LPTSTR lpFileName)
{
    LPTSTR pch;

    GetFileName(lpPath, lpFileName);

    pch = _tcsrchr(lpFileName, _T('.'));

    if (pch)
    {
        *pch = TEXT('\0');
    }
}

//+----------------------------------------------------------------------------
//
// Function:  FileAccessErr
//
// Synopsis:  Helper function that handles notification of a file access error
//
// Arguments: HWND hDlg - Parent window handle
//            LPTSTR lpFile - The file that caused the access error.
//
// Returns:   static void - Nothing
//
// History:   nickball    Created Header    10/11/97
//
//+----------------------------------------------------------------------------
static void FileAccessErr(HWND hDlg,LPCTSTR lpFile)
{
    TCHAR szMsg[MAX_PATH+1];
    TCHAR szTemp2[2*MAX_PATH+1];

    MYVERIFY(0 != LoadString(g_hInstance,IDS_NOACCESS,szMsg,MAX_PATH));                 
    MYVERIFY(CELEMS(szTemp2) > (UINT)wsprintf(szTemp2,szMsg,lpFile));
    MessageBox(hDlg, szTemp2, g_szAppTitle, MB_OK);
}

//+----------------------------------------------------------------------------
//
// Function:  VerifyFile
//
// Synopsis:    Given the ID of a dialog box edit control in ctrlID
//              Check if user entered in something different than what is contained in lpFile
//              If it is different, get the entire path and verify it exists.
//              If it doesn't exist and ShowErr = TRUE, display an error message
//              Copy the full path to lpFile if exists
//
// Arguments: HWND hDlg - Window handle of the dialog containing the edit control
//            DWORD ctrlID - edit control containing the file to check
//            LPTSTR lpFile - Filename to verify (checked against that contained in the control)
//            BOOL ShowErr - Whether to show an error message or not
//
// Returns:   BOOL - Return TRUE if the file was verified to exist
//
// History:   quintinb Created Header    1/8/98
//
//+----------------------------------------------------------------------------
BOOL VerifyFile(HWND hDlg, DWORD ctrlID, LPTSTR lpFile, BOOL ShowErr)
{
    TCHAR szMsg[MAX_PATH+1];
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szTemp2[2*MAX_PATH+1];
    TCHAR szPath[MAX_PATH+1];
    int nResult;
    LPTSTR lpfilename;
    HANDLE hInf;
    LRESULT lrNumChars;

    lrNumChars = GetTextFromControl(hDlg, ctrlID, szTemp, MAX_PATH, ShowErr); // bDisplayError == ShowErr

    //
    // don't check blank entry
    //
    if (0 == lrNumChars || 0 == szTemp[0]) 
    {
        lpFile[0] = TEXT('\0');
        return TRUE;
    }
    
    //
    //  Also check to make sure that we were able to convert the text to ANSI
    //
    if (-1 == lrNumChars)
    {
        SetFocus(GetDlgItem(hDlg, ctrlID));
        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
        return FALSE;
    }

    //
    // if filename is still the same, ignore entry box
    //
    CheckNameChange(lpFile, szTemp);

    MYVERIFY(0 != GetCurrentDirectory(MAX_PATH, szPath));

    //
    // Check current directory, if not found, check OS directory as root.
    // This handles relative paths from the CMS
    //

    nResult = SearchPath(NULL, lpFile, NULL, MAX_PATH, szTemp2, &lpfilename);
    if (!nResult)
    {
        MYVERIFY(0 != SetCurrentDirectory(g_szOsdir));
        nResult = SearchPath(NULL, lpFile, NULL, MAX_PATH, szTemp2, &lpfilename);

        if (!nResult)
        {
            goto Error;
        }
    }

    hInf = CreateFile(szTemp2, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

    MYVERIFY(0 != SetCurrentDirectory(szPath));

    if (hInf == INVALID_HANDLE_VALUE)
    {
        goto Error;
    }
    else
    {
        MYVERIFY(0 != CloseHandle(hInf));
    }
    _tcscpy(lpFile,szTemp2);

    return TRUE;

Error:
    _tcscpy(lpFile,szTemp);
    MYVERIFY(0 != SetCurrentDirectory(szPath));

    if (ShowErr)
    {
        MYVERIFY(0 != LoadString(g_hInstance, IDS_NOEXIST, szMsg, MAX_PATH));                  
        MYVERIFY(CELEMS(szTemp2) > (UINT)wsprintf(szTemp2, szMsg, szTemp));
        MessageBox(hDlg, szTemp2, g_szAppTitle, MB_OK);
        SetFocus(GetDlgItem(hDlg, ctrlID));

        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
    }
    return FALSE;

}

// If has entry but file doesn't exist, blank out entry.
BOOL VerifyPhonebk(HWND hDlg,DWORD ctrlID,LPTSTR lpFile)
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szTemp2[MAX_PATH+1];
    TCHAR szPath[MAX_PATH+1];
    int nResult;
    LPTSTR lpfilename;
    HANDLE hInf;
    LRESULT lrNumChars;

    //
    //  If the text is not convertable to ANSI then we will catch it on the Next/Back.  Thus
    //  don't try to catch it here, would throw too many error messages at the user.
    //
    lrNumChars = GetTextFromControl(hDlg, ctrlID, szTemp, MAX_PATH, FALSE); // bDisplayError == FALSE

    // don't check blank entry
    if (0 == lrNumChars || 0 == szTemp[0]) 
    {
        lpFile[0] = 0;
        return TRUE;
    }

    // if filename is still the same, don't check
    CheckNameChange(lpFile,szTemp);

    MYVERIFY(0 != GetCurrentDirectory(MAX_PATH,szPath));

    MYVERIFY(0 != SetCurrentDirectory(g_szOsdir));

    nResult = SearchPath(NULL,lpFile,NULL,MAX_PATH,szTemp2,&lpfilename);
    
    if (!nResult)
    {
        goto Error;
    }

    hInf = CreateFile(szTemp2,GENERIC_READ,0,NULL,OPEN_EXISTING,
                      FILE_ATTRIBUTE_NORMAL,NULL);

    MYVERIFY(0 != SetCurrentDirectory(szPath));

    if (hInf == INVALID_HANDLE_VALUE)
    {
        goto Error;
    }
    else
    {
        MYVERIFY(0 != CloseHandle(hInf));
    }
    _tcscpy(lpFile,szTemp2);
//  SendMessage(GetDlgItem(hDlg, ctrlID), WM_SETTEXT, 0, (LPARAM)lpFile);
    return TRUE;
Error:

    lpFile[0] = TEXT('\0');
    MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, ctrlID), WM_SETTEXT, 0, (LPARAM)lpFile));
    return FALSE;

}

// If user entered in a new filename, copy it to lpnew

void CheckNameChange(LPTSTR lpold, LPTSTR lpnew)
{
    //
    // if filename changed or if new name contains directories, copy new to old
    //
    if ((_tcsicmp(GetName(lpold), lpnew) != 0) || (_tcschr(lpnew, TEXT('\\')) != NULL))
    {
        _tcscpy(lpold, lpnew);
    }
}

//+----------------------------------------------------------------------------
//
// Function:  WriteRegStringValue
//
// Synopsis:  Wrapper function to encapsulate opening a key for write access and
//            then setting a string value.  Assumes the string is NULL terminated.
//
// Arguments: HKEY hBaseKey - base key, HKCU/HKLM/etc.
//            LPCTSTR pszKeyName - subkey name
//            LPCTSTR pszValueName - Value name to write
//            LPCTSTR pszValueToWrite - Value data string to write
//
// Returns:   BOOL - TRUE if successful
//
// History:   quintinb Created    6/15/99
//
//+----------------------------------------------------------------------------
BOOL WriteRegStringValue(HKEY hBaseKey, LPCTSTR pszKeyName, LPCTSTR pszValueName, LPCTSTR pszValueToWrite) 
{
    HKEY hKey;
    DWORD dwSize;
    BOOL bReturn = FALSE;

    if (hBaseKey && pszKeyName && pszValueName && pszValueToWrite &&
        TEXT('\0') != pszKeyName[0] && TEXT('\0') != pszValueName[0]) // pszValueToWrite could be empty
    {

        LONG lReturn = RegOpenKeyEx(hBaseKey, pszKeyName, 0, KEY_WRITE, &hKey);

        if (ERROR_SUCCESS == lReturn) 
        {
            dwSize = (lstrlen(pszValueToWrite) +1)*sizeof(TCHAR);

            lReturn = RegSetValueEx(hKey, pszValueName, 0, REG_SZ, (LPBYTE)pszValueToWrite, dwSize);
            if (ERROR_SUCCESS == lReturn)
            {
                bReturn = TRUE;
            }

            RegCloseKey(hKey);
        }
    }

    return bReturn;
}


// check to see if the original CMAK installtion directory exists and
// contains the language directories.

//+----------------------------------------------------------------------------
//
// Function:  EraseTempDir
//
// Synopsis:  This function deletes all the files in the tempdir (stored in the global g_szTempDir)
//            then changes directories to the CMAK dir (stored in the global g_szCmakdir).  From
//            there the temp dir is deleted.
//
// Arguments: None
//
// Returns:   BOOL - TRUE if the temp dir was deleted
//
// History:   quintinb Created Header    1/5/98
//            quintinb changed return type to a BOOL
//
//+----------------------------------------------------------------------------
BOOL EraseTempDir()
{
    SHFILEOPSTRUCT FileOp;
    ZeroMemory(&FileOp, sizeof(SHFILEOPSTRUCT));

    //
    //  First save a copy of the file
    //
    FileOp.wFunc = FO_DELETE;
    FileOp.pFrom = g_szTempDir;
    FileOp.fFlags = FOF_NOERRORUI | FOF_SILENT | FOF_NOCONFIRMATION;

    int iRet = SHFileOperation (&FileOp); // return 0 on success

    return (iRet ? FALSE : TRUE); 
}

// copies service profile information from the CMAK directory to the 
// temporary directory

static BOOL CopyToTempDir(LPTSTR szName)
{
    HANDLE hCopyFileSearch;
    WIN32_FIND_DATA FindData;
    BOOL bCopyResult;
    TCHAR szTemp[MAX_PATH+1];

    MYVERIFY(0 != SetCurrentDirectory(g_szCmakdir));
    if (!CreateDirectory(g_szTempDir,NULL))
    {
        return FALSE;
    }
    
    if (TEXT('\0') == szName[0])
    {
        return TRUE;
    }

    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s%s"), g_szOsdir, szName));

    if (!SetCurrentDirectory(szTemp))
    {
        return FALSE;
    }

    hCopyFileSearch = FindFirstFile(c_pszWildCard,&FindData);
    if (hCopyFileSearch != INVALID_HANDLE_VALUE)
    {
        do
        {
            if ((FindData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) == 0)
            {
                MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s"), g_szTempDir, FindData.cFileName));
                
                //
                // CLEAN OUT ANY READ ONLY ATTRIBUTES
                //
                MYVERIFY(0 != SetFileAttributes(FindData.cFileName,FILE_ATTRIBUTE_NORMAL));
                
                if (!CopyFileWrapper(FindData.cFileName,szTemp,FALSE))
                {
                    return FALSE;
                }

            }

            bCopyResult = FindNextFile(hCopyFileSearch,&FindData);

        } while (TRUE == bCopyResult);
    }

    MYVERIFY(0 != FindClose(hCopyFileSearch));
    
    return TRUE;
}



//+----------------------------------------------------------------------------
//
// Function:  GetInfVersion
//
// Synopsis:  Opens the inf file and tries to get the InfVersion key from the CMAK Status
//            section.  If the inf file doesn't contain a version stamp then we know it is 
//            version 0 (1.0 and 1.1 releases).
//
// Arguments: LPTSTR szFullPathToInfFile - the full path the the inf file to get the version of
//
// Returns:   int - returns the version value or zero if one wasn't found.
//
// History:   quintinb Created    3/4/98
//
//+----------------------------------------------------------------------------
int GetInfVersion(LPTSTR szFullPathToInfFile)
{
    if ((NULL == szFullPathToInfFile) || (TEXT('\0') == szFullPathToInfFile[0]))
    {
        CMASSERTMSG(FALSE, TEXT("GetInfVersion -- Invalid InfPath Input."));
        return FALSE;
    }

    return ((int)GetPrivateProfileInt(c_pszCmakStatus, c_pszInfVersion, 0, szFullPathToInfFile));
}

//+----------------------------------------------------------------------------
//
// Function:  WriteInfVersion
//
// Synopsis:  Opens the inf file and writes the current INF file version to the Cmak Status section.
//
// Arguments: LPTSTR szFullPathToInfFile - the full path the the inf file to get the version of
//
// Returns:   Returns TRUE if able to write the value
//
// History:   quintinb Created    3/4/98
//
//+----------------------------------------------------------------------------
BOOL WriteInfVersion(LPTSTR szFullPathToInfFile, int iVersion)
{
    TCHAR szTemp[MAX_PATH+1];

    if ((NULL == szFullPathToInfFile) || (TEXT('\0') == szFullPathToInfFile[0]))
    {
        CMASSERTMSG(FALSE, TEXT("WriteInfVersion -- Invalid InfPath Input."));
        return FALSE;
    }

    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%d"), iVersion));

    return (0 != WritePrivateProfileString(c_pszCmakStatus, c_pszInfVersion, szTemp, szFullPathToInfFile));
}



//+----------------------------------------------------------------------------
//
// Function:  UpgradeInf
//
// Synopsis:  This function upgrades and INF from an older version to the current
//            version.
//
// Arguments: LPCTSTR szRenamedInfFile - Filename to save the old INF to
//            LPCTSTR szFullPathToInfFile - Profile INF file
//
// Returns:   BOOL - TRUE if successful
//
// History:   quintinb Created Header    7/31/98
//
//+----------------------------------------------------------------------------
BOOL UpgradeInf(LPCTSTR szRenamedInfFile, LPCTSTR szFullPathToInfFile)
{
    SHFILEOPSTRUCT FileOp;
    TCHAR szTemp[MAX_PATH+1];
    DWORD dwSize;
    TCHAR* pszBuffer = NULL;
    
    const int NUMSECTIONS = 3;
    const TCHAR* const aszSectionName[NUMSECTIONS] = 
    {
        c_pszCmakStatus,
        c_pszExtraFiles,
        c_pszMergeProfiles
    };
    
    const int NUMKEYS = 4;
    const TCHAR* const aszKeyName[NUMKEYS] = 
    {
        c_pszCmEntryServiceName,
        c_pszShortSvcName,
        c_pszUninstallAppTitle,
        c_pszDesktopIcon
    };


    ZeroMemory(&FileOp, sizeof(SHFILEOPSTRUCT));

    //
    //  First save a copy of the file
    //
    FileOp.wFunc = FO_COPY;
    FileOp.pFrom = szFullPathToInfFile;
    FileOp.pTo = szRenamedInfFile;
    FileOp.fFlags = FOF_NOERRORUI | FOF_SILENT | FOF_NOCONFIRMATION;

    if (0 != SHFileOperation (&FileOp))
    {
        return FALSE;
    }
    
    //
    //  First Copy the template.inf from the lang dir so that we have something to work from
    //

    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s"), g_szSupportDir, c_pszTemplateInf));
    MYVERIFY(FALSE != CopyFileWrapper(szTemp, szFullPathToInfFile, FALSE));
    MYVERIFY(0 != SetFileAttributes(szFullPathToInfFile, FILE_ATTRIBUTE_NORMAL));

    //
    //  now migrate the [CMAK Status], [Extra Files], [Merge Profiles] sections
    //

    for (int i=0; i < NUMSECTIONS; i++)
    {
        pszBuffer = GetPrivateProfileSectionWithAlloc(aszSectionName[i], szRenamedInfFile);
        
        if (pszBuffer)
        {
            MYVERIFY(0 != WritePrivateProfileSection(aszSectionName[i], pszBuffer, szFullPathToInfFile));
        }
    }

    //
    //  Free the allocated Buffer
    //
    CmFree(pszBuffer);
    pszBuffer = NULL;

    //
    //  Migrate the ServiceName, ShortSvcName, DesktopGUID, UninstallAppTitle, DesktopIcon values
    //  from the strings section.
    //

    for (i=0; i < NUMKEYS; i++)
    {
    
        dwSize = GetPrivateProfileString(c_pszInfSectionStrings, aszKeyName[i], TEXT(""), szTemp, MAX_PATH, szRenamedInfFile);
        
        if (0 != dwSize)
        {
            MYVERIFY(0 != WritePrivateProfileString(c_pszInfSectionStrings, aszKeyName[i], szTemp, szFullPathToInfFile));
        }
    }

    //
    //  Special Case for the Desktop GUID.  We always write Quotes around the GUID and these get 
    //  stripped by the reading routine.  Thus we need to add them back.
    //
    dwSize = GetPrivateProfileString(c_pszInfSectionStrings, c_pszDesktopGuid, TEXT(""), szTemp, MAX_PATH, szRenamedInfFile);
        
    if (0 != dwSize)
    {
        QS_WritePrivateProfileString(c_pszInfSectionStrings, c_pszDesktopGuid, szTemp, szFullPathToInfFile);
    }

    //  The follwing sections should get rewritten and won't need to be migrated.
    //  [Xnstall.AddReg.Icon]
    //  [RegisterOCXSection], [Xnstall.CopyFiles], [Xnstall.CopyFiles.SingleUser],  [Xnstall.CopyFiles.ICM], 
    //  [Remove.DelFiles.ICM], [SourceDisksFiles], [Xnstall.RenameReg],
    //  [Remove.DelFiles]

    return TRUE;

}

//+----------------------------------------------------------------------------
//
// Function:  EnsureInfIsCurrent
//
// Synopsis:  This function does whatever processing is necessary to upgrade the inf from
//            its current version to the current version of CMAK itself.
//
// Arguments: HWND hDlg - window handle of the dialog box for modal messagebox purposes.
//            LPTSTR szFullPathToInfFile - the full path the the inf file to get the version of
//
// Returns:   BOOL - return TRUE if the inf was successfully upgraded, otherwise FALSE
//
// History:   quintinb Created   3/4/98
//
//+----------------------------------------------------------------------------
BOOL EnsureInfIsCurrent(HWND hDlg, LPTSTR szFullPathToInfFile)
{

    int iInfVersion;
    TCHAR szRenamedInfFile[2*MAX_PATH+1];
    TCHAR szTitle[2*MAX_PATH+1];
    TCHAR szMsg[2*MAX_PATH+1];
    TCHAR szTemp[MAX_PATH+1];
    BOOL bUpgradeProfile = FALSE;

    if ((NULL == szFullPathToInfFile) || (TEXT('\0') == szFullPathToInfFile[0]))
    {
        CMASSERTMSG(FALSE, TEXT("EnsureInfIsCurrent -- Invalid InfPath Input."));
        return FALSE;
    }

    iInfVersion = GetInfVersion(szFullPathToInfFile);

    ZeroMemory(szRenamedInfFile, sizeof(szRenamedInfFile));

    MYVERIFY(CELEMS(szRenamedInfFile) > (UINT)wsprintf(szRenamedInfFile, TEXT("%s.bak"), 
        szFullPathToInfFile));

    //
    //  We want to upgrade the inf if the Profile versions don't match.  We also have
    //  a special case to handle upgrading NT5 Beta3 (and IEAK) profiles to NT5 RTM
    //  profiles.  In order to fix NTRAID 323721 and 331446, the inf format had to change
    //  slightly thus we need to make sure to upgrade these profiles.  We will use any
    //  cmdial32.dll build prior to 2055 as needing this fix.  If version == 4 and the BuildNumber
    //  doesn't exist we assume it is a new profile.  Thus don't upgrade.
    //
    const DWORD c_dwBuild2080 = ((2080 << c_iShiftAmount) + VER_PRODUCTBUILD_QFE);
    DWORD dwProfileBuildNumber = (DWORD)GetPrivateProfileInt(c_pszSectionCmDial32, c_pszVerBuild, 
                                                             (c_dwBuild2080 + 1), szFullPathToInfFile);

    bUpgradeProfile = (iInfVersion != PROFILEVERSION) || 
                      ((4 == iInfVersion) && (c_dwBuild2080 > dwProfileBuildNumber));

    //
    //  Always grab most of the information out of the template so that we get the correct language
    //  info.
    //
    if (bUpgradeProfile)
    {
        MYVERIFY(0 != LoadString(g_hInstance, IDS_MUST_UPGRADE_INF, szTitle, 2*MAX_PATH));  // temporarily use szTitle
        GetFileName(szRenamedInfFile, szTemp);
        MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szTitle, szTemp));

        MYVERIFY(IDOK == MessageBox(hDlg, szMsg, g_szAppTitle, MB_OK | MB_APPLMODAL));
        return UpgradeInf(szRenamedInfFile, szFullPathToInfFile);
    }

    return TRUE;
}


BOOL CopyFromTempDir(LPTSTR szName)
{
    HANDLE hCopyFileSearch;
    WIN32_FIND_DATA FindData;
    BOOL bCopyResult;
    TCHAR szSource[MAX_PATH+1];
    TCHAR szDest[MAX_PATH+1];    
    TCHAR szOut[MAX_PATH+1];

    //
    // Create profile directory
    // 

    MYVERIFY(CELEMS(szOut) > (UINT)wsprintf(szOut, TEXT("%s%s"), g_szOsdir, szName));

    if (0 == SetCurrentDirectory(szOut))
    {
        MYVERIFY(0 != CreateDirectory(szOut,NULL));
    }

    MYVERIFY(0 != SetCurrentDirectory(g_szTempDir));

    hCopyFileSearch = FindFirstFile(c_pszWildCard, &FindData);

    if (hCopyFileSearch != INVALID_HANDLE_VALUE)
    {
        do
        {
            if (0 == (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
            {
                MYVERIFY(CELEMS(szDest) > (UINT)wsprintf(szDest, TEXT("%s\\%s"), szOut, FindData.cFileName));

                MYVERIFY(CELEMS(szSource) > (UINT)wsprintf(szSource, TEXT("%s\\%s"), g_szTempDir, FindData.cFileName));
            
                if (!CopyFileWrapper(szSource, szDest, FALSE))
                {
                    return FALSE;
                }
            }
            
            bCopyResult = FindNextFile(hCopyFileSearch, &FindData);

        } while (bCopyResult == TRUE);
    }

    MYVERIFY(0 != FindClose(hCopyFileSearch));

    return TRUE;
}

//+----------------------------------------------------------------------------
//
// Function:  LoadServiceProfiles
//
// Synopsis:  This function loads all the service profiles in the subdirectories
//            of the current directory (thus you set this to c:\program files\cmak\profiles-32
//            to have it load the normal profiles).  The profiles are loaded into
//            CMAK's internal linked list of available profiles to edit.
//
// Arguments: None
//
// Returns:   Nothing 
//
// History:   quintinb Created Header    6/24/98
//            quintinb removed two boolean arguments    6/24/98
//
//+----------------------------------------------------------------------------
void LoadServiceProfiles()
{
    WIN32_FIND_DATA FindData;
    HANDLE hFileSearch;
    HANDLE hCms;
    BOOL bResult;
    TCHAR szTemp[MAX_PATH+1];

    hFileSearch = FindFirstFile(c_pszWildCard,&FindData);
    if (hFileSearch != INVALID_HANDLE_VALUE)
    {
        do
        {
            if ((FindData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) != 0)
            {
                MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s.cms"), 
                    FindData.cFileName, FindData.cFileName));
                //
                // If we can open the file, add a record to our profile list
                //
                
                hCms = CreateFile(szTemp,GENERIC_READ,0,NULL,OPEN_EXISTING,
                                  FILE_ATTRIBUTE_NORMAL,NULL);
                if (hCms != INVALID_HANDLE_VALUE)
                {
                    MYVERIFY(0 != CloseHandle(hCms));                
                    MYVERIFY(FALSE != createListBxRecord(&g_pHeadProfile, &g_pTailProfile, (void *)NULL, 0, FindData.cFileName));
                }
            }

            bResult = FindNextFile(hFileSearch, &FindData);

        } while (TRUE == bResult);

        MYVERIFY(0 != FindClose(hFileSearch));
    }
}

//+---------------------------------------------------------------------------
//
//  Function:   CopyNonLocalProfile
//
//  Synopsis:   Helper function to handle details of copying an external profile
//              to the local CMAK layout. 
//
//  Arguments:  pszName - The name of the profile to be copied
//                          
//  Returns:    Nothing
//
//  History:    nickball - created - 11/16/97
//              quintinb - modified to not change directory -- 6/24/98
//
//----------------------------------------------------------------------------

void CopyNonLocalProfile(LPCTSTR pszName, LPCTSTR pszExistingProfileDir)
{
    WIN32_FIND_DATA FindData;
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szProfileDestDir[MAX_PATH+1];
    TCHAR szOldInf[MAX_PATH+1];
    TCHAR szFindFilePath[MAX_PATH+1];
    TCHAR szTempDest[MAX_PATH+1];
    BOOL bCopyResult;
    HANDLE hCopyFileSearch;
    
    //
    // First determine if it exists already, we don't want to overwrite
    //

    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s%s\\%s\\%s.cms"), g_szCmakdir, 
        c_pszProfiles, pszName, pszName));

    if (!FileExists(szTemp))
    {
        //  
        // Profile does not exist locally, create profile and platform sub-dirs
        //

        MYVERIFY(CELEMS(szProfileDestDir) > (UINT)wsprintf(szProfileDestDir, 
            TEXT("%s%s\\%s"), g_szCmakdir, c_pszProfiles, pszName));

        MYVERIFY(0 != CreateDirectory(szProfileDestDir, NULL));

        //
        //  First try to copy the inf from the system directory.  This is the old location.
        //  If it doesn't exist here, then we will pick it up when we copy the profile directory, so
        //  don't report an error on failure.
        //      

        MYVERIFY(0 != GetSystemDirectory(szTemp, CELEMS(szTemp)));
        MYVERIFY(CELEMS(szOldInf) > (UINT)wsprintf(szOldInf, TEXT("%s\\%s.inf"), 
            szTemp, pszName));
        
        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s.inf"), 
            szProfileDestDir, pszName));

        
        if (FileExists(szOldInf))
        {
            MYVERIFY(0 != CopyFile(szOldInf, szTemp, FALSE));
        }

        //
        // Start copying files
        //

        MYVERIFY (CELEMS(szFindFilePath) > (UINT)wsprintf(szFindFilePath, TEXT("%s\\*.*"), 
            pszExistingProfileDir));

        hCopyFileSearch = FindFirstFile(szFindFilePath, &FindData);
        if (hCopyFileSearch != INVALID_HANDLE_VALUE)
        {
            do
            {
                if ((FindData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) == 0)
                {
                    MYVERIFY (CELEMS(szTempDest) > (UINT)wsprintf(szTempDest, TEXT("%s\\%s"), szProfileDestDir, FindData.cFileName));

                    MYVERIFY (CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s"), pszExistingProfileDir, FindData.cFileName));

                    MYVERIFY(0 != CopyFile(szTemp, szTempDest, FALSE));
                    MYVERIFY(0 != SetFileAttributes(szTempDest, FILE_ATTRIBUTE_NORMAL));
                }

                bCopyResult = FindNextFile(hCopyFileSearch,&FindData);

            } while (TRUE == bCopyResult);

            MYVERIFY(0 != FindClose(hCopyFileSearch));
        }

        //4404 - don't copy .cmp with user information in it. always create new.
    }
}




//+----------------------------------------------------------------------------
//
// Function:  GetProfileDirAndShortSvcNameFromCmpFilePath
//
// Synopsis:  
//
// Arguments: IN LPCTSTR szCmpFileLocation - Cmp File location of the profile
//            OUT LPTSTR pszShortServiceName - returns the ShortServiceName of the profile
//            OUT LPTSTR pszProfileDirLocation - returns the Full path to the profile dir
//            IN UINT uiStrLen - Length of the buffer pointed to by pszProfileDirLocation
//                               in characters.
//
// Returns:   TRUE if successful
//
// History:   quintinb Created    6/24/98
//
//+----------------------------------------------------------------------------
BOOL GetProfileDirAndShortSvcNameFromCmpFilePath(IN LPCTSTR pszCmpFileLocation, 
                                                 OUT LPTSTR pszShortServiceName, 
                                                 OUT LPTSTR pszProfileDirLocation, 
                                                 IN UINT uiStrLen)
{
    //
    //  Check Inputs
    //
    MYDBGASSERT(pszCmpFileLocation);
    MYDBGASSERT(pszProfileDirLocation);
    MYDBGASSERT(pszShortServiceName);
    MYDBGASSERT(0 != uiStrLen);
    MYDBGASSERT(TEXT('\0') != pszCmpFileLocation[0]);

    if ((NULL == pszCmpFileLocation) || 
        (TEXT('\0') == pszCmpFileLocation[0]) ||
        (NULL == pszProfileDirLocation) ||
        (NULL == pszShortServiceName) ||
        (0 == uiStrLen)
        )
    {
        return FALSE;
    }

    //
    //  Split the input cmp path
    //
    CFileNameParts FileParts(pszCmpFileLocation);

    //
    //  Construct the cms path from the cmp path parts
    //
    MYVERIFY(uiStrLen > (UINT)wsprintf(pszProfileDirLocation, TEXT("%s%s%s"), FileParts.m_Drive, FileParts.m_Dir, FileParts.m_FileName));

    //
    //  Short Service Names are 8.3
    //
    MYVERIFY(9 > (UINT)wsprintf(pszShortServiceName, TEXT("%s"), FileParts.m_FileName));

    return TRUE;
}

//+----------------------------------------------------------------------------
//
// Function:  CopyInstalledProfilesForCmakToEdit
//
// Synopsis:  This function finds all the installed profiles that a user has
//            access to and copies them to the CMAK\Profiles-32 directory so
//            the user may edit them in CMAK.  To do this it enumerates both
//            the HKLM and the current HKCU Connection Manager Mappings keys
//            and calls CopyNonLocalProfile on each found profile.
//
// Arguments: None
//
// Returns:   Nothing
//
// History:   quintinb Created  6/24/98
//
//+----------------------------------------------------------------------------
void CopyInstalledProfilesForCmakToEdit()
{
    HKEY hKey;
    HKEY hBaseKey;
    DWORD dwType;
    LPTSTR pszCurrentValue = NULL;
    LPTSTR pszCurrentData = NULL;
    TCHAR szShortServiceName[MAX_PATH+1];
    TCHAR szCurrentProfileDirPath[MAX_PATH+1];
    LPTSTR pszExpandedPath = NULL;

    for (int i=0; i < 2; i++)
    {
        //
        //  First Load the Single User Profiles (we want to give preference to loading these if
        //  they happen to have it installed both all user and single user)
        //        
        if (0 == i)
        {
             hBaseKey = HKEY_CURRENT_USER;
        }
        else
        {
             hBaseKey = HKEY_LOCAL_MACHINE;        
        }

        if (ERROR_SUCCESS == RegOpenKeyEx(hBaseKey, c_pszRegCmMappings, 0, KEY_ALL_ACCESS, &hKey))
        {
            DWORD dwValueBufSize = 0;
            DWORD dwDataBufSize = 0;

            //
            //  figure out how big the buffers need to be
            //
            if (ERROR_SUCCESS == RegQueryInfoKey(hKey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &dwValueBufSize, &dwDataBufSize, NULL, NULL))
            {

                //
                //  Increment the count we got back to include the terminating NULL char
                //
                dwValueBufSize++;
                dwDataBufSize += 2; // this is in bytes

                //
                //  allocate the space we need
                //
                pszCurrentValue = (LPTSTR) CmMalloc(dwValueBufSize * sizeof(TCHAR));
                pszCurrentData  = (LPTSTR) CmMalloc(dwDataBufSize);

                CMASSERTMSG(pszCurrentValue && pszCurrentData, TEXT("CopyInstalledProfilesForCmakToEdit -- CmMalloc failed allocating value and data buffers."));
                if (pszCurrentValue && pszCurrentData)
                {
                    DWORD dwIndex = 0;
                    DWORD dwValueSize = dwValueBufSize;     // only used for the in/out param
                    DWORD dwDataSize = dwDataBufSize;       // only used for the in/out param
                    
                    while (ERROR_SUCCESS == RegEnumValue(hKey, dwIndex, pszCurrentValue, &dwValueSize, NULL, &dwType, (LPBYTE)pszCurrentData, &dwDataSize))
                    {
                        if (REG_SZ == dwType)
                        {
                            MYDBGASSERT(0 != pszCurrentValue[0]);
                            MYDBGASSERT(0 != pszCurrentData[0]);
                            
                            //
                            //  Expand environment strings if necessary (single user profiles contain the 
                            //  %USERPROFILE% environment var).
                            //
                            DWORD dwDataSizeExpanded = ExpandEnvironmentStrings(pszCurrentData, NULL, 0);

                            CMASSERTMSG((dwDataSizeExpanded != 0),
                                TEXT("CopyInstalledProfilesForCmakToEdit -- Error expanding environment vars."));

                            if (dwDataSizeExpanded)
                            {
                                pszExpandedPath = (LPTSTR) CmMalloc(dwDataSizeExpanded * sizeof(TCHAR));

                                if (NULL != pszExpandedPath)
                                {
                                    DWORD dwTmp = ExpandEnvironmentStrings(pszCurrentData, pszExpandedPath, dwDataSizeExpanded);
                                    MYDBGASSERT(dwTmp == dwDataSizeExpanded);

                                    if (dwTmp)
                                    {
                                        MYVERIFY(0 != GetProfileDirAndShortSvcNameFromCmpFilePath(pszExpandedPath, 
                                            szShortServiceName, szCurrentProfileDirPath,
                                            CELEMS(szCurrentProfileDirPath)));

                                        MYDBGASSERT(0 != szCurrentProfileDirPath[0]);
                                        MYDBGASSERT(0 != szShortServiceName[0]);

                                        CopyNonLocalProfile(szShortServiceName, szCurrentProfileDirPath);
                                    }

                                    CmFree(pszExpandedPath);
                                }
                            }
                        }

                        dwValueSize = dwValueBufSize;
                        dwDataSize = dwDataBufSize;
                        dwIndex++;
                    }

                    CmFree(pszCurrentValue);
                    CmFree(pszCurrentData);
                }
            }
            MYVERIFY(ERROR_SUCCESS == RegCloseKey(hKey));
        }
    }
}




//+----------------------------------------------------------------------------
//
// Function:  GetLangFromInfTemplate
//
// Synopsis:  Wrote to replace GetLangFromDir.  This function gets the LCID value
//            from an inf and then calls GetLocaleInfo to get the Language Display
//            name.
//
// Arguments: LPCTSTR szFullInfPath - full path to the inf file
//            OUT LPTSTR pszLanguageDisplayName - out param to hold the display name of the LCID value
//            IN int iCharsInBuffer - number of chars in the out buffer
//
// Returns:   BOOL - TRUE if successful
//
// History:   quintinb  Created Header    8/8/98
//
//+----------------------------------------------------------------------------
BOOL GetLangFromInfTemplate(LPCTSTR szFullInfPath, OUT LPTSTR pszLanguageDisplayName, IN int iCharsInBuffer)
{
    TCHAR szTemp[MAX_PATH+1] = TEXT("");

    MYDBGASSERT(NULL != szFullInfPath);
    MYDBGASSERT(TEXT('\0') != szFullInfPath[0]);
    MYDBGASSERT(NULL != pszLanguageDisplayName);
    MYDBGASSERT(0 < iCharsInBuffer);

    if (FileExists(szFullInfPath))
    {
        //
        //  First check for the new LCID location under strings, we shouldn't need to
        //  check both places because it is template.inf but we will anyway just for
        //  completeness.
        //
        if (0 == GetPrivateProfileString(c_pszInfSectionStrings, c_pszCmLCID, 
                                         TEXT(""), szTemp, CELEMS(szTemp), szFullInfPath))
        {        
            //
            //  If the new key didn't exist, then try the old [Intl] section and
            //  display key.  The change was made during the CMAK Unicode changes to
            //  make the inf template easier to localize.
            //
            MYVERIFY(0 != GetPrivateProfileString(c_pszIntl, c_pszDisplay, 
                TEXT(""), szTemp, CELEMS(szTemp), szFullInfPath));
        }

        //
        //  Now try to extract the LCID from the string if we have one.
        //
        if (TEXT('\0') != szTemp[0])
        {
            //
            // This value should be an LCID so a negative value is invalid anyway
            //
            DWORD dwLang = (DWORD)_ttol(szTemp);
            
            int nResult = GetLocaleInfo(dwLang, LOCALE_SLANGUAGE | LOCALE_USE_CP_ACP, 
                pszLanguageDisplayName, iCharsInBuffer);

            if (0 == nResult)
            {
                ZeroMemory(pszLanguageDisplayName, sizeof(TCHAR)*iCharsInBuffer);
                return FALSE;
            }
            else
            {
                return TRUE;
            }
        }    
    }
    else
    {
        CMTRACE1(TEXT("GetLangFromInfTemplate can't find %s"), szFullInfPath);
    }

    return FALSE;
}

//+----------------------------------------------------------------------------
//
// Function:  GetLocalizedLanguageNameFromLCID
//
// Synopsis:  This function returns the language name of the given LCID in the
//            language of the current system default language.
//
// Arguments: DWORD dwLCID - Locale Identifier to get the language for
//
// Returns:   LPTSTR - returns NULL if unsuccessful, a pointer to the string
//                     otherwise.  The Caller is responsible for CmFree-ing it.
//
// History:   quintinb Created     6/17/99
//
//+----------------------------------------------------------------------------
LPTSTR GetLocalizedLanguageNameFromLCID(DWORD dwLCID)
{
    LPTSTR pszReturnString = NULL;
    LPTSTR pszTmp = NULL;

    if (dwLCID)
    {
        int nCharsNeeded = GetLocaleInfo(dwLCID, LOCALE_SLANGUAGE, NULL, 0);
        pszTmp = (LPTSTR)CmMalloc(nCharsNeeded*sizeof(TCHAR) + sizeof(TCHAR)); // one extra for the NULL

        if (pszTmp)
        {
            nCharsNeeded = GetLocaleInfo(dwLCID, LOCALE_SLANGUAGE, pszTmp, nCharsNeeded);
            if (0 != nCharsNeeded)
            {
                pszReturnString = pszTmp;        
            }
        }
    }

    return pszReturnString;
}

  
//+----------------------------------------------------------------------------
//
// Function:  GetDoNotShowLcidMisMatchDialogRegValue
//
// Synopsis:  This function gets the registry key value which stores whether
//            the user has checked the box on the Lcids don't match dialog
//            displayed by CMAK which says, "Don't show this dialog again".
//
//
// Arguments: None
//
// Returns:   BOOL - TRUE if cmak should NOT show the dialog or FALSE if it should
//
// History:   quintinb Created     03/22/2001
//
//+----------------------------------------------------------------------------
BOOL GetDoNotShowLcidMisMatchDialogRegValue()
{
    BOOL bReturn = FALSE;
    HKEY hKey;

    LONG lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, c_pszRegCmak, 0, KEY_READ, &hKey);

    if (ERROR_SUCCESS == lResult)
    {
        DWORD dwType = 0;
        DWORD dwDoNotShowDialog = 0;
        DWORD dwSize = sizeof(DWORD);

        lResult = RegQueryValueEx(hKey, c_pszDoNotShowLcidMisMatchDialog, NULL, &dwType, 
                                  (LPBYTE)&dwDoNotShowDialog, &dwSize);
                
        if (ERROR_SUCCESS == lResult)
        {
            bReturn = (BOOL)dwDoNotShowDialog;
        }

        RegCloseKey(hKey);
    }

    return bReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  SetDoNotShowLcidMisMatchDialogRegValue
//
// Synopsis:  This function sets the registry key value which stores whether
//            the user has checked the box on the Lcids don't match dialog
//            displayed by CMAK which says, "Don't show this dialog again".
//
//
// Arguments: DWORD dwValueToSet - TRUE or FALSE value that should be set in reg
//
// Returns:   BOOL - TRUE if the value was set successfully, FALSE otherwise
//
// History:   quintinb Created     03/22/2001
//
//+----------------------------------------------------------------------------
BOOL SetDoNotShowLcidMisMatchDialogRegValue(DWORD dwValueToSet)
{
    HKEY hKey;
    BOOL bReturn = FALSE;

    LONG lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, c_pszRegCmak, 0, KEY_WRITE, &hKey);

    if (ERROR_SUCCESS == lResult)
    {
        lResult = RegSetValueEx(hKey, c_pszDoNotShowLcidMisMatchDialog, NULL, REG_DWORD, 
                                  (LPBYTE)&dwValueToSet, sizeof(DWORD));
                
        if (ERROR_SUCCESS == lResult)
        {
            bReturn = TRUE;
        }

        RegCloseKey(hKey);
    }

    return bReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessLCIDsDontMatchPopup
//
// Synopsis:  Processes windows messages for the dialog which tells the user they
//            have a mismatch between the system locale and the language of CMAK
//            itself.  Note that we pass in a pointer to the message string containing
//            the language names through the lParam parameter.
//
// Arguments: WND hDlg - dialog window handle
//            UINT message - message identifier
//            WPARAM wParam - wParam Value 
//            LPARAM lParam - lParam Value
//
//
// History:   quintinb  Created     03/22/01
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessLCIDsDontMatchPopup(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    DWORD dwChecked = 0;
    SetDefaultGUIFont(hDlg, message, IDC_MSG);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_LCID_POPUP)) return TRUE;

    switch (message)
    {
        case WM_INITDIALOG:

            //
            //  We need to set the text passed through the lParam parameter
            //  to the IDC_MSG control.
            //
            if (lParam)
            {
                LPTSTR pszMsg = (LPTSTR)lParam;
                MYVERIFY(TRUE == SendDlgItemMessage (hDlg, IDC_MSG, WM_SETTEXT, (WPARAM)0, (LPARAM)pszMsg));
            }

            break;
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDOK: // Continue

                    //
                    //  Get the value of the "Do not show me this dialog again", checkbox
                    //  and save it to the registry
                    //
                    dwChecked = IsDlgButtonChecked(hDlg, IDC_CHECK1);
                    MYVERIFY(FALSE != SetDoNotShowLcidMisMatchDialogRegValue(dwChecked));

                    MYVERIFY(0 != EndDialog(hDlg, IDOK));
                    return TRUE;
                    break;

                case IDCANCEL: // Cancel
                    MYVERIFY(0 != EndDialog(hDlg, IDCANCEL));
                    return TRUE;
                    break;

                default:
                    break;
            }
            break;

        default:
            return FALSE;
    }
    return FALSE;   
}

//+----------------------------------------------------------------------------
//
// Function:  DisplayLcidsDoNotMatchDialog
//
// Synopsis:  This function handles the details of displaying the Lcids don't
//            match dialog.  Including such details as checking the registry
//            key to see if the user has already seen the message and asked
//            not to see it again, loading the proper string resources, displaying
//            the dialog, and processing the user's answer.
//
//
// Arguments: HINSTANCE hInstance - Instance handle for resources
//            DWORD dwCmakNativeLCID - LCID of CMAK itself
//            DWORD dwSystemDefaultLCID - current system LCID
//
// Returns:   BOOL - TRUE if cmak should continue, FALSE if it should exit
//
// History:   quintinb Created     03/26/2001
//
//+----------------------------------------------------------------------------
BOOL DisplayLcidsDoNotMatchDialog(HINSTANCE hInstance, DWORD dwCmakNativeLCID, DWORD dwSystemDefaultLCID)
{
    //
    //  If we are in here, then the CMAK LCID and the Default System LCID
    //  have a different Primary language (Japanese vs English for instance).
    //  Thus we want to warn the user that they can continue but that the
    //  language version of CM is potentially going to be different than the
    //  language version of the text that they are typing into the profile.
    //  It would probably be a better user experience to use the native version 
    //  of CMAK that makes the language you have set as your default locale.
    //  First, however, we need to check to see if a registry value exists which
    //  tells us the user has already seen the dialog and asked not to see it again...
    //

    BOOL bReturn = TRUE;

    if (FALSE == GetDoNotShowLcidMisMatchDialogRegValue())
    {
        //
        //  Get the Language Names of the Two LCIDs (sys default and CMAK lang)
        //
        LPTSTR pszSystemLanguage = GetLocalizedLanguageNameFromLCID(dwSystemDefaultLCID);
        LPTSTR pszCmakLanguage = GetLocalizedLanguageNameFromLCID(dwCmakNativeLCID);
        LPTSTR pszFmtString = CmLoadString(hInstance, IDS_LCIDS_DONT_MATCH);

        if (pszSystemLanguage && pszCmakLanguage && pszFmtString)
        {
            LPTSTR pszMsg = (LPTSTR)CmMalloc(sizeof(TCHAR)*(lstrlen(pszSystemLanguage) + 
                                             lstrlen(pszCmakLanguage) + lstrlen(pszFmtString) + 1));

            if (pszMsg)
            {
                wsprintf(pszMsg, pszFmtString, pszSystemLanguage, pszCmakLanguage);

                INT_PTR nResult = DialogBoxParam(NULL, MAKEINTRESOURCE(IDD_LCIDS_DONT_MATCH_POPUP), NULL, 
                                                 (DLGPROC)ProcessLCIDsDontMatchPopup,(LPARAM)pszMsg);

                if (IDCANCEL == nResult)
                {
                    bReturn = FALSE;
                }

                CmFree(pszMsg);
            }
        }

        CmFree(pszSystemLanguage);
        CmFree(pszCmakLanguage);
        CmFree(pszFmtString);
    }

    return bReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  CheckLocalization
//
// Synopsis:  This function checks to make sure that the current default 
//            system language has a default ANSI code page and that the
//            CMAK Native language (what it is localized to) and the current
//            default system language are in the same language family.  If there
//            is no default ANSI code page or the LCIDs of CMAK and the system
//            don't match, then we throw an error message.
//
//
// Arguments: HINSTANCE hInstance - Instance handle for resources
//
// Returns:   BOOL - TRUE if cmak should continue, FALSE if it should exit
//
// History:   quintinb Created     6/25/99
//
//+----------------------------------------------------------------------------
BOOL CheckLocalization(HINSTANCE hInstance)
{
    TCHAR szTemp[MAX_PATH+1];
    BOOL bReturn = TRUE;

    //
    //  Check localization requirements.  We want to make sure that the current system 
    //  default language has an ANSI code page, otherwise we are not going to be
    //  able to convert the Unicode text that the user types in to anything that we
    //  can store in our ANSI text data store (ini files).
    //  

    DWORD dwSystemDefaultLCID = GetSystemDefaultLCID();
    CMTRACE1(TEXT("CheckLocalization -- System Default LCID is %u"), dwSystemDefaultLCID);

    GetLocaleInfo(dwSystemDefaultLCID, LOCALE_IDEFAULTANSICODEPAGE, szTemp, CELEMS(szTemp));
    DWORD dwAnsiCodePage = CmAtol(szTemp);

    if (0 == dwAnsiCodePage)
    {
        //
        //  Then this LCID has no ANSI code page and we need to throw an error.  The user
        //  will not be able to create a profile without an ANSI codepage of some sort.
        //        
        int iReturn = ShowMessage(NULL, IDS_NO_ANSI_CODEPAGE, MB_YESNO);

        if (IDNO == iReturn)
        {
            return FALSE;
        }
    }
    else
    {
        //
        //  We have an ANSI codepage, very good.  We want to check and see if the current language the
        //  user is using is different from that of CMAK itself.  If so, then we need to tell the user
        //  that the language they are entering and the language of the CM bits are different.  While this
        //  is okay, it may not provide the experience they are looking for.
        //
        
        //
        //  Get the CMAK Native LCID
        //
        CmakVersion CmakVer;
        DWORD dwCmakNativeLCID = CmakVer.GetNativeCmakLCID();
        BOOL bSeenDialog = FALSE;

        //
        //  Compare the Primary Lang IDs of the language that CMAK is in and the language
        //  the system locale is set to (this tells us what code page is loaded.
        //
        if (!ArePrimaryLangIDsEqual(dwCmakNativeLCID, dwSystemDefaultLCID))
        {
            bReturn = DisplayLcidsDoNotMatchDialog(hInstance, dwCmakNativeLCID, dwSystemDefaultLCID);
            bSeenDialog = TRUE;
        }

        //
        //  Now load the Native CMAK LCID from the CMAK resources.  If this doesn't match
        //  what we got from above we know MUI is involved and we still could have a problem
        //  as the user may be entering text in a different language then what we are expecting.
        //
        if (!bSeenDialog)
        {
            MYVERIFY(0 != LoadString(hInstance, IDS_NATIVE_LCID, szTemp, CELEMS(szTemp)));
            dwCmakNativeLCID = CmAtol(szTemp);

            if (!ArePrimaryLangIDsEqual(dwCmakNativeLCID, dwSystemDefaultLCID))
            {
                bReturn = DisplayLcidsDoNotMatchDialog(hInstance, dwCmakNativeLCID, dwSystemDefaultLCID);
            }
        }
    }

    return bReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  WinMain
//
// Synopsis:  Main function for CMAK.  Basically does some initialization and
//            then launches the wizard.
//
//
// History: quintinb on 8/26/97:  made changes to fix bug 10406, see below  
//          quintinb  Created new style Header    3/29/98
//
//+----------------------------------------------------------------------------
int APIENTRY WinMain(
    HINSTANCE, //hInstance
    HINSTANCE, //hPrevInstance
    LPSTR, //lpCmdLine
    int nCmdShow
    )
{
    LPTSTR lpfilename;
    int nresult;
    TCHAR szSaveDir[MAX_PATH+1];
    TCHAR szTemp[2*MAX_PATH+1];
    HWND hwndPrev;
    HWND hwndChild;
    BOOL bTempDirExists; // added by quintinb, please see comment below
    HINSTANCE hInstance = GetModuleHandle(NULL);
    LPTSTR lpCmdLine = GetCommandLine();
    DWORD dwFlags;
    INITCOMMONCONTROLSEX InitCommonControlsExStruct = {0};

    g_hInstance = hInstance;

    //
    //  Process Command Line Arguments
    //
    ZeroMemory(szTemp, sizeof(szTemp));
    const DWORD c_dwIeakBuild = 0x1;
    ArgStruct Args;

    Args.pszArgString = TEXT("/o");
    Args.dwFlagModifier = c_dwIeakBuild;

    {   // Make sure ArgProcessor gets destructed properly and we don't leak mem

        CProcessCmdLn ArgProcessor(1, (ArgStruct*)&Args, TRUE, 
            TRUE); //bSkipFirstToken == TRUE, bBlankCmdLnOkay == TRUE

        if (ArgProcessor.GetCmdLineArgs(lpCmdLine, &dwFlags, szTemp, 2*MAX_PATH))
        {
            g_bIEAKBuild = dwFlags & c_dwIeakBuild;
        }
    }

    //
    // Get the name product name from resource, now we're just a lowly component.
    //

    MYVERIFY(0 != LoadString(g_hInstance, IDS_APP_TITLE, g_szAppTitle, MAX_PATH));

    // Check if already executing program by trying to set Mutex
    MYVERIFY(NULL != CreateMutex(NULL, TRUE, TEXT("spwmutex")));
    if (GetLastError() == ERROR_ALREADY_EXISTS)
    {
        // if error, then must already be in use by first instance
        hwndPrev = FindWindow(NULL, c_pszAppCaption);
        if (!hwndPrev) 
        {
            // check for error message box
            hwndPrev = FindWindow(NULL, g_szAppTitle);
            if (!hwndPrev)
            {
                return CMAK_RETURN_ERROR;
            }
        }

        // Bring up previous executing copy to the top.
        ShowWindow(hwndPrev,SW_SHOWNORMAL);
        hwndChild = GetLastActivePopup(hwndPrev);
        MYVERIFY(0 != BringWindowToTop(hwndPrev));
        if (IsIconic(hwndPrev)) 
        {
            ShowWindow(hwndPrev,SW_RESTORE);
        }
        if (hwndChild != hwndPrev) 
        {
            MYVERIFY(0 != BringWindowToTop(hwndChild));
        }

        MYVERIFY(0 != SetForegroundWindow(hwndChild));

        return CMAK_RETURN_ERROR;
    }

    // save off the current instance
    g_szPhonebk[0] = TEXT('\0');
    g_szRegion[0] = TEXT('\0');
    g_szHelp[0] = TEXT('\0');
    g_szLicense[0] = TEXT('\0');
    g_szPhoneName[0] = TEXT('\0');
    g_szCmProxyFile[0] = TEXT('\0');
    g_szCmRouteFile[0] = TEXT('\0');
    g_szVpnFile[0] = TEXT('\0');


    // SearchPath will return only the ugly filename format of the path.
    // On NT, it works
    // On 95, it returns upper case form.

    nresult = SearchPath(NULL, c_pszCmakExe, NULL, CELEMS(g_szCmakdir), g_szCmakdir, &lpfilename);
    if (nresult == 0)
    {
        FileAccessErr(NULL, c_pszCmakExe);
        return CMAK_RETURN_ERROR;
    }

    // delete the file name to leave the exe directory
    *lpfilename = TEXT('\0');

    if (ERROR_SUCCESS != RegisterBitmapClass(hInstance))
    {
        return CMAK_RETURN_ERROR;
    }

    //
    //  Make sure we have a temp directory and then create %TEMP%\cmaktemp
    //

    MYVERIFY(0 != GetCurrentDirectory(MAX_PATH, szSaveDir));

    MYVERIFY(0 != GetTempPath(CELEMS(g_szTempDir), g_szTempDir));
    // begin changes by quintinb on 8/26/97
    // added to handle bug 10406
    bTempDirExists = SetCurrentDirectory(g_szTempDir);
    if (!bTempDirExists)
    {
        // temp dir doesn't exist even though the system thinks it does,
        // so create it and everybody is happy
        MYVERIFY(0 != CreateDirectory(g_szTempDir, NULL));
    }
    // end changes by quintinb on 8/26/97
    _tcscat(g_szTempDir,TEXT("cmaktemp"));

    MYDBGASSERT(_tcslen(g_szTempDir) <= CELEMS(g_szTempDir));
    
    MYVERIFY(0 != CreateDirectory(g_szTempDir,NULL));

    //
    //  Fill in the path for the support directory, we will need it below
    //
    MYVERIFY(CELEMS(g_szSupportDir) > (UINT)wsprintf(g_szSupportDir, 
        TEXT("%s%s"), g_szCmakdir, c_pszSupport));

    //
    //  Now we need to check that we have compatible versions of cmak.exe and cmbins.exe.
    //  In the win64 case, we have no cmbins.exe so we use the native cmdial32.dll in
    //  system32.  On x86, we need to open the CM binaries cab and check the version of cmdial32.dll
    //  to ensure that they are compatible.  For instance different versions (5.0 vs 5.1)
    //  shouldn't work together.  We also don't want CMAK to work with
    //  a cmdial that is of the same version but the cmdial has a lower build number.
    //

#ifdef _WIN64
    //
    //  On Win64 we are using the native cmdial32.dll in system32
    //
    CmVersion CmDialVer;
#else
    //
    //  Extract the CM binaries from the cmbins.exe so that we can get
    //  the version number from cmdial32.dll and can get the correct version
    //  of cmstp.exe to put in the cab.
    //
    wsprintf(g_szCmBinsTempDir, TEXT("%s\\cmbins"), g_szTempDir);
    if (FAILED(ExtractCmBinsFromExe(g_szSupportDir, g_szCmBinsTempDir)))
    {
        CMASSERTMSG(FALSE, TEXT("WinMain -- ExtractCmBinsFromExe Failed."));
        return CMAK_RETURN_ERROR;
    }

    wsprintf(szTemp, TEXT("%s\\cmdial32.dll"), g_szCmBinsTempDir);

    CVersion CmDialVer(szTemp);
#endif

    CmakVersion CmakVer;

    if (CmDialVer.IsPresent())
    {
        const DWORD c_dwCmakBuildNumber = VER_PRODUCTBUILD;
        
        if ((c_dwCurrentCmakVersionNumber < CmDialVer.GetVersionNumber()))
        {
            //
            //  Then we have a newer version of CM then we know how to handle,
            //  throw an error and exit
            //
            MYVERIFY(IDOK == ShowMessage(NULL, IDS_CM_TOO_NEW, MB_OK));
            g_iCMAKReturnVal = CMAK_RETURN_ERROR;
            goto exit;
        }
        else if ((c_dwCurrentCmakVersionNumber > CmDialVer.GetVersionNumber()) || 
                ((c_dwCurrentCmakVersionNumber == CmDialVer.GetVersionNumber()) && 
                 (c_dwCmakBuildNumber > CmDialVer.GetBuildNumber())))
        {
            //
            //  Then we have a older version of CM then we need,
            //  throw an error and exit
            //
            MYVERIFY(IDOK == ShowMessage(NULL, IDS_CM_TOO_OLD, MB_OK));
            g_iCMAKReturnVal = CMAK_RETURN_ERROR;
            goto exit;
        }
    }
    else
    {
        //
        //  Then we have no CM bits, lets throw an error
        //
        MYVERIFY(IDOK == ShowMessage(NULL, IDS_NO_CM_BITS, MB_OK));
        g_iCMAKReturnVal = CMAK_RETURN_ERROR;
        goto exit;
    }

    //
    //  Setup the profiles path in Temp
    //
    g_szShortServiceName[0] = TEXT('\0');
    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s%s"), g_szCmakdir, c_pszProfiles));
    
    if (0 == SetCurrentDirectory(szTemp))
    {
        MYVERIFY(0 != CreateDirectory(szTemp, NULL));
        MYVERIFY(0 != SetCurrentDirectory(szTemp));
    }

    //
    //  We need to make sure that the user has Read/Write
    //  permissions to the Profiles directory.  Otherwise they can
    //  get themselves into the situation where they would build a
    //  whole profile and lose all of the work because they couldn't
    //  save it to the output directory (since we work out of the temp
    //  dir until we actually build the cab itself).  NTRAID 372081
    //  Also note that since this function is shared by cmdial we use
    //  function pointers (here just the function names themselves)
    //  for items that cmdial32.dll doesn't statically link to so that
    //  it can dynamically link to them but still use the same code while
    //  allowing cmak not to have to do the dynamic link.  Quirky but it
    //  works.
    //

    if (!HasSpecifiedAccessToFileOrDir(szTemp, FILE_GENERIC_READ | FILE_GENERIC_WRITE))
    {
        //
        //  Then we need to throw an error to the user and exit.
        //
        
        LPTSTR pszTmp = CmLoadString(g_hInstance, IDS_INSUFF_PERMS);

        if (pszTmp)
        {
            DWORD dwSize = lstrlen(pszTmp) + lstrlen(szTemp) + 1;
            LPTSTR pszMsg = (LPTSTR)CmMalloc(dwSize*sizeof(TCHAR));

            if (pszMsg)
            {
                wsprintf(pszMsg, pszTmp, szTemp);
                MessageBox(NULL, pszMsg, g_szAppTitle, MB_OK | MB_ICONERROR | MB_TASKMODAL);
                CmFree(pszMsg);
            }

            CmFree(pszTmp);
        }

        g_iCMAKReturnVal = CMAK_RETURN_ERROR;
        goto exit;
    }

    //
    //  Grab all the installed CM profiles and copy them
    //  to the CMAK dir so that they can be edited.
    //
    CopyInstalledProfilesForCmakToEdit();

    LoadServiceProfiles();

    //
    //  Ensure that the directory CMAK\Support exists
    //
    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s%s"), g_szCmakdir, c_pszSupport));
    
    if (0 == SetCurrentDirectory(szTemp))
    {
        MYVERIFY(IDOK == ShowMessage(NULL, IDS_NOLANGRES, MB_OK));
        g_iCMAKReturnVal = CMAK_RETURN_ERROR;
        goto exit;
    }

    MYVERIFY(0 != SetCurrentDirectory(szSaveDir));

    if (!CheckLocalization(g_hInstance))
    {
        g_iCMAKReturnVal = CMAK_RETURN_CANCEL;
        goto exit;
    }

    //
    //  Initialize the common controls
    //
    InitCommonControlsExStruct.dwSize = sizeof(InitCommonControlsExStruct);
    InitCommonControlsExStruct.dwICC = ICC_INTERNET_CLASSES | ICC_LISTVIEW_CLASSES;
    
    if (FALSE == InitCommonControlsEx(&InitCommonControlsExStruct))
    {
        g_iCMAKReturnVal = CMAK_RETURN_ERROR;
        goto exit;
    }

    g_pCustomActionList = new CustomActionList();

    MYVERIFY(-1 != CreateWizard(NULL));

    //
    //  Make sure to delete the CustomActionList Class, it is
    //  allocated on the custom action screen.
    //
    delete g_pCustomActionList;

exit:

    EraseTempDir();
    ExitProcess((UINT)g_iCMAKReturnVal);
    return g_iCMAKReturnVal;
                                                 
}   //lint !e715 we don't use nCmdShow, lpCmdLine, nor hPrevInstance


//+----------------------------------------------------------------------------
//
// Function:  DoBrowse
//
// Synopsis:  This function does the necessary work to pop up a Browse Common Dialog (either for
//            saving files or for opening files depending on the SaveAs flag).
//
// Arguments: WND hDlg - handle of current dialog
//            UINT IDS_FILTER - ID for display filter description
//            LPTSTR lpMask - file filter (*.ext)
//            int IDC_EDIT - ID of edit field
//            LPCTSTR lpDefExt - file filter extension (ext)
//            LPTSTR lpFile - path/filename currently selected file on input and output
//
// Returns:   Returns 1 if successful, -1 if the user hit cancel, and 0 if there was an error.
//
// History:     quintinb    8-26-97
//              Reorganized and rewrote most of this function to resolve bug # 13159.
//              Tried to keep the original variable names and style as much as possible 
//              to keep the code style the same. 
//
// 
//              quintinb    01/22/1998     changed the return value to int so that we could
//                                         return -1 on cancel and 0 on error and distinguish the
//                                         two cases.
//              quintinb    07/13/1998     changed the function prototype so that more than one filter/mask
//                                         pair could be specified.
//              quintinb    01/14/2000     Remove SaveAs functionality as it was no longer used
//
//+----------------------------------------------------------------------------
int DoBrowse(HWND hDlg, UINT* pFilterArray, LPTSTR* pMaskArray, UINT uNumFilters, int IDC_EDIT, LPCTSTR lpDefExt, LPTSTR lpFile)
{
    OPENFILENAME filedef;
    TCHAR szMsg[MAX_PATH+1];
    TCHAR szFile[MAX_PATH+1];
    TCHAR* pszFilter = NULL;
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szDir[MAX_PATH+1];
    TCHAR szFileTitle[MAX_PATH+1];
    int nResult;
    LPTSTR lpfilename;
    int iReturnValue;

    //
    //  Check Inputs
    //

    MYDBGASSERT(uNumFilters);
    MYDBGASSERT(pFilterArray);
    MYDBGASSERT(pMaskArray);

    if ((NULL == pFilterArray) ||
        (NULL == pMaskArray) ||
        (0 == uNumFilters))
    {
        return FALSE;
    }

    ZeroMemory(&filedef, sizeof(OPENFILENAME));

    szFile[0] = TEXT('\0');
    szDir[0] = TEXT('\0');

    //
    //  Allocate Memory for the Filter string
    //

    pszFilter = (TCHAR*)CmMalloc(sizeof(TCHAR)*MAX_PATH*uNumFilters);
    
    if (pszFilter)
    {
        ZeroMemory(pszFilter, sizeof(TCHAR)*MAX_PATH*uNumFilters);// REVIEW: This really isn't necessary since CmMalloc always zeros
    }
    else
    {
        CMASSERTMSG(FALSE, TEXT("DoBrowse -- CmMalloc returned a NULL pointer"));
        return FALSE;
    }

    //
    // Initialize the OPENFILENAME data structure
    //

    filedef.lStructSize = sizeof(OPENFILENAME); 
    filedef.hwndOwner = hDlg; 
    filedef.hInstance = g_hInstance;
    filedef.lpstrFilter = pszFilter;
    filedef.lpstrCustomFilter = NULL; 
    filedef.nMaxCustFilter = 0; 
    filedef.nFilterIndex = 0; 
    filedef.lpstrFile = szFile;
    filedef.nMaxFile = MAX_PATH;
    filedef.lpstrFileTitle = szFileTitle;
    filedef.nMaxFileTitle = MAX_PATH;
    filedef.lpstrInitialDir = szDir;
    filedef.lpstrTitle = szMsg;
    filedef.Flags = OFN_FILEMUSTEXIST|OFN_LONGNAMES|OFN_PATHMUSTEXIST; 
    filedef.lpstrDefExt = lpDefExt; 

    //
    // create filter string - separated by 0 and ends with 2 0's
    //

    UINT uCurrentCharInBuffer=0;
    UINT uTempChars;

    for (UINT i = 0; i < uNumFilters; i++)
    {
        uTempChars = (UINT)LoadString(g_hInstance, pFilterArray[i], szTemp, MAX_PATH);
        
        if ((MAX_PATH*uNumFilters) <= (uCurrentCharInBuffer + uTempChars))
        {   
            //
            //  We don't want to overrun the buffer
            //
            break;
        }

        _tcscpy(&(pszFilter[uCurrentCharInBuffer]), szTemp);
        uCurrentCharInBuffer += uTempChars;

        uTempChars = (UINT)_tcslen(pMaskArray[i]);

        if ((MAX_PATH*uNumFilters) <= (uCurrentCharInBuffer + uTempChars))
        {   
            //
            //  We don't want to overrun the buffer
            //
            break;
        }

        _tcscpy(&(pszFilter[uCurrentCharInBuffer + 1]), pMaskArray[i]);

        //
        //  Add 2 chars so that we get a \0 between strings.
        //
        uCurrentCharInBuffer = (uCurrentCharInBuffer + uTempChars + 2);
    }


    //
    // if a path/file passed in, find its directory and make it szDir
    //

    if (TEXT('\0') != lpFile[0])
    {
        nResult = GetFullPathName(lpFile, CELEMS(szDir), szDir, &lpfilename);

        if (nResult != 0)
        {
            if (lpfilename) // 13062
            {
                _tcscpy(szFile,lpfilename);
                *lpfilename = TEXT('\0');
            }
        }
    }

    MYVERIFY(0 != LoadString(g_hInstance, IDS_BROWSETITLE, szMsg, MAX_PATH));
        
    //
    // pop up the open dialog
    //
        
    if (GetOpenFileName((OPENFILENAME*)&filedef))
    {
        MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDIT), WM_SETTEXT, 0, (LPARAM)szFileTitle));
        _tcscpy(lpFile, szFile);

        iReturnValue = 1;
    }
    else
    {
        //
        //  If we are in this state than the user could have hit cancel or there could have
        //  been an error.  If the CommDlgExtendedError function returns 0 then we know it was
        //  just a cancel, otherwise we have an error.
        //

        if (0 == CommDlgExtendedError())
        {
           iReturnValue = -1;
        }
        else
        {
            iReturnValue = 0;
        }
    }

    CmFree(pszFilter);
    
    return iReturnValue;
}

INT_PTR APIENTRY ProcessCancel(HWND hDlg, UINT message, LPARAM lParam)
{
    int iRes;
    NMHDR* pnmHeader = (NMHDR*)lParam;

    switch (message)
    {

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {
                case PSN_QUERYCANCEL:
                    
                    iRes = ShowMessage(hDlg, IDS_CANCELWIZ, MB_YESNO);

                    if (iRes==IDYES) 
                    {
                        //
                        //  Free Up the memory we used
                        //

                        ClearCmakGlobals();
                        FreeList(&g_pHeadProfile, &g_pTailProfile);

                        EraseTempDir();
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT,FALSE));
                    }
                    else 
                    {
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT,TRUE));
                    }
                    return TRUE;

                default:
                    return FALSE;
            }
        default:
            return FALSE;
    }
}



//+----------------------------------------------------------------------------
//
// Function:  ProcessHelp
//
// Synopsis:  Processes messages that have to do with the Help button.
//
// Arguments: WND hDlg - dialog handle
//            UINT message - Message ID to process
//            LPARAM lParam - the lParam of the message
//            DWORD_PTR dwHelpId - The Help ID of the page in question 
//                                 (this is the ID that will be launched 
//                                  for a help request from this page).
//
// Returns:   BOOL - TRUE if the message was handled
//
// History:   quintinb Created Header    10/15/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessHelp(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam, DWORD_PTR dwHelpId)
{
    NMHDR* pnmHeader = (NMHDR*)lParam;

    switch (message)
    {
        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {
                case PSN_HELP:
                    HtmlHelp(hDlg, c_pszCmakOpsChm, HH_HELP_CONTEXT, dwHelpId);   //lint !e534 we don't care about the htmlhelp HWND
                    return TRUE;

                default:
                    return FALSE;
            }
            break;

        case WM_HELP:
            HtmlHelp(hDlg, c_pszCmakOpsChm, HH_HELP_CONTEXT, dwHelpId);   //lint !e534 we don't care about the htmlhelp HWND
            return TRUE;
            break;

        case WM_COMMAND:
            switch (LOWORD(wParam)) 
            {
                case IDC_HELPBUTTON:
                    HtmlHelp(hDlg, c_pszCmakOpsChm, HH_HELP_CONTEXT, dwHelpId);   //lint !e534 we don't care about the htmlhelp HWND
                    return TRUE;
                    break;
            }

        default:
            return FALSE;
    }
}



//+----------------------------------------------------------------------------
//
// Function:  ProcessWelcome
//
// Synopsis:  Welcome to the Connection Manager Administration Kit.
//
//
// History:   quintinb Created Header and renamed from ProcessPage1    8/6/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessWelcome(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{

    NMHDR* pnmHeader = (NMHDR*)lParam;
    RECT rDlg;
    RECT rWorkArea;
    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_WELCOME)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;

    switch (message)
    {
        case WM_INITDIALOG:
            if (GetWindowRect(GetParent(hDlg),&rDlg) && SystemParametersInfoA(SPI_GETWORKAREA,0,&rWorkArea,0)) 
            {
                MoveWindow(GetParent(hDlg),
                   rWorkArea.left + ((rWorkArea.right-rWorkArea.left)-(rDlg.right-rDlg.left))/2,
                   rWorkArea.top + ((rWorkArea.bottom-rWorkArea.top)-(rDlg.bottom-rDlg.top))/2,
                   rDlg.right-rDlg.left,
                   rDlg.bottom-rDlg.top,
                   FALSE);
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    break;

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_NEXT);
                    break;

                case PSN_WIZBACK:
                    break;

                case PSN_WIZNEXT:
                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

void ClearCmakGlobals(void)
{

    //
    //  Free the connect action class
    //
    delete(g_pCustomActionList);
    g_pCustomActionList = NULL;

    FreeDnsList(&g_pHeadDunEntry, &g_pTailDunEntry);
    FreeDnsList(&g_pHeadVpnEntry, &g_pTailVpnEntry);
    FreeList(&g_pHeadExtra, &g_pTailExtra);
    FreeList(&g_pHeadMerge, &g_pTailMerge);
    FreeList(&g_pHeadRefs, &g_pTailRefs);
    FreeList(&g_pHeadRename, &g_pTailRename);
    FreeIconMenu();

    g_szOutExe[0] = TEXT('\0');
    g_szCmsFile[0] = TEXT('\0');
    g_szInfFile[0] = TEXT('\0');
    g_szCmpFile[0] = TEXT('\0');
    g_szSedFile[0] = TEXT('\0');

    EraseTempDir();
    _tcscpy(g_szOutdir, g_szTempDir);

    //
    //  Reset Connect Action Intro Screen
    //
    g_bUseTunneling = FALSE;
}


BOOL EnsureProfileFileExists(LPTSTR pszOutFile, LPCTSTR szTemplateFileName, LPCTSTR szExtension, UINT uCharsInBuffer)
{
    TCHAR szTemp[MAX_PATH+1];

    MYVERIFY(uCharsInBuffer > (UINT)wsprintf(pszOutFile, TEXT("%s\\%s%s"), g_szOutdir, 
        g_szShortServiceName, szExtension));

    if (!FileExists(pszOutFile))
    {        
        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s"), 
            g_szSupportDir, szTemplateFileName));

        if (!CopyFileWrapper(szTemp, pszOutFile, FALSE))
        {
            return FALSE;
        }

        MYVERIFY(0 != SetFileAttributes(pszOutFile, FILE_ATTRIBUTE_NORMAL));

    }

    return TRUE;
}

BOOL IsNativeLCID(LPCTSTR szFullPathToInf)
{
    HANDLE hFile;
    TCHAR szName[MAX_PATH+1] = TEXT("");
    TCHAR szNativeLCID[MAX_PATH+1] = TEXT("");

    hFile = CreateFile(szFullPathToInf, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (INVALID_HANDLE_VALUE != hFile)
    {
        MYVERIFY(0 != CloseHandle(hFile));

        //
        //  First check for the new LCID location under strings
        //
        if (0 == GetPrivateProfileString(c_pszInfSectionStrings, c_pszCmLCID, 
                                         TEXT(""), szName, CELEMS(szName), szFullPathToInf))
        {        
            //
            //  If the new key didn't exist, then try the old [Intl] section and
            //  display key.  The change was made during the CMAK Unicode changes to
            //  make the inf template easier to localize.
            //
            MYVERIFY(0 != GetPrivateProfileString(c_pszIntl, c_pszDisplay, 
                TEXT(""), szName, CELEMS(szName), szFullPathToInf));
        }
        
        if (TEXT('\0') != szName[0])
        {
            //
            // This value should be an LCID so a negative value is invalid anyway
            //
            DWORD dwLang = (DWORD)_ttol(szName);
            MYDBGASSERT((long)dwLang >= 0);

            CmakVersion CmakVer;
            DWORD dwNative = CmakVer.GetNativeCmakLCID();

            MYDBGASSERT((long)dwNative >= 0);

            if (dwLang == dwNative)
            {
                return TRUE;
            }
        }
    }
    return FALSE;
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessAddEditProfile
//
// Synopsis:  Choose whether to create a new profile or edit an existing one.
//
//
// History:   quintinb  Created Header and renamed from ProcessPage1A    8/6/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessAddEditProfile(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    INT_PTR nResult;
    INT_PTR lCount;
    TCHAR szName[MAX_PATH+1];
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szMsg[MAX_PATH+1];
    TCHAR szLanguageDisplayName[MAX_PATH+1];
    NMHDR* pnmHeader = (NMHDR*)lParam;
    static LONG_PTR iCBSel = 0;

    BOOL bNameChanged;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_STARTCUST)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_COMBO1);

    switch (message)
    {
        case WM_INITDIALOG:
        RefreshComboList(hDlg, g_pHeadProfile);
        EnableWindow(GetDlgItem(hDlg, IDC_COMBO1), FALSE);

        lCount = SendDlgItemMessage(hDlg, IDC_COMBO1, CB_GETCOUNT, (WPARAM)0, (LPARAM)0);
        if ((CB_ERR != lCount) && (lCount > 0))
        {
            MYVERIFY(CB_ERR != SendDlgItemMessage(hDlg, IDC_COMBO1, CB_SETCURSEL, (WPARAM)0, (LPARAM)0));
        }

        MYVERIFY(0 != CheckRadioButton(hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO1));
        g_bNewProfile = TRUE;

        break;

        case WM_COMMAND:
            switch (LOWORD(wParam)) 
            {
                case IDC_RADIO1:    //Build a new service profile
                    g_szShortServiceName[0] = TEXT('\0');
                    EnableWindow(GetDlgItem(hDlg,IDC_COMBO1),FALSE);
                    g_bNewProfile = TRUE;
                    break;

                case IDC_RADIO2:    //Edit an existing service profile
                
                    EnableWindow(GetDlgItem(hDlg,IDC_COMBO1),TRUE);

                    lCount = SendDlgItemMessage(hDlg, IDC_COMBO1, CB_GETCOUNT, 0, (LPARAM)0);
                    
                    if ((CB_ERR != lCount) && (lCount > 0))
                    {
                        if (iCBSel > lCount)
                        {
                            iCBSel = 0;
                        }

                        MYVERIFY(CB_ERR != SendDlgItemMessage(hDlg, IDC_COMBO1, CB_SETCURSEL,
                                                              (WPARAM)iCBSel, (LPARAM)0));                       
                    }
                    g_bNewProfile = FALSE;

                    break;


                case IDC_COMBO1:
                    MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO1,IDC_RADIO2,IDC_RADIO2));

                    nResult = SendDlgItemMessage(hDlg, IDC_COMBO1, CB_GETCURSEL, 0, (LPARAM)0);

                    if (nResult != LB_ERR)
                    {
                        iCBSel = nResult;
                        MYVERIFY(CB_ERR != SendDlgItemMessage(hDlg, IDC_COMBO1, CB_GETLBTEXT, 
                            (WPARAM)iCBSel, (LPARAM)szName));
                    }
                    else
                    {
                        SendDlgItemMessage(hDlg, IDC_COMBO1, CB_SETCURSEL, 0, (LPARAM)0);   //lint !e534 this will error if no items in combo
                        nResult = SendDlgItemMessage(hDlg,IDC_COMBO1,CB_GETCURSEL,0,(LPARAM)0);
                        if (nResult != LB_ERR)
                        {
                            iCBSel = nResult;
                            MYVERIFY(CB_ERR != SendDlgItemMessage(hDlg, IDC_COMBO1, CB_GETLBTEXT, 
                                (WPARAM)nResult, (LPARAM)szName));
                        }
                        else
                        {
                            return 1;
                        }
                    }

                    EnableWindow(GetDlgItem(hDlg,IDC_COMBO1),TRUE);
                    break;

                default:
                    break;
            }
            break;


        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));


                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));
                    break;

                case PSN_WIZBACK:
                case PSN_WIZNEXT:
                    //
                    // Establish global platform path
                    //
                    MYVERIFY(CELEMS(g_szOsdir) > (UINT)wsprintf(g_szOsdir, TEXT("%s%s\\"), 
                        g_szCmakdir, c_pszProfiles));            

                    //
                    //  Create the support dir path  and get the Name of its Language
                    //
                    
                    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s%s\\%s"), 
                        g_szCmakdir, c_pszSupport, c_pszTemplateInf));
                    
                    MYVERIFY(FALSE != GetLangFromInfTemplate(szTemp, szLanguageDisplayName, 
                        CELEMS(szLanguageDisplayName)));

                    //
                    // Determine if its a new or existing profile
                    //
                    
                    if (IsDlgButtonChecked(hDlg, IDC_RADIO2) == BST_CHECKED)
                    {
                        //
                        //  Editing an existing profile
                        //

                        nResult = SendDlgItemMessage(hDlg,IDC_COMBO1,CB_GETCURSEL,0,(LPARAM)0);
                        if (nResult != LB_ERR)
                        {
                            MYVERIFY(CB_ERR != SendDlgItemMessage(hDlg, IDC_COMBO1, CB_GETLBTEXT, 
                                (WPARAM)nResult, (LPARAM)szName));
                        }
                        else
                        {
                            MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NEEDPROF, MB_OK));
                            SetFocus(GetDlgItem(hDlg, IDC_COMBO1));
                            
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));

                            return 1;
                        }
                        
                        //
                        // if already editing a profile, don't reset everything
                        // if didn't switch to another profile.
                        //
                        bNameChanged = (_tcsicmp(szName,g_szShortServiceName) != 0);
                        
                        if (bNameChanged)
                        {
                            _tcscpy(g_szShortServiceName, szName);
                            ClearCmakGlobals();
    
                            //
                            //  Okay, copy the profile files to the temp dir
                            //
                            if (!CopyToTempDir(g_szShortServiceName))
                            {                       
                                MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                                return 1;
                            }
                        }

                        //
                        //  We need to make sure that the user has Read/Write
                        //  permissions to the Profiles\<g_szShortServiceName> directory.  Otherwise 
                        //  they can get themselves into the situation where they would build a
                        //  whole profile and lose all of the work because they couldn't
                        //  save it to the output directory (since we work out of the temp
                        //  dir until we actually build the cab itself).  NTRAID 372081
                        //
                        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s%s\\%s"), g_szCmakdir, c_pszProfiles, g_szShortServiceName));
                        if (!HasSpecifiedAccessToFileOrDir(szTemp, FILE_GENERIC_READ | FILE_GENERIC_WRITE))
                        {
                            //
                            //  Then we need to throw an error to the user and exit.
                            //

                            LPTSTR pszTmp = CmLoadString(g_hInstance, IDS_INSUFF_PERMS);

                            if (pszTmp)
                            {
                                DWORD dwSize = lstrlen(pszTmp) + lstrlen(szTemp) + 1;
                                LPTSTR pszMsg = (LPTSTR)CmMalloc(dwSize*sizeof(TCHAR));

                                if (pszMsg)
                                {
                                    wsprintf(pszMsg, pszTmp, szTemp);
                                    MessageBox(NULL, pszMsg, g_szAppTitle, MB_OK | MB_ICONERROR | MB_TASKMODAL);
                                    CmFree(pszMsg);
                                }

                                CmFree(pszTmp);
                            }

                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }
                    }
                    else
                    {
                        //
                        //  Building a new profile
                        //
                        if (TEXT('\0') == g_szShortServiceName[0])
                        {
                            ClearCmakGlobals();
                            
                            if (FileExists(g_szTempDir))
                            {
                                EraseTempDir();
                            }
                            
                            MYVERIFY(0 != CreateDirectory(g_szTempDir, NULL));

                        }
                    }
                            
                    // CHECK IF .CMS .CMP .INF .SED FILES EXIST, CREATE FROM TEMPLATE IF NOT EXIST
                    // Don't do this if in the special case where we have not verified the short name.
                    
                    GetFileName(g_szCmsFile, szTemp);
                    
                    if (_tcsicmp(szTemp, TEXT(".cms")) != 0)
                    {
                        if (!EnsureProfileFileExists(g_szCmsFile, c_pszTemplateCms, TEXT(".cms"), MAX_PATH))
                        {
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }

                        if (!EnsureProfileFileExists(g_szCmpFile, c_pszTemplateCmp, c_pszCmpExt, MAX_PATH))
                        {
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }

                        if (!EnsureProfileFileExists(g_szSedFile, c_pszTemplateSed, TEXT(".sed"), MAX_PATH))
                        {
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }

                        if (!EnsureProfileFileExists(g_szInfFile, c_pszTemplateInf, TEXT(".inf"), MAX_PATH))
                        {
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }                        

                        //
                        //  Since we removed multi-language support from CMAK (NTRAID 177515),
                        //  we need to check to make sure they aren't trying to edit a foriegn
                        //  language profile.  If so then we need to force an upgrade.
                        //
                        if (!IsNativeLCID(g_szInfFile))
                        {
                            MYVERIFY(0 != LoadString(g_hInstance, IDS_NONNATIVELCID, szTemp, MAX_PATH));
                            MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szTemp, g_szShortServiceName, szLanguageDisplayName));
                            
                            if (IDYES == MessageBox(hDlg, szMsg, g_szAppTitle, MB_YESNO | MB_APPLMODAL | MB_DEFBUTTON2 | MB_ICONEXCLAMATION))
                            {
                                //
                                //  They want to continue in the current language so upgrade the
                                //  inf so that it uses the native language template.
                                //
                                MYVERIFY(CELEMS(szTemp) > (UINT) wsprintf(szTemp, TEXT("%s.bak"), g_szInfFile));
                                MYVERIFY(TRUE == UpgradeInf(szTemp, g_szInfFile));
                            }
                            else
                            {
                                MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                                return 1;                                
                            }
                        }

                        //
                        //  Since the Unicode changes to CMAK and the multi-language capabilities of NT5, it is
                        //  possible to create many different language profiles inside CMAK.  Thus we need to check that
                        //  the Current System Default language and the language of the profile the user is editing have
                        //  the same primary language ID, otherwise display problems may arise.  For instance, a use
                        //  with an English version of the OS and CMAK, could set their default system locale to Japanese
                        //  and create a Japanese profile for a client.  Then if they change their system default language
                        //  back to English and try to edit the profile the Japanese characters in the profile will not
                        //  display correctly.  Thus, we should detect the situation where the display language of the profile
                        //  and the current system default language are not the same and throw a warning.
                        //
                        DWORD dwSystemDefaultLCID = GetSystemDefaultLCID();
                        DWORD dwProfileDisplayLanguage = 0;

                        if (0 != GetPrivateProfileString(c_pszInfSectionStrings, c_pszDisplayLCID, 
                                 TEXT(""), szTemp, CELEMS(szTemp), g_szInfFile))
                        {        
                           dwProfileDisplayLanguage = (DWORD)_ttol(szTemp);
                            
                            if (!ArePrimaryLangIDsEqual(dwProfileDisplayLanguage, dwSystemDefaultLCID))
                            {
                                //
                                //  If we are in here, then the default system LCID that the profile was
                                //  last editted in and the current Default System LCID
                                //  have a different Primary language (Japanese vs English for instance).
                                //  Thus we want to warn the user that they can continue but certain characters
                                //  may not display properly.  They should probably change their system default
                                //  locale back to the setting that it was originally editted in.
                                //

                                //
                                //  Get the Language Names of the Two LCIDs (sys default and CMAK lang)
                                //
                                LPTSTR pszSystemLanguage = GetLocalizedLanguageNameFromLCID(dwSystemDefaultLCID);
                                LPTSTR pszProfileDisplayLanguage = GetLocalizedLanguageNameFromLCID(dwProfileDisplayLanguage);
                                LPTSTR pszFmtString = CmLoadString(g_hInstance, IDS_DIFF_DISPLAY_LCID);

                                if (pszSystemLanguage && pszProfileDisplayLanguage && pszFmtString)
                                {
                                    LPTSTR pszMsg = (LPTSTR)CmMalloc(sizeof(TCHAR)*(lstrlen(pszSystemLanguage) + 
                                                                     lstrlen(pszProfileDisplayLanguage) + lstrlen(pszFmtString) + 1));
                                    if (pszMsg)
                                    {
                                        wsprintf(pszMsg, pszFmtString, pszSystemLanguage, pszProfileDisplayLanguage);
                                        MessageBox(hDlg, pszMsg, g_szAppTitle, MB_OK | MB_ICONINFORMATION);
                                        CmFree(pszMsg);
                                    }
                                }

                                CmFree(pszSystemLanguage);
                                CmFree(pszProfileDisplayLanguage);
                                CmFree(pszFmtString);
                            }
                        }

                        //
                        //  We have the possiblity that the inf will be of an old format.  Call
                        //  Upgrade Inf to see if it needs to be upgraded.
                        //

                        MYVERIFY (TRUE == EnsureInfIsCurrent(hDlg, g_szInfFile));
                        WriteInfVersion(g_szInfFile); //lint !e534
                    }

                    break;

                default:
                    return FALSE;
            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}


//
// Write out profile strings with quotes around the entry
// Takes string const as second param
//
void QS_WritePrivateProfileString(LPCTSTR pszSection, LPCTSTR pszItem, LPTSTR entry, LPCTSTR inifile)
{
    TCHAR szTemp[2*MAX_PATH+1] = TEXT("");

    if (NULL != entry)
    {
        MYDBGASSERT(_tcslen(entry) <= ((2 * MAX_PATH) - 2));
        _tcscpy(szTemp,TEXT("\""));
        _tcscat(szTemp,entry);
        _tcscat(szTemp,TEXT("\""));
    }

    MYDBGASSERT(_tcslen(szTemp) <= sizeof(szTemp));

    MYVERIFY(0 != WritePrivateProfileString(pszSection, pszItem, szTemp, inifile));
}



//+----------------------------------------------------------------------------
//
// Function:  ValidateServiceName
//
// Synopsis:  This function makes sure that a long service name is valid.
//            For a long service name to be valid it must contain at least
//            one alpha-numeric character, not start with a period (.), and
//            not contain any of the following characters : */\\:?\"<>|[]
//
// Arguments: LPCTSTR pszLongServiceName - the service name to check
//
// Returns:   BOOL returns TRUE if the name is valid.
//                  
//
// History:   quintinb Created     10/29/98
//
//+----------------------------------------------------------------------------
int ValidateServiceName(HWND hDlg, LPTSTR pszLongServiceName)
{
    BOOL bBadServiceNameCharFound = FALSE;
    BOOL bFoundAlphaNumeric = FALSE;
    LPTSTR pch;
    int iLen;


    if ((NULL == pszLongServiceName) || (TEXT('\0') == pszLongServiceName[0]))
    {
        //
        //  Cannot have an empty service name
        //
        MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NOSERVICE, MB_OK));
        return FALSE;
    }
    else if (MAX_LONG_SERVICE_NAME_LENGTH < _tcslen(pszLongServiceName))
    {
        //
        //  Too Long
        //
        TCHAR* pszMsg = CmFmtMsg(g_hInstance, IDS_SERVICENAMETOBIG, MAX_LONG_SERVICE_NAME_LENGTH);

        if (pszMsg)
        {
            MessageBox(hDlg, pszMsg, g_szAppTitle, MB_OK);
            CmFree(pszMsg);
        }

        return FALSE;
    }
    else
    {
        iLen = lstrlen(g_szBadLongServiceNameChars); 
        pch = pszLongServiceName;

        //
        //  Check that the service name doesn't start with a period
        //
        if (TEXT('.') == pszLongServiceName[0])
        {
            bBadServiceNameCharFound = TRUE;
        }

        //
        //  Check that it doesn't contain any bad characters
        //
        while (!bBadServiceNameCharFound && (*pch != _T('\0')))
        {
            for (int j = 0; j < iLen; ++j)
            {
                if (*pch == g_szBadLongServiceNameChars[j])
                {
                    bBadServiceNameCharFound = TRUE;
                    break;
                }
            }

            pch = CharNext(pch);
        }

        //
        //  Check that it contains at least one alphanumeric character
        //
        iLen = lstrlen(pszLongServiceName);
        WORD *pwCharTypeArray = (WORD*)CmMalloc(sizeof(WORD)*(iLen + 1));

        if (pwCharTypeArray)
        {
            if (GetStringTypeEx(LOCALE_SYSTEM_DEFAULT, CT_CTYPE1, pszLongServiceName, -1, pwCharTypeArray))
            {
                for (int i = 0; i < iLen; i++)
                {
                    if (pwCharTypeArray[i] & (C1_ALPHA | C1_DIGIT)) 
                    {
                        bFoundAlphaNumeric = TRUE;
                        break;  // only need one alpha numeric char.
                    }
                }
            }

            CmFree(pwCharTypeArray);
        }

        if (bBadServiceNameCharFound || !bFoundAlphaNumeric)
        {
            //
            //  Contains bad chars.
            //
            LPTSTR pszMsg = CmFmtMsg(g_hInstance, IDS_BADLONGNAME, g_szBadLongServiceNameChars);

            if (pszMsg)
            {
                MessageBox(hDlg, pszMsg, g_szAppTitle, MB_OK);
                CmFree(pszMsg);
            }
            return FALSE;
        }
        else
        {
            //
            //  A good long service name
            //
            return TRUE;
        }
    }
}

//+----------------------------------------------------------------------------
//
// Function:  ValidateShortServiceName
//
// Synopsis:  This function checks to see if a given short service name is valid.
//            To be valid, a short service name must be less than 8 bytes long
//            (but not empty) and must not contain any characters found in
//            g_szBadFilenameChars ... basically we only allow letters and
//            numbers.
//
// Arguments: LPTSTR pszShortServiceName - the short service name to verify
//
// Returns:   BOOL - TRUE if the short service name passed in is valid
//
// History:   quintinb Created    10/29/98
//
//+----------------------------------------------------------------------------
BOOL ValidateShortServiceName(HWND hDlg, LPTSTR pszShortServiceName)
{
    LPTSTR pch;

    if ((NULL == pszShortServiceName) || (TEXT('\0') == pszShortServiceName[0]))
    {                   
        MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NOSHORTNAME, MB_OK));
        return FALSE;
    }

    //
    //  Notice that 8.3 filenames are 8 bytes not 8 characters.  Thus we can only have
    //  4 DBCS chars.
    //
#ifdef UNICODE

    LPSTR pszAnsiShortServiceName = WzToSzWithAlloc(pszShortServiceName);

    if (MAX_SHORT_SERVICE_NAME_LENGTH < lstrlenA(pszAnsiShortServiceName))
#else
    if (MAX_SHORT_SERVICE_NAME_LENGTH < strlen(pszShortServiceName))
#endif
    {
        MYVERIFY(IDOK == ShowMessage(hDlg, IDS_TOOLONG, MB_OK));
        return FALSE;
    }
    else
    {
        // check for valid file name

        int iLen = lstrlen(g_szBadFilenameChars); 
        pch = pszShortServiceName;

        while(*pch != _T('\0'))
        {
            for (int j = 0; j < iLen; ++j)
            {
                if (*pch == g_szBadFilenameChars[j])
                {
                    LPTSTR pszMsg = CmFmtMsg(g_hInstance, IDS_BADNAME, g_szBadFilenameChars);

                    if (pszMsg)
                    {
                        MessageBox(hDlg, pszMsg, g_szAppTitle, MB_OK);
                        CmFree(pszMsg);
                    }

                    return FALSE;
                }
            }
            pch = CharNext(pch);
        }
    }

#ifdef UNICODE
    CmFree(pszAnsiShortServiceName);
#endif

    return TRUE;
}

//+----------------------------------------------------------------------------
//
// Function:  CmStrStrI
//
// Synopsis:  Simple replacement for StrStr from C runtime, but case-insensitive
//
// Arguments: LPCTSTR pszString - The string to search in
//            LPCTSTR pszSubString - The string to search for
//
// Returns:   LPTSTR - Ptr to the first occurence of pszSubString in pszString. 
//                    NULL if pszSubString does not occur in pszString
//
//
// History:   SumitC      copied from CmStrStrW    15-Mar-2001
//
//+----------------------------------------------------------------------------
CMUTILAPI LPWSTR CmStrStrI(LPCWSTR pszString, LPCWSTR pszSubString)
{

    //
    //  Check the inputs
    //
    MYDBGASSERT(pszString);
    MYDBGASSERT(pszSubString);

    if (NULL == pszSubString || NULL == pszString)
    {
        return NULL;
    }

    //
    //  Check to make sure we have something to look for
    //
    if (TEXT('\0') == pszSubString[0])
    {
        return((LPWSTR)pszString);
    }

    //
    //  Okay, start looking for the string
    //
    LPWSTR pszCurrent = (LPWSTR)pszString;
    LPWSTR pszTmp1;
    LPWSTR pszTmp2;

    while (*pszCurrent)
    {
        pszTmp1 = pszCurrent;
        pszTmp2 = (LPWSTR) pszSubString;

        while (*pszTmp1 && *pszTmp2 && (tolower(*pszTmp1) == tolower(*pszTmp2)))
        {
            pszTmp1 = CharNext(pszTmp1);
            pszTmp2 = CharNext(pszTmp2);
        }

        if (TEXT('\0') == *pszTmp2)
        {        
            return pszCurrent;
        }

        pszCurrent = CharNext(pszCurrent);
    }

    return NULL;
}




//+----------------------------------------------------------------------------
//
// Func:    FixupCMSFileForClonedProfile
//
// Desc:    Parses the CMS file and replaces references to the old shortname
//
// Args:    [pszCMSFile] - name of the CMS file
//          [pszOld]     - old short service name
//          [pszNew]     - new short service name
//
// Return:  HRESULT
//
// Notes:   
//
// History: 16-Feb-2001   SumitC      Created
//
//-----------------------------------------------------------------------------
HRESULT
FixupCMSFileForClonedProfile(LPTSTR pszCMSFile, LPTSTR pszOld, LPTSTR pszNew)
{
    HRESULT hr = S_OK;
    LPTSTR pszCurrentSection = NULL;

    MYDBGASSERT(pszCMSFile);
    MYDBGASSERT(pszOld);
    MYDBGASSERT(pszNew);
    MYDBGASSERT(lstrlen(pszOld) <= MAX_SHORT_SERVICE_NAME_LENGTH);

    if (NULL == pszCMSFile || NULL == pszOld || NULL == pszNew ||
        (lstrlen(pszOld) > MAX_SHORT_SERVICE_NAME_LENGTH))
    {
        return E_INVALIDARG;
    }

    //
    //  Set up the string we're going to look for in the Values
    //
    TCHAR szOldNamePlusSlash[MAX_SHORT_SERVICE_NAME_LENGTH + 1 + 1];

    lstrcpy(szOldNamePlusSlash, pszOld);
    lstrcat(szOldNamePlusSlash, TEXT("\\"));

    //
    //  read in all the sections from the CMS file
    //
    LPTSTR pszAllSections = GetPrivateProfileStringWithAlloc(NULL, NULL, TEXT(""), pszCMSFile);

    //
    //  iterate over all the sections
    //
    for (pszCurrentSection = pszAllSections;
         pszCurrentSection && (TEXT('\0') != pszCurrentSection[0]);
         pszCurrentSection += (lstrlen(pszCurrentSection) + 1))
    {
        //
        //  Skip the [Connection Manager] section.  The entries here are image files,
        //  and are dealt with in a later CMAK page.
        //
        if (0 == lstrcmpi(c_pszCmSection, pszCurrentSection))
        {
            continue;
        }
        
        //
        // for each section, get all the keys
        //
        LPTSTR pszKeysInThisSection = GetPrivateProfileStringWithAlloc(pszCurrentSection, NULL, TEXT(""), pszCMSFile);
        LPTSTR pszCurrentKey = NULL;
        
        //
        //  iterate over all the keys
        //
        for (pszCurrentKey = pszKeysInThisSection;
             pszCurrentKey && (TEXT('\0') != pszCurrentKey[0]);
             pszCurrentKey += (lstrlen(pszCurrentKey) + 1)) // alternate is CmEndOfStr(pszCurrentKeyName) & pszCurrentKeyName++
        {
            //
            //  Get the value for this key
            //
            LPTSTR pszValue = GetPrivateProfileStringWithAlloc(pszCurrentSection, pszCurrentKey, TEXT(""), pszCMSFile);

            if (pszValue)
            {
                //
                //  Search for "pszOld\", and replace with "pszNew\" (the \ is
                //  to ensure that it is part of a path)
                //
                if (CmStrStrI(pszValue, szOldNamePlusSlash) == pszValue)
                {
                    UINT cLen = lstrlen(pszValue) - lstrlen(pszOld) + lstrlen(pszNew) + 1;

                    LPTSTR pszNewValue = (LPTSTR) CmMalloc(cLen * sizeof(TCHAR));
                    if (pszNewValue)
                    {
                        lstrcpy(pszNewValue, pszNew);
                        lstrcat(pszNewValue, TEXT("\\"));
                        lstrcat(pszNewValue, pszValue + lstrlen(szOldNamePlusSlash));

                        //
                        //  Write back the value (this doesn't affect the list
                        //  of keys, so it is safe to do.)
                        //
                        MYDBGASSERT(0 != WritePrivateProfileString(pszCurrentSection, pszCurrentKey, pszNewValue, pszCMSFile));

                        CmFree(pszNewValue);
                    }
                }

                CmFree(pszValue);
            }
        }
        CmFree(pszKeysInThisSection);
    }

    CmFree(pszAllSections);

    return hr;
}

//+----------------------------------------------------------------------------
//
// Func:    CloneProfile
//
// Desc:    Does the gruntwork to clone a given profile
//
// Args:    [pszShortServiceName] - new short service name
//          [pszLongServiceName] -  new long service name
//
// Return:  HRESULT
//
// Notes:   
//
// History: 16-Feb-2001   SumitC      Created (most code copied from ProcessServiceName)
//
//-----------------------------------------------------------------------------
HRESULT
CloneProfile(IN LPTSTR pszShortServiceName, IN LPTSTR pszLongServiceName)
{
    HRESULT hr = S_OK;
    TCHAR szMsg[MAX_PATH+1];

    MYDBGASSERT(pszShortServiceName);
    MYDBGASSERT(pszLongServiceName);

    if ((_tcsicmp(g_szShortServiceName, pszShortServiceName) != 0))
    {
        //
        //  If this is a cloned profile, we want to delete the 
        //  old executable file and the old .inf.bak file so that 
        //  we don't leave it around.
        //
        if (TEXT('\0') != g_szShortServiceName[0])
        {
            MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, 
                TEXT("%s\\%s.exe"), g_szOutdir, g_szShortServiceName));

            DeleteFile(szMsg);

            MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, 
                TEXT("%s\\%s.inf.bak"), g_szOutdir, g_szShortServiceName));

            DeleteFile(szMsg);

        }

        MYVERIFY(0 != WritePrivateProfileString(c_pszInfSectionStrings, 
            c_pszDesktopGuid,TEXT(""), g_szInfFile));

        //
        //  By calling WritePrivateProfileString with all NULL's we flush the file cache 
        //  (win95 only).  This call will return 0.
        //

        WritePrivateProfileString(NULL, NULL, NULL, g_szInfFile); //lint !e534 this call will return 0

        MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, TEXT("%s\\%s.inf"), 
            g_szOutdir, pszShortServiceName));
        MYVERIFY(0 != MoveFile(g_szInfFile, szMsg));
        _tcscpy(g_szInfFile, szMsg);

        MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, TEXT("%s\\%s.sed"), 
            g_szOutdir, pszShortServiceName));
        MYVERIFY(0 != MoveFile(g_szSedFile, szMsg));
        _tcscpy(g_szSedFile, szMsg);

        MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, TEXT("%s\\%s.cms"), 
            g_szOutdir, pszShortServiceName));
        MYVERIFY(0 != MoveFile(g_szCmsFile, szMsg));
        _tcscpy(g_szCmsFile, szMsg);

        MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, TEXT("%s\\%s.cmp"), 
            g_szOutdir, pszShortServiceName));                        
        MYVERIFY(0 != MoveFile(g_szCmpFile, szMsg));
        _tcscpy(g_szCmpFile, szMsg);

        //
        //  Fix up any entries that are pointing to the old path
        //
        (void) FixupCMSFileForClonedProfile(g_szCmsFile, g_szShortServiceName, pszShortServiceName);
        
    }
    _tcscpy(g_szShortServiceName, pszShortServiceName);

    //
    //  Check to see if the user changed the long service name
    //
    if ((0 != lstrcmpi(pszLongServiceName, g_szLongServiceName)) && (TEXT('\0') != g_szLongServiceName[0]))
    {
        const int c_iNumDunSubSections = 4;
        TCHAR szCurrentSectionName[MAX_PATH+1];
        TCHAR szNewSectionName[MAX_PATH+1];
        const TCHAR* const ArrayOfSubSections[c_iNumDunSubSections] = 
        {
            c_pszCmSectionDunServer, 
            c_pszCmSectionDunNetworking, 
            c_pszCmSectionDunTcpIp, 
            c_pszCmSectionDunScripting
        };

        //
        //  Free the DNS list so that we will re-read it later.  This ensures that
        //  we will get rid of any default entries we added that don't really exist
        //  and will add new defaults if we need them.
        //
        FreeDnsList(&g_pHeadDunEntry, &g_pTailDunEntry);
        FreeDnsList(&g_pHeadVpnEntry, &g_pTailVpnEntry);

        //
        //  The user cloned the long service name.  Update the DUN key and rename the 
        //  default DUN entry if the long service name and the DUN name match.  If they
        //  don't match we don't want to rename them as a phonebook may be referencing them
        //  by their original name.
        //
        GetDefaultDunSettingName(g_szCmsFile, g_szLongServiceName, pszShortServiceName, MAX_PATH + 1);

        if (0 == lstrcmpi(g_szLongServiceName, pszShortServiceName))
        {
            for (int i = 0; i < c_iNumDunSubSections; i++)
            {
                wsprintf(szCurrentSectionName, TEXT("%s&%s"), ArrayOfSubSections[i], g_szLongServiceName);
                wsprintf(szNewSectionName, TEXT("%s&%s"), ArrayOfSubSections[i], pszLongServiceName);

                RenameSection(szCurrentSectionName, szNewSectionName, g_szCmsFile);
            }

            MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryDun, pszLongServiceName, g_szCmsFile));
        }

        //
        //  Now update the TunnelDUN key and rename the Tunnel DUN entry if Tunnel DUN name is based on the original
        //  long service name.  If they aren't related then we don't want to rename them.
        //
        GetTunnelDunSettingName(g_szCmsFile, g_szLongServiceName, pszShortServiceName, MAX_PATH + 1);
        wsprintf(szMsg, TEXT("%s %s"), g_szLongServiceName, c_pszCmEntryTunnelPrimary);

        if (0 == lstrcmpi(szMsg, pszShortServiceName))
        {
            for (int i = 0; i < c_iNumDunSubSections; i++)
            {
                wsprintf(szCurrentSectionName, TEXT("%s&%s %s"), ArrayOfSubSections[i], g_szLongServiceName, c_pszCmEntryTunnelPrimary);
                wsprintf(szNewSectionName, TEXT("%s&%s %s"), ArrayOfSubSections[i], pszLongServiceName, c_pszCmEntryTunnelPrimary);

                RenameSection(szCurrentSectionName, szNewSectionName, g_szCmsFile);
            }

            MYVERIFY(CELEMS(szNewSectionName) > (UINT)wsprintf(szNewSectionName, TEXT("%s %s"), pszLongServiceName, c_pszCmEntryTunnelPrimary));
            MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryTunnelDun, szNewSectionName, g_szCmsFile));
        }
    }

    CMTRACEHR("CloneProfile", hr);
    return hr;
}


//+----------------------------------------------------------------------------
//
// Function:  ProcessServiceName
//
// Synopsis:  Setup service and File Names
//
//
// History:   quintinb Created Header and renamed from ProcessPage2    8/6/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessServiceName(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szTemp2[MAX_PATH+1];
    TCHAR szMsg[MAX_PATH+1];
    LONG lLongServiceReturn;
    LONG lShortServiceReturn;
    int nResult;
    NMHDR* pnmHeader = (NMHDR*)lParam;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_NAMES)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_SERVICE);
    SetDefaultGUIFont(hDlg,message,IDC_SSERVICE);

    switch (message)
    {
        case WM_INITDIALOG:
            // this init's the focus, otherwise Setfocus won't work 1st time
            SetFocus(GetDlgItem(hDlg, IDC_SERVICE));
            // bug fix 6234, quintinb 9-8-97
            SendDlgItemMessage(hDlg, IDC_SERVICE, EM_SETLIMITTEXT, (WPARAM)MAX_LONG_SERVICE_NAME_LENGTH, (LPARAM)0);//lint !e534 EM_SETLIMITTEXT doesn't return anything useful
            // end bug fix 6234, quintinb
            break;

        case WM_NOTIFY:


            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:

                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    
                    return 1;

                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));
                    if (*g_szShortServiceName)
                    {
                        MYVERIFY(TRUE == SendDlgItemMessage(hDlg, IDC_SSERVICE, WM_SETTEXT, 
                            (WPARAM)0, (LPARAM) g_szShortServiceName));

                        GetFileName(g_szCmsFile,szTemp);
                        
                        if (_tcsicmp(szTemp,TEXT(".cms")) != 0)
                        {
                            MYVERIFY(0 != GetPrivateProfileString(c_pszCmSection, c_pszCmEntryServiceName,
                                TEXT(""), g_szLongServiceName, CELEMS(g_szLongServiceName), g_szCmsFile));
                        }

                        MYVERIFY(TRUE == SendDlgItemMessage(hDlg, IDC_SERVICE, WM_SETTEXT, (WPARAM)0, 
                            (LPARAM) g_szLongServiceName));
                    }
                    else
                    {
                        MYVERIFY(TRUE == SendDlgItemMessage(hDlg, IDC_SERVICE, WM_SETTEXT, 
                            (WPARAM)0, (LPARAM) NULL));
                        MYVERIFY(TRUE == SendDlgItemMessage(hDlg, IDC_SSERVICE, WM_SETTEXT, 
                            (WPARAM)0, (LPARAM) NULL));
                    }

                    break;

                case PSN_WIZBACK: // fall through to Next
                case PSN_WIZNEXT:
                    // the Next button was pressed
                    if (-1 == GetTextFromControl(hDlg, IDC_SERVICE, szTemp2, MAX_PATH, (PSN_WIZNEXT == pnmHeader->code))) // bDisplayError == (PSN_WIZBACK == pnmHeader->code)
                    {
                        //
                        //  Let the user go back if there is a problem with retrieving their text so that
                        //  they can choose another profile.
                        //
                        if (PSN_WIZBACK == pnmHeader->code)
                        {
                            return FALSE;
                        }
                        else
                        {
                            goto ServiceNameError;
                        }
                    }

                    CmStrTrim(szTemp2);

                    if (-1 == GetTextFromControl(hDlg, IDC_SSERVICE, szTemp, MAX_PATH, (PSN_WIZNEXT == pnmHeader->code))) // bDisplayError == (PSN_WIZBACK == pnmHeader->code)
                    {
                        //
                        //  Let the user go back if there is a problem with retrieving their text so that
                        //  they can choose another profile.
                        //
                        if (PSN_WIZBACK == pnmHeader->code)
                        {
                            return FALSE;
                        }
                        else
                        {
                            goto ServiceNameError;
                        }
                    }

                    //
                    //  If both the servicename and the short servicename are blank and the user
                    //  is navigating back, then allow them to continue.  Otherwise go through all
                    //  the normal checks.
                    //

                    if ((pnmHeader && (PSN_WIZBACK == pnmHeader->code))) 
                    {
                        if ((szTemp[0] == TEXT('\0')) && (szTemp2[0] == TEXT('\0')))
                        {
                            return 0;
                        }
                    }
                    
                    //
                    //  Validate the Long Service Name
                    //

                    if (!ValidateServiceName(hDlg, szTemp2))
                    {
                        goto ServiceNameError;                
                    }

                    //
                    //  Now lets validate the short service name
                    //

                    if (!ValidateShortServiceName(hDlg, szTemp))
                    {
                        goto ShortServiceNameError;                 
                    }

                    //
                    //  Changing one of the service names without changing the
                    //  other can cause problems when installing the profile
                    //  later.  Warn the user if this is the case.
                    //
                    { // scoping braces
                        BOOL bShortServiceNameChanged = !!lstrcmpi(g_szShortServiceName, szTemp);
                        BOOL bLongServiceNameChanged = !!lstrcmpi(g_szLongServiceName, szTemp2);

                        if ((FALSE == g_bNewProfile) && (bShortServiceNameChanged != bLongServiceNameChanged))
                        {
                            nResult = ShowMessage(hDlg, IDS_CHANGED_ONLY_SS_OR_LS, MB_YESNO);
                            if (nResult == IDYES)
                            {
                                if (bShortServiceNameChanged)
                                {
                                    goto ServiceNameError;
                                }
                                if (bLongServiceNameChanged)
                                {
                                    goto ShortServiceNameError;
                                }
                            }
                        }
                    }

                    //
                    //  Create a default output directory based on the short name.
                    //
                    //  NTRAID 159367 -- quintinb
                    //  Must leave the comparison between the ShortName and szTemp, otherwise the
                    //  user can change the shortname and we won't rename the files.  This allows
                    //  profile cloning.
                    //
                    if ((_tcsicmp(g_szShortServiceName, szTemp) != 0))
                    {
                        BOOL bFound;
                        
                        bFound = FindListItemByName(szTemp, g_pHeadProfile, NULL); // NULL passed because we don't need a pointer to the item returned
                        
                        if (bFound)
                        {
                            nResult = ShowMessage(hDlg,IDS_PROFEXISTS,MB_YESNO);
                            if (nResult == IDNO)
                            {
                                goto ShortServiceNameError;
                            }
                        }

                        MYVERIFY(S_OK == CloneProfile(szTemp, szTemp2));
                    }
                    
                    //
                    //  The Long Service Name is valid, lets keep it.
                    //
                    _tcscpy(g_szLongServiceName, szTemp2);                    

                    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryServiceName, g_szLongServiceName, g_szCmsFile));

                    QS_WritePrivateProfileString(c_pszInfSectionStrings, c_pszCmEntryServiceName, g_szLongServiceName, g_szInfFile);

                    QS_WritePrivateProfileString(c_pszInfSectionStrings, c_pszUninstallAppTitle, g_szLongServiceName, g_szInfFile);

                    QS_WritePrivateProfileString(c_pszInfSectionStrings, c_pszShortSvcName, g_szShortServiceName, g_szInfFile);

                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;

ServiceNameError:
    
    SetFocus(GetDlgItem(hDlg, IDC_SERVICE));
    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
    return 1;

ShortServiceNameError:
    
    SetFocus(GetDlgItem(hDlg, IDC_SSERVICE));
    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
    return 1;
}


//+----------------------------------------------------------------------------
//
// Function:  ProcessSupportInfo
//
// Synopsis:  Customize Support Information
//
//
// History:   quintinb  Created Header and renamed from ProcessPage2_A    8/6/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessSupportInfo(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    NMHDR* pnmHeader = (NMHDR*)lParam;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_SUPPINFO)) return TRUE;
    if (ProcessCancel(hDlg, message, lParam)) return TRUE;
    SetDefaultGUIFont(hDlg, message, IDC_SUPPORT);

    switch (message)
    {
        case WM_INITDIALOG:

           // Fix for Whistler bug 9156
            SendDlgItemMessage(hDlg, IDC_SUPPORT, EM_SETLIMITTEXT, (WPARAM) 50, 0);

            // this init's the focus, otherwise Setfocus won't work 1st time
            SetFocus(GetDlgItem(hDlg, IDC_SUPPORT));
            break;

        case WM_NOTIFY:


            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));

                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));

                    //
                    //  this call to GetPrivateProfileString may retreive a blank string, thus don't use the MYVERIFY macro
                    //
                    GetPrivateProfileString(c_pszCmSection, c_pszCmEntryServiceMessage, TEXT(""), 
                        g_szSvcMsg, CELEMS(g_szSvcMsg), g_szCmsFile);    //lint !e534

                    MYVERIFY(TRUE == SendDlgItemMessage(hDlg, IDC_SUPPORT, WM_SETTEXT, 
                        (WPARAM)0, (LPARAM) g_szSvcMsg));

                    break;
                case PSN_WIZBACK:

                case PSN_WIZNEXT:
                    // the Next button was pressed

                    if (-1 == GetTextFromControl(hDlg, IDC_SUPPORT, szTemp, MAX_PATH, TRUE)) // bDisplayError == TRUE
                    {
                        SetFocus(GetDlgItem(hDlg, IDC_SUPPORT));
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                        return 1;
                    }

                    CmStrTrim(szTemp);
                    MYVERIFY(TRUE == SendDlgItemMessage(hDlg, IDC_SUPPORT, WM_SETTEXT, (WPARAM)0, (LPARAM) szTemp));
                    _tcscpy(g_szSvcMsg,szTemp);
                    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection,c_pszCmEntryServiceMessage,g_szSvcMsg,g_szCmsFile));

#ifdef _WIN64
                    //
                    //  If we are going forward, skip the Include CM binaries page if this is IA64
                    //
                    if (pnmHeader && (PSN_WIZNEXT == pnmHeader->code))
                    {
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, IDD_LICENSE));
                    }
#endif
                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessIncludeCm
//
// Synopsis:  Include CM bits
//
//
// History:   quintinb  Created Header and renamed from ProcessPage2A    8/6/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessIncludeCm(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    NMHDR* pnmHeader = (NMHDR*)lParam;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_CMSW)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;

    switch (message)
    {
        case WM_INITDIALOG:

            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));

                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:

                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));
                    
                    MYVERIFY(0 != GetPrivateProfileString(c_pszCmakStatus, c_pszIncludeCmCode, 
                        c_pszOne, szTemp, CELEMS(szTemp), g_szInfFile));
                    
                    if (*szTemp == TEXT('1'))
                    {
                        g_bIncludeCmCode = TRUE;
                        MYVERIFY(0 != CheckDlgButton(hDlg,IDC_CHECK1,TRUE));
                    }
                    else
                    {
                        g_bIncludeCmCode = FALSE;
                        MYVERIFY(0 != CheckDlgButton(hDlg,IDC_CHECK1,FALSE));
                    }

                    break;

                case PSN_WIZBACK:
                case PSN_WIZNEXT:
                    g_bIncludeCmCode = IsDlgButtonChecked(hDlg,IDC_CHECK1);
                    if (g_bIncludeCmCode)
                    {
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmakStatus,c_pszIncludeCmCode,c_pszOne,g_szInfFile));
                    }
                    else
                    {
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmakStatus,c_pszIncludeCmCode,c_pszZero,g_szInfFile));
                    }

                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

void EnableDisableCmProxyControls(HWND hDlg)
{
    BOOL bCmProxyEnabled = (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_RADIO2));
    
    HWND hControl = GetDlgItem(hDlg, IDC_EDIT1);
    EnableWindow(hControl, bCmProxyEnabled);

    hControl = GetDlgItem(hDlg, IDC_CHECK1);
    EnableWindow(hControl, bCmProxyEnabled);

    hControl = GetDlgItem(hDlg, IDC_PROXYLABEL);
    EnableWindow(hControl, bCmProxyEnabled);    
}

BOOL FillInCustomActionStructWithCmProxy(BOOL bRestorePrevProxySettings, CustomActionListItem* pCustomAction, 
                                         BOOL bDisconnectAction, LPCTSTR pszProxyFile)
{
    BOOL bReturn = FALSE;
    
    MYDBGASSERT(pCustomAction && pszProxyFile && (TEXT('\0') != pszProxyFile[0]));
    
    if (pCustomAction && pszProxyFile && (TEXT('\0') != pszProxyFile[0]))
    {
        const TCHAR* const c_pszBackupFileName = TEXT("proxy.bak");
        const TCHAR* const c_pszDialRasEntry = TEXT("%DIALRASENTRY%");
        const TCHAR* const c_pszProfile = TEXT("%PROFILE%");
        const TCHAR* const c_pszTunnelRasEntry = TEXT("%TUNNELRASENTRY%");
        const TCHAR* const c_pszSetProxyFunction = TEXT("SetProxy");

        UINT uDescription;

        LPTSTR aArrayOfStrings[10];
        UINT uCount = 0;

        if (bDisconnectAction)
        {
            aArrayOfStrings[uCount] = (LPTSTR)c_pszSourceFileNameSwitch;
            uCount++;

            aArrayOfStrings[uCount] = (LPTSTR)c_pszBackupFileName;
            uCount++;

            aArrayOfStrings[uCount] = (LPTSTR)c_pszDialRasEntrySwitch;
            uCount++;

            aArrayOfStrings[uCount] = (LPTSTR)c_pszDialRasEntry;
            uCount++;

            aArrayOfStrings[uCount] = (LPTSTR)c_pszTunnelRasEntrySwitch;
            uCount++;

            aArrayOfStrings[uCount] = (LPTSTR)c_pszTunnelRasEntry;
            uCount++;

            aArrayOfStrings[uCount] = (LPTSTR)c_pszProfileSwitch;
            uCount++;

            aArrayOfStrings[uCount] = (LPTSTR)c_pszProfile;
            uCount++;

            uDescription = IDS_CMPROXY_DIS_DESC;
        }
        else
        {
            aArrayOfStrings[uCount] = (LPTSTR)c_pszSourceFileNameSwitch;
            uCount++;

            aArrayOfStrings[uCount] = (LPTSTR)pszProxyFile;
            uCount++;

            if (bRestorePrevProxySettings)
            {
                aArrayOfStrings[uCount] = (LPTSTR)c_pszBackupFileNameSwitch;
                uCount++;

                aArrayOfStrings[uCount] = (LPTSTR)c_pszBackupFileName;
                uCount++;            
            }

            aArrayOfStrings[uCount] = (LPTSTR)c_pszDialRasEntrySwitch;
            uCount++;

            aArrayOfStrings[uCount] = (LPTSTR)c_pszDialRasEntry;
            uCount++;

            aArrayOfStrings[uCount] = (LPTSTR)c_pszTunnelRasEntrySwitch;
            uCount++;

            aArrayOfStrings[uCount] = (LPTSTR)c_pszTunnelRasEntry;
            uCount++;

            aArrayOfStrings[uCount] = (LPTSTR)c_pszProfileSwitch;
            uCount++;

            aArrayOfStrings[uCount] = (LPTSTR)c_pszProfile;
            uCount++;

            uDescription = IDS_CMPROXY_CON_DESC;
        }
        
        MYVERIFY(0 != LoadString(g_hInstance, uDescription, pCustomAction->szDescription, CELEMS(pCustomAction->szDescription)));
        pCustomAction->Type = bDisconnectAction ? ONDISCONNECT : ONCONNECT;

        wsprintf(pCustomAction->szProgram, TEXT("%s\\cmproxy.dll"), g_szSupportDir);
    
        lstrcpy(pCustomAction->szFunctionName, c_pszSetProxyFunction);
    
        pCustomAction->bIncludeBinary = TRUE;
        pCustomAction->bBuiltInAction = TRUE;
        pCustomAction->bTempDescription = FALSE;
        pCustomAction->dwFlags = ALL_CONNECTIONS;

        HRESULT hr = BuildCustomActionParamString(&(aArrayOfStrings[0]), uCount, &(pCustomAction->pszParameters));

        bReturn = (SUCCEEDED(hr) && pCustomAction->pszParameters);
    }

    return bReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessCmProxy
//
// Synopsis:  Automatic IE proxy configuration
//
// History:   quintinb  Created     03/23/00
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessCmProxy(

    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    NMHDR* pnmHeader = (NMHDR*)lParam;
    BOOL bEnableCmProxy;
    BOOL bRestorePrevProxySettings;
    TCHAR szTemp[MAX_PATH+1];

    HRESULT hr;

    CustomActionListItem* pCmProxyCustomAction = NULL;
    CustomActionListItem UpdatedCmProxyAction;

    ProcessBold(hDlg, message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_APCONFIG)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_EDIT1);


    switch (message)
    {
        case WM_INITDIALOG:
            break;

        case WM_COMMAND:
            switch (LOWORD(wParam)) 
            {
                case IDC_RADIO1:
                case IDC_RADIO2:
                    EnableDisableCmProxyControls(hDlg);
                    break;

                case IDC_BUTTON1: // browse 
                    {
                        //
                        //  If the user clicked the browse button without clicking the Proxy radio button,
                        //  then we need to set the radio and make sure the other Proxy controls are
                        //  enabled.
                        //
                        MYVERIFY(0 != CheckRadioButton(hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO2));
                        EnableDisableCmProxyControls(hDlg);

                        UINT uFilter = IDS_TXTFILTER;
                        TCHAR* pszMask = TEXT("*.txt");
                                          
                        int iTemp = DoBrowse(hDlg, &uFilter, &pszMask, 1, IDC_EDIT1, TEXT("txt"), g_szLastBrowsePath);

                        MYDBGASSERT(0 != iTemp);

                        if (0 < iTemp) // -1 means the user cancelled
                        {
                            //
                            //  We want to copy the full path to the filename into g_szCmProxyFile so
                            //  that we have it for later in case the user wants to include it in the profile.
                            //
                            lstrcpy (g_szCmProxyFile, g_szLastBrowsePath);

                            //
                            //  We also want to save the last browse path so that when the user next
                            //  opens the browse dialog they will be in the same place they last
                            //  browsed from.
                            //
                            LPTSTR pszLastSlash = CmStrrchr(g_szLastBrowsePath, TEXT('\\'));

                            if (pszLastSlash)
                            {
                                pszLastSlash = CharNext(pszLastSlash);
                                *pszLastSlash = TEXT('\0');
                            }
                            else
                            {
                                g_szLastBrowsePath[0] = TEXT('\0');                        
                            }        
                        }
                    }
                    break;
                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));

                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:

                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));

                    //
                    //  Ensure we have a custom action list
                    //
                    if (NULL == g_pCustomActionList)
                    {
                        g_pCustomActionList = new CustomActionList;

                        MYDBGASSERT(g_pCustomActionList);

                        if (NULL == g_pCustomActionList)
                        {
                            return FALSE;
                        }

                        //
                        //  Read in the custom actions from the Cms File
                        //

                        hr = g_pCustomActionList->ReadCustomActionsFromCms(g_hInstance, g_szCmsFile, g_szShortServiceName);
                        CMASSERTMSG(SUCCEEDED(hr), TEXT("ProcessCmProxy -- Loading custom actions failed."));
                    }

                    //
                    //  Init the static variables to no proxy settings
                    //
                    bEnableCmProxy = FALSE;
                    bRestorePrevProxySettings = FALSE;
                    g_szCmProxyFile[0] = TEXT('\0');

                    //
                    //  Now lets search the custom action list for cmproxy
                    //
                    MYVERIFY(0 != LoadString(g_hInstance, IDS_CMPROXY_CON_DESC, szTemp, CELEMS(szTemp)));

                    hr = g_pCustomActionList->GetExistingActionData(g_hInstance, szTemp, ONCONNECT, &pCmProxyCustomAction);

                    if (SUCCEEDED(hr) && pCmProxyCustomAction)
                    {
                        //
                        //  Get the filename that the user specified and add it to the UI
                        //
                        if (FindSwitchInString(pCmProxyCustomAction->pszParameters, c_pszSourceFileNameSwitch, TRUE, szTemp)) // bReturnNextToken == TRUE
                        {
                            //
                            //  Figure out if we have the disconnect action too, ensuring to free the existing action first
                            //
                            CmFree(pCmProxyCustomAction->pszParameters);
                            CmFree(pCmProxyCustomAction);

                            wsprintf(g_szCmProxyFile, TEXT("%s\\%s"), g_szTempDir, szTemp);
                            bEnableCmProxy = TRUE;
                        
                            MYVERIFY(0 != LoadString(g_hInstance, IDS_CMPROXY_DIS_DESC, szTemp, CELEMS(szTemp)));

                            hr = g_pCustomActionList->GetExistingActionData(g_hInstance, szTemp, ONDISCONNECT, &pCmProxyCustomAction);

                            if (SUCCEEDED(hr) && pCmProxyCustomAction)
                            {
                                bRestorePrevProxySettings = TRUE;
                                CmFree(pCmProxyCustomAction->pszParameters);
                                CmFree(pCmProxyCustomAction);
                            }
                        }
                        else
                        {
                            CmFree(pCmProxyCustomAction->pszParameters);
                            CmFree(pCmProxyCustomAction);
                            CMASSERTMSG(FALSE, TEXT("ProcessCmProxy -- parameter string format incorrect"));
                        }
                    }
                    
                    MYVERIFY(0 != CheckDlgButton(hDlg, IDC_CHECK1, bRestorePrevProxySettings));
                    MYVERIFY(0 != CheckRadioButton(hDlg, IDC_RADIO1, IDC_RADIO2, (bEnableCmProxy ? IDC_RADIO2 : IDC_RADIO1)));
                    MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDIT1), WM_SETTEXT, 0, (LPARAM)GetName(g_szCmProxyFile)));

                    //
                    //  Now make sure the correct set of controls is enabled.
                    //
                    EnableDisableCmProxyControls(hDlg);

                    break;

                case PSN_WIZBACK:

                case PSN_WIZNEXT:

                    //
                    //  Get the checkbox and radio button state
                    //
                    bEnableCmProxy = (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_RADIO2));
                    bRestorePrevProxySettings = (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_CHECK1));

                    if (bEnableCmProxy)
                    {
                        //
                        //  Lets get the proxy file and verify that they gave us a file and that
                        //  the file actually exists.
                        //
                        if (-1 == GetTextFromControl(hDlg, IDC_EDIT1, szTemp, MAX_PATH, TRUE)) // bDisplayError == TRUE
                        {
                            SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }

                        CmStrTrim(szTemp);

                        if (TEXT('\0') == szTemp[0])
                        {
                            MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NEED_PROXY_FILE, MB_OK));
 
                            SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
 
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;                        
                        }

                        if (!VerifyFile(hDlg, IDC_EDIT1, g_szCmProxyFile, TRUE))
                        {
                            SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
                            return TRUE;
                        }

                        //
                        //  Lets copy the proxy file to the temp dir
                        //
                        wsprintf(szTemp, TEXT("%s\\%s"), g_szTempDir, GetName(g_szCmProxyFile));

                        if (0 != lstrcmpi(szTemp, g_szCmProxyFile))
                        {
                            MYVERIFY(TRUE == CopyFileWrapper(g_szCmProxyFile, szTemp, FALSE));
                            MYVERIFY(0 != SetFileAttributes(szTemp, FILE_ATTRIBUTE_NORMAL));
                        }

                        //
                        //  Now we have all of the data we need, lets build the custom action struct and then
                        //  either edit it or add it depending on whether it already exists or not.
                        //
                        MYVERIFY(LoadString(g_hInstance, IDS_CMPROXY_CON_DESC, szTemp, CELEMS(szTemp)));

                        if (szTemp[0])
                        {
                            hr = g_pCustomActionList->GetExistingActionData(g_hInstance, szTemp, ONCONNECT, &pCmProxyCustomAction);

                            if (SUCCEEDED(hr))
                            {
                                FillInCustomActionStructWithCmProxy(bRestorePrevProxySettings, &UpdatedCmProxyAction, 
                                                                    FALSE, GetName(g_szCmProxyFile)); // bDisconnectAction == FALSE

                                hr = g_pCustomActionList->Edit(g_hInstance, pCmProxyCustomAction, &UpdatedCmProxyAction, g_szShortServiceName);
                                MYVERIFY(SUCCEEDED(hr));

                                CmFree(UpdatedCmProxyAction.pszParameters);
                                UpdatedCmProxyAction.pszParameters = NULL;

                                CmFree(pCmProxyCustomAction->pszParameters);
                                CmFree(pCmProxyCustomAction);
                            }
                            else
                            {
                                FillInCustomActionStructWithCmProxy(bRestorePrevProxySettings, &UpdatedCmProxyAction, 
                                                                    FALSE, GetName(g_szCmProxyFile)); // bDisconnectAction == FALSE

                                hr = g_pCustomActionList->Add(g_hInstance, &UpdatedCmProxyAction, g_szShortServiceName);
                                CmFree(UpdatedCmProxyAction.pszParameters);
                                UpdatedCmProxyAction.pszParameters = NULL;

                                MYVERIFY(SUCCEEDED(hr));
                            }
                        }
                    }
                    else
                    {
                        //
                        //  Clear out the global proxy file path
                        //
                        g_szCmProxyFile[0] = TEXT('\0');

                        //
                        //  The user doesn't want cmproxy.  Delete it from the connect action list.
                        //
                        MYVERIFY(LoadString(g_hInstance, IDS_CMPROXY_CON_DESC, szTemp, CELEMS(szTemp)));

                        g_pCustomActionList->Delete(g_hInstance, szTemp, ONCONNECT);
                    }

                    //
                    //  Now do the same for the disconnect cmproxy action if needed
                    //
                    if (bEnableCmProxy && bRestorePrevProxySettings)
                    {
                        MYVERIFY(LoadString(g_hInstance, IDS_CMPROXY_DIS_DESC, szTemp, CELEMS(szTemp)));

                        if (szTemp[0])
                        {
                            hr = g_pCustomActionList->GetExistingActionData(g_hInstance, szTemp, ONDISCONNECT, &pCmProxyCustomAction);

                            if (S_OK == hr)
                            {
                                FillInCustomActionStructWithCmProxy(bRestorePrevProxySettings, &UpdatedCmProxyAction, 
                                                                    TRUE, GetName(g_szCmProxyFile)); // bDisconnectAction == TRUE

                                hr = g_pCustomActionList->Edit(g_hInstance, pCmProxyCustomAction, &UpdatedCmProxyAction, g_szShortServiceName);
                                MYVERIFY(SUCCEEDED(hr));

                                CmFree(UpdatedCmProxyAction.pszParameters);
                                UpdatedCmProxyAction.pszParameters = NULL;

                                CmFree(pCmProxyCustomAction->pszParameters);
                                CmFree(pCmProxyCustomAction);
                            }
                            else
                            {
                                FillInCustomActionStructWithCmProxy(bRestorePrevProxySettings, &UpdatedCmProxyAction, 
                                                                    TRUE, GetName(g_szCmProxyFile)); // bDisconnectAction == TRUE

                                hr = g_pCustomActionList->Add(g_hInstance, &UpdatedCmProxyAction, g_szShortServiceName);
                                MYVERIFY(SUCCEEDED(hr));

                                CmFree(UpdatedCmProxyAction.pszParameters);
                                UpdatedCmProxyAction.pszParameters = NULL;
                            }
                        }
                    }
                    else
                    {
                        //
                        //  Now try to delete the disconnect action
                        //
                        MYVERIFY(LoadString(g_hInstance, IDS_CMPROXY_DIS_DESC, szTemp, CELEMS(szTemp)));

                        if (szTemp[0])
                        {
                            g_pCustomActionList->Delete(g_hInstance, szTemp, ONDISCONNECT);
                        }
                    }
                    break;

                default:
                    return FALSE;
            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

void EnableDisableCmRouteControls(HWND hDlg)
{
    BOOL bCmRouteEnabled = (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_RADIO2));
    
    HWND hControl = GetDlgItem(hDlg, IDC_ROUTE_FILE);
    EnableWindow(hControl, bCmRouteEnabled);

    hControl = GetDlgItem(hDlg, IDC_ROUTE_FILE_LABEL);
    EnableWindow(hControl, bCmRouteEnabled);

    hControl = GetDlgItem(hDlg, IDC_ROUTE_URL);
    EnableWindow(hControl, bCmRouteEnabled);

    hControl = GetDlgItem(hDlg, IDC_ROUTE_URL_LABEL);
    EnableWindow(hControl, bCmRouteEnabled);

    //
    //  We only want to enable the require URL checkbox if there is text in the URL field.
    //
    LRESULT lResult = SendDlgItemMessage(hDlg, IDC_ROUTE_URL, WM_GETTEXTLENGTH, 0, 0);

    hControl = GetDlgItem(hDlg, IDC_CHECK1);
    EnableWindow(hControl, bCmRouteEnabled && lResult);    

    hControl = GetDlgItem(hDlg, IDC_CHECK2);
    EnableWindow(hControl, bCmRouteEnabled);
}

BOOL FindSwitchInString(LPCTSTR pszStringToSearch, LPCTSTR pszSwitchToFind, BOOL bReturnNextToken, LPTSTR pszToken)
{
    if ((NULL == pszStringToSearch) || (NULL == pszSwitchToFind) || (bReturnNextToken && (NULL == pszToken)))
    {
        CMASSERTMSG(FALSE, TEXT("FindSwitchInString -- invalid parameter"));
        return FALSE;
    }

    BOOL bReturn = FALSE;
    BOOL bLongFileName = FALSE;
    LPTSTR pszSourceFileName = CmStrStr(pszStringToSearch, pszSwitchToFind);
    
    if (pszSourceFileName)
    {
        if (bReturnNextToken)
        {
            pszSourceFileName = pszSourceFileName + lstrlen(pszSwitchToFind);

            while (CmIsSpace(pszSourceFileName))
            {
                pszSourceFileName = CharNext(pszSourceFileName);
            }

            if (TEXT('"') == *pszSourceFileName)
            {
                bLongFileName = TRUE;
                pszSourceFileName = CharNext(pszSourceFileName);
            }
            
            LPTSTR pszCurrent = pszSourceFileName;
            while (pszCurrent && (TEXT('\0') != *pszCurrent))
            {
                if (bLongFileName && (TEXT('"') == *pszCurrent))
                {
                    break;
                }
                else if ((FALSE == bLongFileName) && (CmIsSpace(pszCurrent)))
                {
                    break;
                }

                pszCurrent = CharNext(pszCurrent);
            }

            if (pszCurrent)
            {
                lstrcpyn(pszToken, pszSourceFileName, (int)(pszCurrent - pszSourceFileName + 1));
                bReturn = TRUE;
            }
            else
            {
                CMASSERTMSG(FALSE, TEXT("FindSwitchInString -- unable to find next token to return"));
            }
        }
        else
        {
            bReturn = TRUE;
        }
    }

    return bReturn;
}

HRESULT BuildCustomActionParamString(LPTSTR* aArrayOfStrings, UINT uCountOfStrings, LPTSTR* ppszParamsOutput)
{
    if ((NULL == aArrayOfStrings) || (0 == uCountOfStrings) || (NULL == ppszParamsOutput))
    {
        CMASSERTMSG(FALSE, TEXT("BuildCustomActionParamString -- Invalid Parameter"));
        return E_INVALIDARG;
    }

    UINT uMemoryNeeded = 0;
    LPTSTR pszCurrent;
    BOOL bNeedQuotes;
    
    //
    //  First lets figure out how much memory we need to allocate
    //
    for (UINT i = 0; i < uCountOfStrings; i++)
    {
        if (aArrayOfStrings[i] && (TEXT('\0') != aArrayOfStrings[i]))
        {
            uMemoryNeeded = uMemoryNeeded + lstrlen(aArrayOfStrings[i]);

            //
            //  Next check to see if we need double quotes around the item because it contains spaces
            //
            pszCurrent = (LPTSTR)aArrayOfStrings[i];
            bNeedQuotes = FALSE;

            while (pszCurrent && (TEXT('\0') != *pszCurrent))
            {
                if (CmIsSpace(pszCurrent))
                {
                    bNeedQuotes = TRUE;
                    break;
                }

                pszCurrent = CharNext(pszCurrent);
            }

            //
            //  Add the item to the string, making sure to add a space if this isn't the last
            //  item in the list
            //
            if (bNeedQuotes)
            {
                uMemoryNeeded = uMemoryNeeded + 2;
            }

            //
            //  Add a space unless this is the last item in the list
            //
            if (i < (uCountOfStrings - 1))
            {
                uMemoryNeeded++;
            }
        }
    }

    //
    //  Make sure to add one for the null terminator and multiply by the size of a character
    //
    uMemoryNeeded = (uMemoryNeeded + 1)*sizeof(TCHAR);

    //
    //  Now allocate the memory we need
    //

    *ppszParamsOutput = (LPTSTR)CmMalloc(uMemoryNeeded);

    //
    //  Finally copy over the data
    //
    if (*ppszParamsOutput)
    {

        for (UINT i = 0; i < uCountOfStrings; i++)
        {
            if (aArrayOfStrings[i] && (TEXT('\0') != aArrayOfStrings[i]))
            {
                //
                //  Next check to see if we need double quotes around the item because it contains spaces
                //
                pszCurrent = (LPTSTR)aArrayOfStrings[i];
                bNeedQuotes = FALSE;

                while (pszCurrent && (TEXT('\0') != *pszCurrent))
                {
                    if (CmIsSpace(pszCurrent))
                    {
                        bNeedQuotes = TRUE;
                        break;
                    }

                    pszCurrent = CharNext(pszCurrent);
                }

                //
                //  Add the item to the string, making sure to add a space if this isn't the last
                //  item in the list
                //
                if (bNeedQuotes)
                {
                    lstrcat(*ppszParamsOutput, TEXT("\""));
                }
            
                lstrcat(*ppszParamsOutput, aArrayOfStrings[i]);

                if (bNeedQuotes)
                {
                    lstrcat(*ppszParamsOutput, TEXT("\""));
                }

                //
                //  Add a space unless this is the last item in the list
                //
                if (i < (uCountOfStrings - 1))
                {
                    lstrcat(*ppszParamsOutput, TEXT(" "));
                }
            }
        }
    }
    else
    {
        return E_OUTOFMEMORY;
    }

    return S_OK;
}

BOOL FillInCustomActionStructWithCmRoute(CustomActionListItem* pCustomAction,
                                         BOOL bDisconnectIfUrlUnavailable, LPCTSTR pszUrlPath, LPCTSTR pszRouteFile)
{
    BOOL bReturn = FALSE;

    MYDBGASSERT(pCustomAction && pszUrlPath && pszRouteFile && ((TEXT('\0') != pszRouteFile[0]) || (TEXT('\0') != pszUrlPath[0])));

    if (pCustomAction && pszUrlPath && pszRouteFile && ((TEXT('\0') != pszRouteFile[0]) || (TEXT('\0') != pszUrlPath[0])))
    {
        const TCHAR* const c_pszCmRouteFunction = TEXT("SetRoutes");
        const TCHAR* const c_pszProfileMacro = TEXT("%PROFILE%");

        MYVERIFY(LoadString(g_hInstance, IDS_CMROUTE_DESC, pCustomAction->szDescription, CELEMS(pCustomAction->szDescription)));
        pCustomAction->Type = ONCONNECT;
        wsprintf(pCustomAction->szProgram, TEXT("%s\\cmroute.dll"), g_szSupportDir);

        LPTSTR aArrayOfStrings[8] = {0};
        UINT uIndex = 0;

        if (TEXT('\0') != pszRouteFile[0])
        {
            aArrayOfStrings[uIndex] = (LPTSTR)c_pszProfileSwitch;
            uIndex++;

            aArrayOfStrings[uIndex] = (LPTSTR)c_pszProfileMacro;
            uIndex++;

            aArrayOfStrings[uIndex] = (LPTSTR)c_pszStaticFileNameSwitch;
            uIndex++;

            aArrayOfStrings[uIndex] = (LPTSTR)pszRouteFile;
            uIndex++;
        }

        if (TEXT('\0') != pszUrlPath[0])
        {
            aArrayOfStrings[uIndex] = (LPTSTR)c_pszUrlPathSwitch;
            uIndex++;

            aArrayOfStrings[uIndex] = (LPTSTR)pszUrlPath;
            uIndex++;
        }

        if ((FALSE == bDisconnectIfUrlUnavailable) && (TEXT('\0') != pszUrlPath[0]))
        {
            aArrayOfStrings[uIndex] = (LPTSTR)c_pszDontRequireUrlSwitch;
            uIndex++;
        }

        HRESULT hr = BuildCustomActionParamString(&(aArrayOfStrings[0]), uIndex, &(pCustomAction->pszParameters));
        MYDBGASSERT(SUCCEEDED(hr));
        
        lstrcpy(pCustomAction->szFunctionName, c_pszCmRouteFunction);
 
        pCustomAction->bIncludeBinary = TRUE;
        pCustomAction->bBuiltInAction = TRUE;
        pCustomAction->bTempDescription = FALSE;
        pCustomAction->dwFlags = ALL_CONNECTIONS;

        bReturn = (NULL != pCustomAction->pszParameters);
    }

    return bReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessRoutePlumbing
//
// Synopsis:  Add Route Plumbing information
//
// History:   quintinb  Created     03/23/00
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessRoutePlumbing(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    NMHDR* pnmHeader = (NMHDR*)lParam;    

    BOOL bEnableRoutePlumbing;
    BOOL bDisconnectIfUrlUnavailable;
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szUrlPath[MAX_PATH+1];

    HRESULT hr;
    CustomActionListItem UpdatedCmRouteAction;
    CustomActionListItem* pCmRouteCustomAction = NULL;

    ProcessBold(hDlg, message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_RTPLUMB)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_ROUTE_FILE);
    SetDefaultGUIFont(hDlg,message,IDC_ROUTE_URL);


    switch (message)
    {
        case WM_INITDIALOG:
            break;

        case WM_COMMAND:
            switch (LOWORD(wParam)) 
            {
                case IDC_ROUTE_URL:

                    if (HIWORD(wParam) == EN_CHANGE) 
                    {
                        EnableDisableCmRouteControls(hDlg);
                        return (TRUE);
                    }
                    break;

                case IDC_RADIO1:
                case IDC_RADIO2:
                    EnableDisableCmRouteControls(hDlg);
                    break;

                case IDC_BUTTON1: // browse 
                    {
                        //
                        //  If the user clicked the browse button without clicking the CmRoute radio button,
                        //  then we need to set the radio and make sure the other CmRoute controls are
                        //  enabled.
                        //
                        MYVERIFY(0 != CheckRadioButton(hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO2));
                        EnableDisableCmRouteControls(hDlg);

                        UINT uFilter = IDS_TXTFILTER;
                        TCHAR* pszMask = TEXT("*.txt");
                                          
                        int iTemp = DoBrowse(hDlg, &uFilter, &pszMask, 1, IDC_ROUTE_FILE, TEXT("txt"), g_szLastBrowsePath);

                        MYDBGASSERT(0 != iTemp);

                        if (0 < iTemp) // -1 means the user cancelled
                        {
                            //
                            //  We want to copy the full path to the filename into g_szCmRouteFile so
                            //  that we have it for later in case the user wants to include it in the profile.
                            //
                            lstrcpy (g_szCmRouteFile, g_szLastBrowsePath);

                            //
                            //  We also want to save the last browse path so that when the user next
                            //  opens the browse dialog they will be in the same place they last
                            //  browsed from.
                            //
                            LPTSTR pszLastSlash = CmStrrchr(g_szLastBrowsePath, TEXT('\\'));

                            if (pszLastSlash)
                            {
                                pszLastSlash = CharNext(pszLastSlash);
                                *pszLastSlash = TEXT('\0');
                            }
                            else
                            {
                                g_szLastBrowsePath[0] = TEXT('\0');                        
                            }        
                        }
                    }
                    break;
                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));

                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:

                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));

                    //
                    //  Ensure we have a custom action list
                    //
                    if (NULL == g_pCustomActionList)
                    {
                        g_pCustomActionList = new CustomActionList;

                        MYDBGASSERT(g_pCustomActionList);

                        if (NULL == g_pCustomActionList)
                        {
                            return FALSE;
                        }

                        //
                        //  Read in the custom actions from the Cms File
                        //

                        hr = g_pCustomActionList->ReadCustomActionsFromCms(g_hInstance, g_szCmsFile, g_szShortServiceName);
                        CMASSERTMSG(SUCCEEDED(hr), TEXT("ProcessRoutePlumbing -- Loading custom actions failed."));
                    }

                    //
                    //  Init the static variables to no route plumbing
                    //
                    bEnableRoutePlumbing = FALSE;
                    bDisconnectIfUrlUnavailable = TRUE; // default behavior is to disconnect if URL is unreachable
                    g_szCmRouteFile[0] = TEXT('\0');
                    szUrlPath[0] = TEXT('\0');

                    //
                    //  Now lets search the custom action list for cmproxy
                    //
                    MYVERIFY(0 != LoadString(g_hInstance, IDS_CMROUTE_DESC, szTemp, CELEMS(szTemp)));

                    hr = g_pCustomActionList->GetExistingActionData(g_hInstance, szTemp, ONCONNECT, &pCmRouteCustomAction);

                    if (SUCCEEDED(hr))
                    {
                        //
                        //  Enable Route plumbing
                        //
                        bEnableRoutePlumbing = TRUE;

                        //
                        //  Get the name of the static text file specified for cmroute.dll
                        //
                        if (FindSwitchInString(pCmRouteCustomAction->pszParameters, c_pszStaticFileNameSwitch, TRUE, szTemp)) //bReturnNextToken == TRUE
                        {
                            wsprintf(g_szCmRouteFile, TEXT("%s\\%s"), g_szTempDir, szTemp);
                        }

                        //
                        //  Get the name of the URL to a route file
                        //
                        if (FindSwitchInString(pCmRouteCustomAction->pszParameters, c_pszUrlPathSwitch, TRUE, szUrlPath)) //bReturnNextToken == TRUE
                        {
                            bDisconnectIfUrlUnavailable = (FALSE == FindSwitchInString(pCmRouteCustomAction->pszParameters, 
                                                                                       c_pszDontRequireUrlSwitch, FALSE, NULL)); //bReturnNextToken == FALSE
                        }

                        CmFree(pCmRouteCustomAction->pszParameters);
                        CmFree(pCmRouteCustomAction);
                    }

                    MYVERIFY(0 != CheckRadioButton(hDlg, IDC_RADIO1, IDC_RADIO2, (bEnableRoutePlumbing ? IDC_RADIO2 : IDC_RADIO1)));
                    MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_ROUTE_FILE), WM_SETTEXT, 0, (LPARAM)GetName(g_szCmRouteFile)));
                    MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_ROUTE_URL), WM_SETTEXT, 0, (LPARAM)szUrlPath));

                    MYVERIFY(0 != CheckDlgButton(hDlg, IDC_CHECK1, bDisconnectIfUrlUnavailable));

                    //
                    //  Now make sure the correct set of controls is enabled.
                    //
                    EnableDisableCmRouteControls(hDlg);

                    break;

                case PSN_WIZBACK:

                case PSN_WIZNEXT:
                    //
                    //  Lets figure out if Route plumbing should be enabled or not.
                    //

                    bEnableRoutePlumbing = (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_RADIO2));

                    if (bEnableRoutePlumbing)
                    {
                        //
                        //  First try to get the static route file.  If we don't have one that is okay
                        //  as long as they gave us a route URL.
                        //
                        if (-1 == GetTextFromControl(hDlg, IDC_ROUTE_FILE, szTemp, MAX_PATH, TRUE)) // bDisplayError == TRUE
                        {
                            SetFocus(GetDlgItem(hDlg, IDC_ROUTE_FILE));
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }

                        CmStrTrim(szTemp);

                        if (-1 == GetTextFromControl(hDlg, IDC_ROUTE_URL, szUrlPath, MAX_PATH, TRUE)) // bDisplayError == TRUE
                        {
                            SetFocus(GetDlgItem(hDlg, IDC_ROUTE_URL));
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }

                        CmStrTrim(szUrlPath);

                        if ((TEXT('\0') == szTemp[0]) && (TEXT('\0') == szUrlPath[0]))
                        {
                            MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NEED_ROUTE_FILE, MB_OK));
 
                            SetFocus(GetDlgItem(hDlg, IDC_ROUTE_FILE));
 
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;                        
                        }

                        //
                        //  If they gave us a static route file then we need to verify it
                        //
                        if (TEXT('\0') != szTemp[0])
                        {
                            if (!VerifyFile(hDlg, IDC_ROUTE_FILE, g_szCmRouteFile, TRUE))
                            {
                                SetFocus(GetDlgItem(hDlg, IDC_ROUTE_FILE));
                                return TRUE;
                            }
                            else
                            {
                                //
                                //  Lets copy the route file to the temp dir
                                //
                                wsprintf(szTemp, TEXT("%s\\%s"), g_szTempDir, GetName(g_szCmRouteFile));

                                if (0 != lstrcmpi(szTemp, g_szCmRouteFile))
                                {
                                    MYVERIFY(TRUE == CopyFileWrapper(g_szCmRouteFile, szTemp, FALSE));
                                    MYVERIFY(0 != SetFileAttributes(szTemp, FILE_ATTRIBUTE_NORMAL));
                                }
                            }
                        }
                        else
                        {
                            g_szCmRouteFile[0] = TEXT('\0');
                        }

                        //
                        //  If they gave us a route URL then we need to make sure it starts with
                        //  http:// or https:// or file://, basically that it contains ://.  Note we
                        //  really don't do any validation here under the assumption that they will discover
                        //  it doesn't work when they test it if the URL is invalid.
                        //
                        if ((szUrlPath[0]) && (NULL == CmStrStr(szUrlPath, TEXT("://"))))
                        {
                            lstrcpy (szTemp, szUrlPath);
                            wsprintf (szUrlPath, TEXT("http://%s"), szTemp);
                        }

                        bDisconnectIfUrlUnavailable = (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_CHECK1)); // note we don't write this if we don't have a URL path

                        //
                        //  Now we have all of the data we need, lets build the custom action struct and then
                        //  either edit it or add it depending on whether it already exists or not.
                        //
                        MYVERIFY(0 != LoadString(g_hInstance, IDS_CMROUTE_DESC, szTemp, CELEMS(szTemp)));

                        hr = g_pCustomActionList->GetExistingActionData(g_hInstance, szTemp, ONCONNECT, &pCmRouteCustomAction);

                        if (SUCCEEDED(hr))
                        {
                            FillInCustomActionStructWithCmRoute(&UpdatedCmRouteAction,
                                                                bDisconnectIfUrlUnavailable, szUrlPath, GetName(g_szCmRouteFile));

                            hr = g_pCustomActionList->Edit(g_hInstance, pCmRouteCustomAction, &UpdatedCmRouteAction, g_szShortServiceName);
                            MYVERIFY(SUCCEEDED(hr));

                            CmFree(UpdatedCmRouteAction.pszParameters);
                            UpdatedCmRouteAction.pszParameters = NULL;
                            CmFree(pCmRouteCustomAction->pszParameters);
                            CmFree(pCmRouteCustomAction);
                        }
                        else
                        {
                            FillInCustomActionStructWithCmRoute(&UpdatedCmRouteAction,
                                                                bDisconnectIfUrlUnavailable, szUrlPath, GetName(g_szCmRouteFile));

                            hr = g_pCustomActionList->Add(g_hInstance, &UpdatedCmRouteAction, g_szShortServiceName);
                            MYVERIFY(SUCCEEDED(hr));

                            CmFree(UpdatedCmRouteAction.pszParameters);
                            UpdatedCmRouteAction.pszParameters = NULL;
                        }
                    }
                    else
                    {
                        //
                        //  Clear out the global route file path
                        //
                        g_szCmRouteFile[0] = TEXT('\0');

                        //
                        //  The user doesn't want cmroute.  Delete it from the connect action list.
                        //

                        MYVERIFY(0 != LoadString(g_hInstance, IDS_CMROUTE_DESC, szTemp, CELEMS(szTemp)));

                        if (szTemp[0])
                        {
                            hr = g_pCustomActionList->Delete(g_hInstance, szTemp, ONCONNECT);
                        }                    
                    }
                    break;

                default:
                    return FALSE;
            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

void EnableDisableRealmControls(HWND hDlg)
{
    BOOL bRealmControlsEnabled = (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_RADIO2));
    HWND hControl;

    hControl = GetDlgItem(hDlg, IDC_EDIT1);
    if (hControl)
    {
        EnableWindow(hControl, bRealmControlsEnabled);
    }

    hControl = GetDlgItem(hDlg, IDC_REALMNAME);
    if (hControl)
    {
        EnableWindow(hControl, bRealmControlsEnabled);
    }
    
    hControl = GetDlgItem(hDlg, IDC_RADIO3);
    if (hControl)
    {
        EnableWindow(hControl, bRealmControlsEnabled);
    }

    hControl = GetDlgItem(hDlg, IDC_RADIO4);
    if (hControl)
    {
        EnableWindow(hControl, bRealmControlsEnabled);
    }

    hControl = GetDlgItem(hDlg, IDC_REALM_SEP);
    if (hControl)
    {
        EnableWindow(hControl, bRealmControlsEnabled);
    }    
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessRealmInfo
//
// Synopsis:  Add a Realm Name
//
// History:   quintinb  Created Header and renamed from ProcessPage2B    8/6/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessRealmInfo(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    NMHDR* pnmHeader = (NMHDR*)lParam;
    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_REALM)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_EDIT1);

    switch (message)
    {
        case WM_INITDIALOG:
            break;

        case WM_COMMAND:
            switch (LOWORD(wParam)) 
            {
                case IDC_RADIO1:  //  Do not Add a Realm Name
                case IDC_RADIO2:  //  Add a Realm Name

                    EnableDisableRealmControls(hDlg);
                    break;

                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));

                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:

                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));
                    
                    //
                    //  The next two calls to GetPrivateProfileString could return empty strings, thus don't use MYVERIFY macro
                    //

                    ZeroMemory(g_szPrefix, sizeof(g_szPrefix));
                    GetPrivateProfileString(c_pszCmSection, c_pszCmEntryUserPrefix, TEXT(""), 
                        g_szPrefix, CELEMS(g_szPrefix), g_szCmsFile);  //lint !e534
                    
                    ZeroMemory(g_szSuffix, sizeof(g_szSuffix));
                    GetPrivateProfileString(c_pszCmSection, c_pszCmEntryUserSuffix, TEXT(""), 
                        g_szSuffix, CELEMS(g_szSuffix), g_szCmsFile);  //lint !e534
                    
                    if (*g_szSuffix)
                    {
                        MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO1, IDC_RADIO2, IDC_RADIO2));
                        MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO3, IDC_RADIO4, IDC_RADIO4));

                        MYVERIFY(TRUE == SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)MAX_PATH, (LPARAM) g_szSuffix));
                    }
                    else if (*g_szPrefix)
                    {                            
                        MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO1, IDC_RADIO2, IDC_RADIO2));
                        MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO3, IDC_RADIO4, IDC_RADIO3));

                        MYVERIFY(TRUE == SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)MAX_PATH, (LPARAM) g_szPrefix));
                    }
                    else
                    {
                        MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO1, IDC_RADIO2, IDC_RADIO1));
                        MYVERIFY(TRUE == SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)MAX_PATH, (LPARAM)TEXT("")));

                        //
                        //  Suffix is the default, set this just in case the user adds a suffix or prefix
                        //
                        MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO3, IDC_RADIO4, IDC_RADIO4));
                    }

                    EnableDisableRealmControls(hDlg);

                    break;

                case PSN_WIZBACK:

                case PSN_WIZNEXT:

                    //
                    //  First check if IDC_RADIO1 is checked, if so that means that the user
                    //  doesn't want Realm info
                    //

                    if (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_RADIO1))
                    {
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection,c_pszCmEntryUserPrefix,TEXT(""),g_szCmsFile));
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection,c_pszCmEntryUserSuffix,TEXT(""),g_szCmsFile));
                        g_szSuffix[0] = TEXT('\0');
                        g_szPrefix[0] = TEXT('\0');                    
                    }
                    else if (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_RADIO2))
                    {
                        //
                        //  If Radio2 is checked then they do want Realm info and we need to 
                        //  see if the string exists and if it is convertable to ANSI form.
                        //
                        if (-1 == GetTextFromControl(hDlg, IDC_EDIT1, szTemp, MAX_PATH, TRUE)) // bDisplayError == TRUE
                        {
                            SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }

                        CmStrTrim(szTemp);

                        if (TEXT('\0') == szTemp[0])
                        {
                            MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NOREALM, MB_OK));
 
                            SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
 
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;                        
                        }
                    
                        //
                        //  Now check to see if this is a Prefix or a Suffix
                        //
                        if (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_RADIO3)) // Prefix
                        {
                            _tcscpy(g_szPrefix, szTemp);
                            g_szSuffix[0] = TEXT('\0');

                            MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryUserPrefix, g_szPrefix, g_szCmsFile));
                            MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryUserSuffix, TEXT(""), g_szCmsFile));                            
                        }
                        else if (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_RADIO4)) // Suffix
                        {
                            _tcscpy(g_szSuffix, szTemp);
                            g_szPrefix[0] = TEXT('\0');

                            MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryUserSuffix, g_szSuffix, g_szCmsFile));
                            MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryUserPrefix, TEXT(""), g_szCmsFile));
                        }
                        else
                        {
                            CMASSERTMSG(FALSE, TEXT("ProcessRealmInfo -- Unknown State, bailing"));
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;                        
                        }
                    }
                    else
                    {
                        CMASSERTMSG(FALSE, TEXT("ProcessRealmInfo -- Unknown State, bailing"));
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                        return 1;
                    }
                    break;

                default:
                    return FALSE;
            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

void RefreshList(HWND hwndDlg, UINT uCrtlId, ListBxList * HeadPtr)
{
    ListBxList * LoopPtr;

    SendDlgItemMessage(hwndDlg, IDC_LIST1, LB_RESETCONTENT, 0, (LPARAM)0); //lint !e534 LB_RESETCONTENT doesn't return anything
    
    if (HeadPtr == NULL)
    {
        return;
    }

    LoopPtr = HeadPtr;

    while( LoopPtr != NULL)
    {
        MYVERIFY(LB_ERR != SendDlgItemMessage(hwndDlg, uCrtlId, LB_ADDSTRING, 0, 
            (LPARAM)LoopPtr->szName));

        LoopPtr = LoopPtr->next;
    }
}

void RefreshComboList(HWND hwndDlg, ListBxList * HeadPtr)
{
    ListBxList * LoopPtr;

    SendDlgItemMessage(hwndDlg,IDC_COMBO1,CB_RESETCONTENT,0,(LPARAM)0); //lint !e534 CB_RESETCONTENT doesn't return anything useful
    if (HeadPtr == NULL)
    {
        return;
    }
    LoopPtr = HeadPtr;
    while( LoopPtr != NULL)
    {
        MYVERIFY(CB_ERR != SendDlgItemMessage(hwndDlg, IDC_COMBO1, CB_ADDSTRING, 0, 
            (LPARAM)LoopPtr->szName));

        LoopPtr = LoopPtr->next;
    }
}

void FreeList(ListBxList ** pHeadPtr, ListBxList ** pTailPtr)
{
    ListBxList * pTmpPtr;
    ListBxList * pLoopPtr = *pHeadPtr;

    while(NULL != pLoopPtr)
    {
        CmFree(pLoopPtr->ListBxData);
        pTmpPtr = pLoopPtr;
    
        pLoopPtr = pLoopPtr->next;

        CmFree(pTmpPtr);
    }

    *pHeadPtr = NULL;
    *pTailPtr = NULL;
}

//+----------------------------------------------------------------------------
//
// Function:  MoveCmsFile
//
// Synopsis:  This function checks a referenced CMS file to see if it contains
//            script files.  If the CMS file contains script files, then it
//            copies them to the temporary directory and adds a referenced
//            file entry to the g_pHeadRefs linked list.
//
// Arguments: LPTSTR szFile - name of the cms file to move
//
// Returns:   BOOL - returns TRUE on Success
//
// History:   quintinb Created Header                           01/09/98
//            quintinb rewrote for the Unicode Converversion    06/14/99
//            quintinb updated for rewrite of DUN settings      03/21/00
//
//+----------------------------------------------------------------------------
BOOL MoveCmsFile(LPCTSTR pszCmsFile, LPCTSTR pszShortServiceName)
{
    BOOL bReturn = TRUE;
    ListBxList* pTmpHeadDns = NULL;
    ListBxList*  pTmpTailDns = NULL;
    ListBxList* pTmpCurrentDns = NULL;
    CDunSetting* pTmpDunSetting = NULL;
    TCHAR szFileName[MAX_PATH+1];
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szDest[MAX_PATH+1];

    if ((NULL == pszCmsFile) || (NULL == pszShortServiceName) || 
        (TEXT('\0') == pszCmsFile[0]) || (TEXT('\0') == pszShortServiceName[0]))
    {
        return FALSE;    
    }

    //
    //  Get the Long Service Name from the profile just in case we need a default entry.  
    //
    GetPrivateProfileString(c_pszCmSection, c_pszCmEntryServiceName, 
    TEXT(""), szTemp, CELEMS(szTemp), pszCmsFile);   //lint !e534

    if (ReadNetworkSettings(pszCmsFile, szTemp, TEXT(""),  &pTmpHeadDns, &pTmpTailDns, g_szOsdir, FALSE)) // FALSE == bLookingForVpnEntries
    {
        if (NULL != pTmpHeadDns) // just return TRUE if no entries
        {
            pTmpCurrentDns = pTmpHeadDns;
            
            while (pTmpCurrentDns && pTmpCurrentDns->ListBxData)
            {
                pTmpDunSetting = (CDunSetting*)pTmpCurrentDns->ListBxData;

                if (TEXT('\0') != pTmpDunSetting->szScript[0])
                {
                    //
                    //  Then we have a script, lets copy it and then add it to the g_pHeadRefs List
                    //
                    GetFileName(pTmpDunSetting->szScript, szFileName);

                    MYVERIFY(CELEMS(szDest) > (UINT)wsprintf(szDest, TEXT("%s\\%s"), 
                                                             g_szOutdir, szFileName));
                    //
                    // Copy the Script File
                    //
                    if (CopyFileWrapper(pTmpDunSetting->szScript, szDest, FALSE))
                    {
                        MYVERIFY(0 != SetFileAttributes(szDest, FILE_ATTRIBUTE_NORMAL));
            
                        //
                        //  Add the file to the Referenced files list
                        //
                        bReturn = bReturn && createListBxRecord(&g_pHeadRefs, &g_pTailRefs, 
                                                                (void *)NULL, 0, szFileName);
            
                        //
                        //  Update the script section in the existing cms to point 
                        //  to the new directory.
                        //  Originally: [Scripting&Merge Profile Name]
                        //              Name=merge\script.scp
                        //  Becomes:    [Scripting&Merge Profile Name]
                        //              Name=toplvl\script.scp
                        //
                        //  Note the change in directory name so that the script file 
                        //  can be found.
                        //
                        TCHAR szSection[MAX_PATH+1];
                        MYVERIFY(CELEMS(szSection) > (UINT)wsprintf(szSection, TEXT("%s&%s"), 
                                                                    c_pszCmSectionDunScripting, 
                                                                    pTmpCurrentDns->szName));

                        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s"), 
                                                                 pszShortServiceName, szFileName));

                        MYVERIFY(0 != WritePrivateProfileString(szSection, 
                                                                c_pszCmEntryDunScriptingName, 
                                                                szTemp, pszCmsFile));
                    }
                }

                pTmpCurrentDns = pTmpCurrentDns->next;
            }
        }
    }
    else
    {
        CMTRACE1(TEXT("MoveCmsFile -- ReadDnsList Failed.  GetLastError Returns %d"), GetLastError());
        bReturn = FALSE;
        goto exit;
    }


exit:
    //
    //  Free the DNS List
    //

    FreeDnsList(&pTmpHeadDns, &pTmpTailDns);
    return (bReturn);
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessDunEntries
//
// Synopsis:  Set up Dial-up networking
//
// History:   quintinb  Created Header and renamed from ProcessPage2C  8/6/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessDunEntries(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    //
    //  We have a static Memory buffer and a static pointer
    //  so that we can know when the user has changed the phonebook
    //  on us (meaning we need to reread the Networking settings).
    //  Note that we use the static pointer to tell us if we have read
    //  the settings at least once.
    //
    static TCHAR szCachedPhoneBook[MAX_PATH+1] = {0};
    static TCHAR* pszCachedPhoneBook = NULL;
    NMHDR* pnmHeader = (NMHDR*)lParam;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_DENTRY)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_LIST1);

    switch (message)
    {
        case WM_INITDIALOG:
            break;

        case WM_COMMAND:
            switch (LOWORD(wParam)) 
            {
                case IDC_BUTTON1: //add
                    OnProcessDunEntriesAdd(g_hInstance, hDlg, IDC_LIST1, &g_pHeadDunEntry, &g_pTailDunEntry, FALSE, g_szLongServiceName, g_szCmsFile); // FALSE == bCreateTunnelEntry
                    return TRUE;

                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case IDC_BUTTON2: //edit
                    OnProcessDunEntriesEdit(g_hInstance, hDlg, IDC_LIST1, &g_pHeadDunEntry, &g_pTailDunEntry, g_szLongServiceName, g_szCmsFile);

                    return TRUE;

                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case IDC_BUTTON3: //delete
                    OnProcessDunEntriesDelete(g_hInstance, hDlg, IDC_LIST1, &g_pHeadDunEntry, &g_pTailDunEntry, g_szLongServiceName, g_szCmsFile);
                    return TRUE;

                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case IDC_LIST1:
                    if (LBN_SELCHANGE == HIWORD(wParam))
                    {
                        //
                        //  The selection in the listbox changed, lets figure out if we need to
                        //  enable/disable the delete button
                        //
                        EnableDisableDunEntryButtons(g_hInstance, hDlg, g_szCmsFile, g_szLongServiceName);
                    }
                    else if (LBN_DBLCLK == HIWORD(wParam))
                    {
                        OnProcessDunEntriesEdit(g_hInstance, hDlg, IDC_LIST1, &g_pHeadDunEntry, &g_pTailDunEntry, g_szLongServiceName, g_szCmsFile);                    
                    }
                    break;

                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));

                    //
                    //  To avoid reading the network settings more than we have to, we only want to
                    //  read the networking settings the first time the users hits this page or any
                    //  time the user changes the phonebook (if they clone the profile or edit a different
                    //  one, clearing this will be taken care of elsewhere).
                    //
                    if ((NULL == g_pHeadDunEntry) || (NULL == pszCachedPhoneBook) || lstrcmpi(g_szPhonebk, pszCachedPhoneBook))
                    {

                        FreeDnsList(&g_pHeadDunEntry, &g_pTailDunEntry);

                        MYVERIFY(ReadNetworkSettings(g_szCmsFile, g_szLongServiceName, g_szPhonebk, &g_pHeadDunEntry, &g_pTailDunEntry, g_szOsdir, FALSE)); //FALSE == bLookingForVpnEntries

                        pszCachedPhoneBook = szCachedPhoneBook;
                        lstrcpy(pszCachedPhoneBook, g_szPhonebk);
                    }

                    RefreshDnsList(g_hInstance, hDlg, IDC_LIST1, g_pHeadDunEntry, g_szLongServiceName, g_szCmsFile, NULL);
                    SetFocus(GetDlgItem(hDlg, IDC_BUTTON1));
                    EnableDisableDunEntryButtons(g_hInstance, hDlg, g_szCmsFile, g_szLongServiceName);

                    break;

                case PSN_WIZBACK:
                case PSN_WIZNEXT:

                    //
                    //  Before writing out the entries we must make sure that we don't have a name collision with entries
                    //  from the VPN list.  Thus we will check each name in the DUN entries list for a matching name in the
                    //  VPN entries list.  If we detect a collision, then we will throw an error message to the user and
                    //  let them deal with the problem.
                    //
                    if (!CheckForDUNversusVPNNameConflicts(hDlg, g_pHeadDunEntry, g_pHeadVpnEntry))
                    {
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                        return 1;
                    }

                    //
                    //  Now it is okay to write out the networking entries
                    //
                    WriteNetworkingEntries(g_szCmsFile, g_szLongServiceName, g_szShortServiceName, g_pHeadDunEntry);

                    //
                    //  If we aren't updating the phonebook then we need to go right back to the phonebook page
                    //  and skip the pbk update page
                    //
                    if (pnmHeader && (PSN_WIZBACK == pnmHeader->code) && !g_bUpdatePhonebook) 
                    {                        
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, IDD_PHONEBOOK));
                    }
                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}


//+----------------------------------------------------------------------------
//
// Function:  DoesSomeVPNsettingUsePresharedKey
//
// Synopsis:  Checks VPN DUN settings to see if any chose to use a preshared key
//
// Returns:   BOOL (TRUE if some VPN setting does use a pre-shared key)
//
// History:   25-Apr-2001   SumitC    Created
//
//+----------------------------------------------------------------------------
BOOL DoesSomeVPNsettingUsePresharedKey()
{
    BOOL         bReturn = FALSE;
    ListBxList * ptr = g_pHeadVpnEntry;

    if (g_bUseTunneling)
    {
        while (ptr != NULL)
        {
            CDunSetting * pDunSetting = (CDunSetting*)(ptr->ListBxData);

            if (pDunSetting && pDunSetting->bUsePresharedKey)
            {
                bReturn = TRUE;
                break;
            }
            ptr = ptr->next;
        }
    }

    return bReturn;
}


INT_PTR APIENTRY ProcessVpnEntries(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    //
    //  We have a static Memory buffer and a static pointer
    //  so that we can know when the user has changed the phonebook
    //  on us (meaning we need to reread the Networking settings).
    //  Note that we use the static pointer to tell us if we have read
    //  the settings at least once.
    //
    BOOL bFreeDunList = FALSE;
    static TCHAR szCachedPhoneBook[MAX_PATH+1] = {0};
    static TCHAR* pszCachedPhoneBook = NULL;
    NMHDR* pnmHeader = (NMHDR*)lParam;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_VENTRY)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_LIST1);

    switch (message)
    {
        case WM_INITDIALOG:
            break;

        case WM_COMMAND:
            switch (LOWORD(wParam)) 
            {
                case IDC_BUTTON1: //add
                    OnProcessDunEntriesAdd(g_hInstance, hDlg, IDC_LIST1, &g_pHeadVpnEntry, &g_pTailVpnEntry, TRUE, g_szLongServiceName, g_szCmsFile); // TRUE == bCreateTunnelEntry
                    return TRUE;

                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case IDC_BUTTON2: //edit
                    OnProcessDunEntriesEdit(g_hInstance, hDlg, IDC_LIST1, &g_pHeadVpnEntry, &g_pTailVpnEntry, g_szLongServiceName, g_szCmsFile);

                    return TRUE;

                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case IDC_BUTTON3: //delete
                    OnProcessDunEntriesDelete(g_hInstance, hDlg, IDC_LIST1, &g_pHeadVpnEntry, &g_pTailVpnEntry, g_szLongServiceName, g_szCmsFile);
                    return TRUE;

                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case IDC_LIST1:
                    if (LBN_SELCHANGE == HIWORD(wParam))
                    {
                        //
                        //  The selection in the listbox changed, lets figure out if we need to
                        //  enable/disable the delete button
                        //
                        EnableDisableDunEntryButtons(g_hInstance, hDlg, g_szCmsFile, g_szLongServiceName);
                    }
                    else if (LBN_DBLCLK == HIWORD(wParam))
                    {
                        OnProcessDunEntriesEdit(g_hInstance, hDlg, IDC_LIST1, &g_pHeadVpnEntry, &g_pTailVpnEntry, g_szLongServiceName, g_szCmsFile);                    
                    }
                    break;

                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));

                    //
                    //  To avoid reading the network settings more than we have to, we only want to
                    //  read the networking settings the first time the users hits this page or any
                    //  time the user changes the VPN File (if they clone the profile or edit a different
                    //  one, clearing this will be taken care of elsewhere).
                    //
                    if ((NULL == g_pHeadVpnEntry) || (NULL == pszCachedPhoneBook) || lstrcmpi(g_szVpnFile, pszCachedPhoneBook))
                    {
                        FreeDnsList(&g_pHeadVpnEntry, &g_pTailVpnEntry);

                        MYVERIFY(ReadNetworkSettings(g_szCmsFile, g_szLongServiceName, g_szVpnFile, &g_pHeadVpnEntry, &g_pTailVpnEntry, g_szOsdir, TRUE)); //TRUE == bLookingForVpnEntries

                        pszCachedPhoneBook = szCachedPhoneBook;
                        lstrcpy(pszCachedPhoneBook, g_szVpnFile);
                    }

                    RefreshDnsList(g_hInstance, hDlg, IDC_LIST1, g_pHeadVpnEntry, g_szLongServiceName, g_szCmsFile, NULL);
                    SetFocus(GetDlgItem(hDlg, IDC_BUTTON1));
                    EnableDisableDunEntryButtons(g_hInstance, hDlg, g_szCmsFile, g_szLongServiceName);

                    break;

                case PSN_WIZBACK:
                case PSN_WIZNEXT:

                    //
                    //  Before writing out the entries we must make sure that we don't have a name collision with entries
                    //  from the DUN list.  Thus we will check each name in the VPN entries list for a matching name in the
                    //  DUN entries list.  If we detect a collision, then we will throw an error message to the user and
                    //  let them deal with the problem.  One further complication here is that the DUN entries list may not be
                    //  read in yet and we can't read it in permanently in that case since the phonebook may not have been
                    //  given yet or may change.  Thus we will read in a temp copy to compare against if the list pointer is NULL.
                    //

                    if (NULL == g_pHeadDunEntry)
                    {
                        bFreeDunList = TRUE;
                        MYVERIFY(ReadNetworkSettings(g_szCmsFile, g_szLongServiceName, g_szPhonebk, &g_pHeadDunEntry, &g_pTailDunEntry, g_szOsdir, FALSE)); //FALSE == bLookingForVpnEntries
                    }

                    if (!CheckForDUNversusVPNNameConflicts(hDlg, g_pHeadDunEntry, g_pHeadVpnEntry))
                    {
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                        return 1;
                    }

                    if (bFreeDunList)
                    {
                        FreeDnsList(&g_pHeadDunEntry, &g_pTailDunEntry);
                    }

                    //
                    //  Okay, now it's safe to write out the entries
                    //
                    WriteNetworkingEntries(g_szCmsFile, g_szLongServiceName, g_szShortServiceName, g_pHeadVpnEntry);

                    //
                    //  If any of the VPN dun settings has Pre-shared key enabled, go to the Pre-Shared key page
                    //
                    if (g_pHeadVpnEntry)
                    {
                        //
                        //  If we are going forward, skip the Pre-shared key page if
                        //  no DUN entries have Preshared key enabled.
                        //
                        g_bPresharedKeyNeeded = DoesSomeVPNsettingUsePresharedKey();
                        if (pnmHeader && (PSN_WIZNEXT == pnmHeader->code) && !g_bPresharedKeyNeeded)
                        {
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, IDD_PHONEBOOK));
                        }
                    }
                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

void EnableDisableTunnelAddressControls(HWND hDlg)
{
    BOOL bEnabledTunnelControls = IsDlgButtonChecked(hDlg, IDC_CHECK1) || IsDlgButtonChecked(hDlg, IDC_CHECK2);
    BOOL bUseVpnFile = (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_RADIO2));

    //
    //  Enable/Disable the single VPN Server Edit control
    //
    HWND hControl = GetDlgItem(hDlg, IDC_RADIO1);
    EnableWindow(hControl, bEnabledTunnelControls);

    hControl = GetDlgItem(hDlg, IDC_EDIT1);
    EnableWindow(hControl, (bEnabledTunnelControls && !bUseVpnFile));

    //
    //  Enable/Disable the VPN File edit control, and browse button
    //
    hControl = GetDlgItem(hDlg, IDC_RADIO2);
    EnableWindow(hControl, bEnabledTunnelControls);

    hControl = GetDlgItem(hDlg, IDC_EDIT2);
    EnableWindow(hControl, (bEnabledTunnelControls && bUseVpnFile));

    hControl = GetDlgItem(hDlg, IDC_BUTTON1);
    EnableWindow(hControl, bEnabledTunnelControls);

    //
    //  Enable/Disable the use same username checkbox
    //
    hControl = GetDlgItem(hDlg, IDC_CHECK3);
    EnableWindow(hControl, bEnabledTunnelControls);
}


//+----------------------------------------------------------------------------
//
// Function:  ProcessTunneling
//
// Synopsis:  Setup Tunneling
//
//
// History:   quintinb  Created Header and renamed from ProcessPage2E    8/6/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessTunneling(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    UINT uEditControl = 0;
    UINT uRadioButton = 0;
    UINT uMissingMsgId = 0;
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szTempVpnFile[MAX_PATH+1];
    NMHDR* pnmHeader = (NMHDR*)lParam;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_SECURE)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;

    switch (message)
    {

    case WM_INITDIALOG:

            SetFocus(GetDlgItem(hDlg, IDC_CHECK1));
            break;

        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_RADIO1:
                case IDC_RADIO2:
                case IDC_CHECK1:
                case IDC_CHECK2:
                    EnableDisableTunnelAddressControls(hDlg);                    
                    break;

                case IDC_BUTTON1: // Browse button
                    {

                        //
                        //  If the user clicked the browse button without clicking the VPN File radio button,
                        //  then we need to set the radio and make sure the other controls are
                        //  enabled.
                        //
                        MYVERIFY(0 != CheckRadioButton(hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO2));
                        EnableDisableTunnelAddressControls(hDlg);

                        UINT uFilter = IDS_TXTFILTER;
                        TCHAR* pszMask = TEXT("*.txt");
                                          
                        int iTemp = DoBrowse(hDlg, &uFilter, &pszMask, 1, IDC_EDIT2, TEXT("txt"), g_szLastBrowsePath);

                        MYDBGASSERT(0 != iTemp);

                        if (0 < iTemp) // -1 means the user cancelled
                        {
                            //
                            //  We want to copy the full path to the filename into g_szVpnFile so
                            //  that we have it for later in case the user wants to include it in the profile.
                            //
                            lstrcpy (g_szVpnFile, g_szLastBrowsePath);

                            //
                            //  We also want to save the last browse path so that when the user next
                            //  opens the browse dialog they will be in the same place they last
                            //  browsed from.
                            //
                            LPTSTR pszLastSlash = CmStrrchr(g_szLastBrowsePath, TEXT('\\'));

                            if (pszLastSlash)
                            {
                                pszLastSlash = CharNext(pszLastSlash);
                                *pszLastSlash = TEXT('\0');
                            }
                            else
                            {
                                g_szLastBrowsePath[0] = TEXT('\0');                        
                            }        
                        }
                    }
                    break;

                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {
                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                                        
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));
                    
                    //
                    //  Is this a tunneling profile?  If so, check the tunnel this profile checkbox
                    //
                    MYVERIFY(0 != GetPrivateProfileString(c_pszCmSection, 
                        c_pszCmEntryTunnelPrimary, c_pszZero, szTemp, CELEMS(szTemp), g_szCmsFile));
                    
                    MYVERIFY(0 != CheckDlgButton(hDlg,IDC_CHECK1,(*szTemp == TEXT('1'))));

                    //
                    //  If we have merged profiles and the profile has tunnel references turned on then
                    //  we want to check the tunnel references checkbox.
                    //
                    if (g_pHeadMerge == NULL)
                    {
                        MYVERIFY(0 != CheckDlgButton(hDlg,IDC_CHECK2,FALSE));
                        EnableWindow(GetDlgItem(hDlg,IDC_CHECK2),FALSE);
                    }
                    else
                    {
                        EnableWindow(GetDlgItem(hDlg,IDC_CHECK2),TRUE);
                        MYVERIFY(0 != GetPrivateProfileString(c_pszCmSection, c_pszCmEntryTunnelReferences, 
                            c_pszZero, szTemp, CELEMS(szTemp), g_szCmsFile));
                        MYVERIFY(0 != CheckDlgButton(hDlg,IDC_CHECK2,(*szTemp == TEXT('1'))));
                    }

                    //
                    //  Now we need to decide if we have a VPN File for this profile or just a single
                    //  Tunnel Address.  First try the TunnelFile entry.
                    //
                    szTemp[0] = TEXT('\0');
                    szTempVpnFile[0] = TEXT('\0');

                    GetPrivateProfileString(c_pszCmSection, c_pszCmEntryTunnelFile, TEXT(""), 
                        szTempVpnFile, CELEMS(szTempVpnFile), g_szCmsFile);    //lint !e534

                    if (TEXT('\0') != szTempVpnFile[0])
                    {
                        //
                        //  The VpnFile text should be a relative path (corpras\vpn.txt) and
                        //  thus we will want to add the path to the profile dir in front of it.
                        //
                        wsprintf(g_szVpnFile, TEXT("%s%s"), g_szOsdir, szTempVpnFile);

                        //
                        //  Now verify that this exists
                        //
                        if (FileExists(g_szVpnFile))
                        {
                            LPTSTR pszSlash = CmStrrchr(g_szVpnFile, TEXT('\\'));

                            if (pszSlash)
                            {
                                pszSlash = CharNext(pszSlash);
                                lstrcpy(szTempVpnFile, pszSlash);                        
                            }                        
                        }
                        else
                        {
                            //
                            //  This might just mean that the file is in the temp dir and we haven't
                            //  created a dir under profiles yet ... Lets try looking for the file
                            //  in the temp dir instead.
                            //
                            LPTSTR pszSlash = CmStrrchr(g_szVpnFile, TEXT('\\'));

                            if (pszSlash)
                            {
                                pszSlash = CharNext(pszSlash);
                                lstrcpy(szTempVpnFile, pszSlash);                        
                            }
                            
                            wsprintf(g_szVpnFile, TEXT("%s\\%s"), g_szTempDir, szTempVpnFile);
                            
                            if (!FileExists(g_szVpnFile))
                            {
                                //
                                //  Well, we still didn't find it.  Looks like the user has us baffled at this point.
                                //  Clear out the buffers and the user will be forced to fill in the correct
                                //  file path before continuing.
                                //
                                g_szVpnFile[0] = TEXT('\0');
                                szTempVpnFile[0] = TEXT('\0');                            
                            }
                        }

                        uRadioButton = IDC_RADIO2;
                    }
                    else
                    {
                        //
                        //  We didn't get a VPN file so lets try for a Tunnel Address
                        //
                        GetPrivateProfileString(c_pszCmSection, c_pszCmEntryTunnelAddress, TEXT(""), 
                            szTemp, CELEMS(szTemp), g_szCmsFile);    //lint !e534

                        uRadioButton = IDC_RADIO1;
                    }

                    //
                    //  Now fill in one of the edit controls and set a Radio Button
                    //
                    MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDIT1), WM_SETTEXT, 0, (LPARAM)szTemp));
                    MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDIT2), WM_SETTEXT, 0, (LPARAM)szTempVpnFile));

                    MYVERIFY(0 != CheckRadioButton(hDlg, IDC_RADIO1, IDC_RADIO2, uRadioButton));
                    
                    //
                    //  Now get the UseSameUserName value and set that as appropriate
                    //
                    MYVERIFY(0 != GetPrivateProfileString(c_pszCmSection, 
                        c_pszCmEntryUseSameUserName, c_pszZero, szTemp, CELEMS(szTemp), g_szCmsFile));
                    
                    g_bUseSamePwd = (*szTemp == TEXT('1'));
                    
                    MYVERIFY(0 != CheckDlgButton(hDlg, IDC_CHECK3, (UINT)g_bUseSamePwd));

                    EnableDisableTunnelAddressControls(hDlg);
                    break;

                case PSN_WIZBACK:

                case PSN_WIZNEXT:

                    //
                    //  Read the checkboxes to figure out if we are tunneling or not
                    //
                    if (IsDlgButtonChecked(hDlg,IDC_CHECK1))
                    {
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryTunnelPrimary, c_pszOne, g_szCmsFile));
                    }
                    else
                    {
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryTunnelPrimary, c_pszZero, g_szCmsFile));
                    }

                    if (IsDlgButtonChecked(hDlg,IDC_CHECK2))
                    {
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryTunnelReferences, c_pszOne, g_szCmsFile));
                    }
                    else
                    {
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryTunnelReferences, c_pszZero, g_szCmsFile));
                    }

                    //
                    //  If we are tunneling then set the tunnel settings
                    //
                    if (IsDlgButtonChecked(hDlg,IDC_CHECK2) || IsDlgButtonChecked(hDlg,IDC_CHECK1))
                    {
                        g_bUseTunneling = TRUE;

                        //
                        //  Figure out if we are looking for a single tunnel address or a VPN file
                        //
                        if (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_RADIO1))
                        {
                            uEditControl = IDC_EDIT1;
                            uMissingMsgId = IDS_NOTUNNEL;
                            g_szVpnFile[0] = TEXT('\0');
                        }
                        else
                        {
                            uEditControl = IDC_EDIT2;
                            uMissingMsgId = IDS_NOTUNNELFILE;
                        }

                        //
                        //  Get the tunnel server address or VPN file
                        //
                        LRESULT lResult = GetTextFromControl(hDlg, uEditControl, szTemp, MAX_PATH, TRUE); // bDisplayError == TRUE
                        if (-1 == lResult)
                        {
                            SetFocus(GetDlgItem(hDlg, uEditControl));
                        
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));

                            return 1;
                        }
                        else if (0 == lResult)
                        {
                            szTemp[0] = TEXT('\0');
                        }
                        
                        //
                        //  Trim the string
                        //
                        CmStrTrim(szTemp);

                        //
                        //  Check to make sure that they actually gave us text
                        //
                        if (TEXT('\0') == szTemp[0])
                        {
                            MYVERIFY(IDOK == ShowMessage(hDlg, uMissingMsgId, MB_OK));

                            SetFocus(GetDlgItem(hDlg, uEditControl));
                        
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));

                            return 1;
                        }

                        //
                        //  If we have a VPN file, we need to verify it
                        //
                        if (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_RADIO2))
                        {
                            if (!VerifyFile(hDlg, IDC_EDIT2, g_szVpnFile, TRUE))
                            {
                                SetFocus(GetDlgItem(hDlg, IDC_EDIT2));
                                MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                                return TRUE;
                            }
                            else
                            {
                                //
                                //  We have now verified that we can find the file, but since
                                //  the user cannot enter their own tunnel address we need to
                                //  go one step further and make sure that there is at least one
                                //  tunnel address in the file.
                                //
                                if (!VerifyVpnFile(g_szVpnFile))
                                {
                                    MYVERIFY(IDOK == ShowMessage(hDlg, IDS_BADVPNFORMAT, MB_OK));
                                    SetFocus(GetDlgItem(hDlg, IDC_EDIT2));
                                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                                    return TRUE;
                                }

                                //
                                //  Lets copy the VPN file to the temp dir
                                //
                                wsprintf(szTemp, TEXT("%s\\%s"), g_szTempDir, GetName(g_szVpnFile));

                                if (0 != lstrcmpi(szTemp, g_szVpnFile))
                                {
                                    MYVERIFY(TRUE == CopyFileWrapper(g_szVpnFile, szTemp, FALSE));
                                    MYVERIFY(0 != SetFileAttributes(szTemp, FILE_ATTRIBUTE_NORMAL));
                                }
                            }
                        }

                        //
                        //  Write out the vpn file and tunnel address entries
                        //
                        if (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_RADIO1))
                        {
                            //
                            //  szTemp contains the tunnel address already, so just
                            //  clear the vpn file variable.
                            //
                            szTempVpnFile[0] = TEXT('\0');
                        }
                        else
                        {
                            //
                            // clear the tunnel address and set the vpn file
                            //
                            szTemp[0] = TEXT('\0');
                            wsprintf(szTempVpnFile, TEXT("%s\\%s"), g_szShortServiceName, GetName(g_szVpnFile));                     
                        }

                        //
                        //  Write out the tunnel address
                        //
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryTunnelAddress, szTemp, g_szCmsFile));

                        //
                        //  Write out the tunnel file
                        //
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryTunnelFile, szTempVpnFile, g_szCmsFile));


                        //
                        //  Set the name of the Tunnel Dun setting
                        //
                        MYVERIFY(0 != GetTunnelDunSettingName(g_szCmsFile, g_szLongServiceName, szTemp, CELEMS(szTemp)));
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryTunnelDun, szTemp, g_szCmsFile));
                        
                        //
                        //  Write out the use same user name value
                        //
                        g_bUseSamePwd = IsDlgButtonChecked(hDlg,IDC_CHECK3);

                        if (g_bUseSamePwd)
                        {
                            MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryUseSameUserName, c_pszOne, g_szCmsFile));
                        }
                        else
                        {
                            MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryUseSameUserName, c_pszZero, g_szCmsFile));
                        }
                    }
                    else
                    {
                        //
                        //  Set g_bUseTunneling to False but don't clear out the tunnel settings until the
                        //  user hits the finish button.  That way if they change their mind part way through
                        //  building the profile we don't throw away their settings.
                        //

                        g_bUseTunneling = FALSE;
                    }

                    //
                    //  Skip the VPN entries dialog if we don't have tunneling enabled.
                    //
                    if (pnmHeader && (PSN_WIZNEXT == pnmHeader->code) && !g_bUseTunneling) 
                    {                        
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, IDD_PHONEBOOK));
                    }
                    break;

                default:
                    return FALSE;
            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}


//+----------------------------------------------------------------------------
//
// Function:  ValidatePresharedKey
//
// Synopsis:  Checks the given pre-shared key for validity
//
// Arguments: pszPresharedKey - string to check
//
// Returns:   BOOL - TRUE => key is good, FALSE => bad
//
// History:   sumitc  Created     03/27/01
//
//+----------------------------------------------------------------------------
BOOL ValidatePresharedKey(LPTSTR pszPresharedKey)
{
    BOOL bReturn = FALSE;

    MYDBGASSERT(pszPresharedKey);

    if (pszPresharedKey && (TEXT('\0') != pszPresharedKey[0]) &&
        (lstrlen(pszPresharedKey) <= c_dwMaxPresharedKey))
    {
        bReturn = TRUE;
    }
    
    return bReturn;
}


//+----------------------------------------------------------------------------
//
// Function:  ValidatePresharedKeyPIN
//
// Synopsis:  Checks the given PIN for validity
//
// Arguments: pszPresharedKey - string to check
//
// Returns:   BOOL - TRUE => PIN is good, FALSE => bad
//
// History:   sumitc  Created     03/27/01
//
//+----------------------------------------------------------------------------
BOOL ValidatePresharedKeyPIN(LPTSTR pszPresharedKeyPIN)
{
    BOOL bReturn = FALSE;

    MYDBGASSERT(pszPresharedKeyPIN);

    if (pszPresharedKeyPIN && (TEXT('\0') != pszPresharedKeyPIN[0]) &&
        (lstrlen(pszPresharedKeyPIN) >= c_dwMinPresharedKeyPIN) &&
        (lstrlen(pszPresharedKeyPIN) <= c_dwMaxPresharedKeyPIN))
    {
        bReturn = TRUE;
    }
    
    return bReturn;
}


//+----------------------------------------------------------------------------
//
// Function:  EncryptPresharedKey
//
// Synopsis:  Encrypts the given key into a form that can be serialized.
//
// Arguments: szKey - key to encrypt
//            szPIN - pin to use as seed
//            ppszEncrypted - resultant string
//
// Returns:   BOOL - TRUE => successfully encrypted key, FALSE => failed
//
// History:   sumitc  Created     03/27/01
//
//+----------------------------------------------------------------------------
BOOL EncryptPresharedKey(IN  LPTSTR szKey,
                         IN  LPTSTR szPIN,
                         OUT LPTSTR * ppszEncrypted)
{
    BOOL bReturn = FALSE;
    DWORD dwLenEncrypted = 0;
    LPSTR pszAnsiEncrypted = NULL;

    MYDBGASSERT(ppszEncrypted);
    
    LPSTR pszAnsiKey = WzToSzWithAlloc(szKey);
    LPSTR pszAnsiPIN = WzToSzWithAlloc(szPIN);

    MYDBGASSERT(pszAnsiKey && pszAnsiPIN);
    if (ppszEncrypted && pszAnsiKey && pszAnsiPIN)
    {
        //
        //  Initialize
        //  
        InitSecure(FALSE);      // use secure, not fast encryption

        //
        //  Encrypt it
        //
        if (EncryptString(pszAnsiKey,
                          pszAnsiPIN,
                          (PBYTE*) &pszAnsiEncrypted,
                          &dwLenEncrypted,
#if defined(DEBUG) && defined(DEBUG_MEM)
                          (PFN_CMSECUREALLOC)AllocDebugMem, // Give the DEBUG_MEM version of alloc/free
                          (PFN_CMSECUREFREE)FreeDebugMem))  // Not quit right, AllocDebugMem takes 3 param
#else
                          (PFN_CMSECUREALLOC)CmMalloc,    // mem allocator
                          (PFN_CMSECUREFREE)CmFree))      // mem deallocator
#endif
        {
            bReturn = TRUE;
        }

        //
        //  Uninitialize
        //  
        DeInitSecure();

        if (bReturn)
        {
            *ppszEncrypted = SzToWzWithAlloc(pszAnsiEncrypted);
            ZeroMemory(pszAnsiEncrypted, lstrlenA(pszAnsiEncrypted) * sizeof(CHAR));
#if defined(DEBUG) && defined(DEBUG_MEM)
            FreeDebugMem(pszAnsiEncrypted);
#else
            CmFree(pszAnsiEncrypted);
#endif
        }
    }

    CmFree(pszAnsiKey);
    CmFree(pszAnsiPIN);

    return bReturn;
}


//+----------------------------------------------------------------------------
//
// Function:  EnableDisablePresharedKeyControls
//
// Synopsis:  Based on whether we have a key, set enabled/disabled state of UI
//
// History:   27-Mar-2001   SumitC    Created
//
//+----------------------------------------------------------------------------
void EnableDisablePresharedKeyControls(HWND hDlg, BOOL bEnable)
{
    //
    //  Enable edit controls and checkboxes
    //
    EnableWindow(GetDlgItem(hDlg, IDC_PRESHARED_KEY), bEnable);
    EnableWindow(GetDlgItem(hDlg, IDC_USEENCRYPTION), bEnable);
    EnableWindow(GetDlgItem(hDlg, IDC_PRESHARED_KEY_PIN), bEnable);
    if (bEnable)
    {
        CheckDlgButton(hDlg, IDC_USEENCRYPTION, TRUE);
    }

    //
    //  Either clear edit control or fill with info text
    //
    if (bEnable)
    {
        SendDlgItemMessage(hDlg, IDC_PRESHARED_KEY, WM_SETTEXT, 0, (LPARAM)TEXT(""));
        SetFocus(GetDlgItem(hDlg, IDC_PRESHARED_KEY));
    }
    else
    {
        LPTSTR pszTmp = CmLoadString(g_hInstance, IDS_PRESHAREDKEY_ALREADY);
        if (pszTmp)
        {
            SendDlgItemMessage(hDlg, IDC_PRESHARED_KEY, WM_SETTEXT, 0, (LPARAM)pszTmp);
        }
        CmFree(pszTmp);
    }

    //
    //  Show or hide the "Replace Key" button
    //
    ShowWindow(GetDlgItem(hDlg, IDC_REPLACE_PSK), !bEnable);
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessPresharedKey
//
// Synopsis:  Setup Pre-shared key usage for this profile
//
// History:   27-Mar-2001   SumitC    Created
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessPresharedKey(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    NMHDR* pnmHeader = (NMHDR*)lParam;
    static LPTSTR pszPresharedKey = NULL;
    static BOOL   bEncryptPresharedKey = FALSE;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_PRESHARED)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;

    switch (message)
    {
        case WM_INITDIALOG:
            //
            //  Set max text lengths for the edit controls
            //
            SendDlgItemMessage(hDlg, IDC_PRESHARED_KEY, EM_SETLIMITTEXT, (WPARAM)c_dwMaxPresharedKey, (LPARAM)0); //lint !e534 EM_SETLIMITTEXT doesn't return anything useful
            SendDlgItemMessage(hDlg, IDC_PRESHARED_KEY_PIN, EM_SETLIMITTEXT, (WPARAM)c_dwMaxPresharedKeyPIN, (LPARAM)0); //lint !e534 EM_SETLIMITTEXT doesn't return anything useful
            break;

        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_REPLACE_PSK:
                    if (IDYES == ShowMessage(hDlg, IDS_REALLY_REPLACE_PSK, MB_YESNO | MB_ICONWARNING))
                    {
                        CmFree(pszPresharedKey);
                        pszPresharedKey = NULL;
                        EnableDisablePresharedKeyControls(hDlg, TRUE);
                    }
                    break;

                case IDC_USEENCRYPTION:
                    EnableWindow(GetDlgItem(hDlg, IDC_PRESHARED_KEY_PIN), IsDlgButtonChecked(hDlg, IDC_USEENCRYPTION));
                    break;

                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {
                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:

                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));

                    CMASSERTMSG(g_bPresharedKeyNeeded, TEXT("we shouldn't get to this page otherwise."));

                    //
                    //  Read in the Pre-shared key and the flag that says if it's encrypted
                    //
                    pszPresharedKey = GetPrivateProfileStringWithAlloc(c_pszCmSection, c_pszCmEntryPresharedKey,
                                                                       TEXT(""), g_szCmpFile);    //lint !e534
                    bEncryptPresharedKey = (BOOL)GetPrivateProfileInt(c_pszCmSection, c_pszCmEntryKeyIsEncrypted,
                                                                      FALSE, g_szCmpFile);    //lint !e534

                    //
                    //  If we don't have a pre-shared key, hide the Replace button, and enable all
                    //  the other controls.  If we already have a pre-shared key, disable all the
                    //  controls and enable the Replace button.
                    //
                    EnableDisablePresharedKeyControls(hDlg, !pszPresharedKey);
                    break;

                case PSN_WIZBACK:
                    g_bPresharedKeyNeeded = FALSE;    // force this to be recomputed, since it can change if we go back

                    // fall through and verify pre-shared key as well

                case PSN_WIZNEXT:

                    if (NULL == pszPresharedKey)
                    {
                        TCHAR szPresharedKey[c_dwMaxPresharedKey + 1];
                        TCHAR szPresharedKeyPIN[c_dwMaxPresharedKeyPIN + 1];

                        //
                        //  verify Pre-shared Key
                        //
                        GetTextFromControl(hDlg, IDC_PRESHARED_KEY, szPresharedKey, c_dwMaxPresharedKey, TRUE);

                        if (FALSE == ValidatePresharedKey(szPresharedKey))
                        {
                            MYVERIFY(IDOK == ShowMessage(hDlg, IDS_PRESHAREDKEY_BAD, MB_OK | MB_ICONSTOP));
                            SetFocus(GetDlgItem(hDlg, IDC_PRESHARED_KEY));
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }

                        //
                        //  if key is being encrypted, verify the PIN and use to encrypt key
                        //
                        if (IsDlgButtonChecked(hDlg, IDC_USEENCRYPTION))
                        {
                            GetTextFromControl(hDlg, IDC_PRESHARED_KEY_PIN, szPresharedKeyPIN, c_dwMaxPresharedKeyPIN, TRUE);
                            if (FALSE == ValidatePresharedKeyPIN(szPresharedKeyPIN))
                            {
                                MYVERIFY(IDOK == ShowMessage(hDlg, IDS_PRESHAREDKEY_PIN_BAD, MB_OK | MB_ICONSTOP));
                                SetFocus(GetDlgItem(hDlg, IDC_PRESHARED_KEY_PIN));
                                MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                                return 1;
                            }

                            //
                            //  Encrypt Pre-shared Key
                            //
                            if (FALSE == EncryptPresharedKey(szPresharedKey, szPresharedKeyPIN, &pszPresharedKey))
                            {
                                MYVERIFY(IDOK == ShowMessage(hDlg, IDS_PSK_ENCRYPT_FAILED, MB_OK | MB_ICONSTOP));
                                SetFocus(GetDlgItem(hDlg, IDC_PRESHARED_KEY_PIN));
                                MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                                return 1;
                            }

                            MYDBGASSERT(pszPresharedKey);
                            bEncryptPresharedKey = TRUE;
                        }
                        else
                        {
                            pszPresharedKey = CmStrCpyAlloc(szPresharedKey);
                        }

                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryPresharedKey,
                                                                pszPresharedKey,
                                                                g_szCmpFile));
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryKeyIsEncrypted,
                                                                (bEncryptPresharedKey ? c_pszOne : c_pszZero),
                                                                g_szCmpFile));

                        ZeroMemory(szPresharedKey, c_dwMaxPresharedKey * sizeof(TCHAR));
                        ZeroMemory(szPresharedKeyPIN, c_dwMaxPresharedKeyPIN * sizeof(TCHAR));
                    }
                    CmFree(pszPresharedKey);
                    pszPresharedKey = NULL;
                    break;

                default:
                    return FALSE;
            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}



//+----------------------------------------------------------------------------
//
// Function:  RenameSection
//
// Synopsis:  This function renames an INI file section from the current name to
//            the new name.
//
// Arguments: LPCTSTR szCurrentSectionName - Current name that you want renamed
//            LPCTSTR szNewSectionName - name you want the above renamed to
//            LPCTSTR szFile - INI file to rename the section in
//
// Returns:   BOOL - Returns TRUE unless a malloc error occurred
//
// History:   quintinb Created     9/11/98
//
//+----------------------------------------------------------------------------
BOOL RenameSection(LPCTSTR szCurrentSectionName, LPCTSTR szNewSectionName, LPCTSTR szFile)
{
    //
    //  Get the existing section
    //
    LPTSTR pszBuffer = GetPrivateProfileSectionWithAlloc(szCurrentSectionName, szFile);

    if (NULL == pszBuffer)
    {
        return FALSE;
    }
    else
    {
        //
        //  Erase the old section
        //
        MYVERIFY(0 != WritePrivateProfileString(szCurrentSectionName, NULL, NULL, szFile));

        //
        //  Write out the renamed section
        //

        MYVERIFY(0 != WritePrivateProfileSection(szNewSectionName, pszBuffer, szFile));    
    }

    CmFree(pszBuffer);
    return TRUE;
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessCustomActionPopup
//
// Synopsis:  Processes windows messages for the dialog which allows CMAK to add
//            or edit custom actions.  Note that we pass in a pointer to a
//            CustomActionListItem struct on WM_INITDIALOG through the lParam.
//            If the user hits OK, we copy the data that they gave us into this
//            structure.  Note that we only do this to communicate the data back to
//            the caller as we update the custom action list ourselves.
//
// Arguments: WND hDlg - dialog window handle
//            UINT message - message identifier
//            WPARAM wParam - wParam Value 
//            LPARAM lParam - lParam Value
//
//
// History:   quintinb  Created     02/25/00
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessCustomActionPopup(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    HRESULT hr;
    int iTemp;
    LRESULT lResult;
    LPTSTR pszTypeString = NULL;
    CustomActionTypes Type;
    CustomActionExecutionStates ExecutionIndex;
    static CustomActionListItem* pItem;
    CustomActionListItem* pTempItem = NULL;
    CustomActionListItem NewItem;

    static TCHAR szFullPathToProgram[MAX_PATH+1] = {0};

    HWND hControl;
    LPTSTR pszTemp;

    SetDefaultGUIFont(hDlg, message, IDC_EDIT1);
    SetDefaultGUIFont(hDlg, message, IDC_EDIT2);
    SetDefaultGUIFont(hDlg, message, IDC_EDIT3);
    SetDefaultGUIFont(hDlg, message, IDC_COMBO1);
    SetDefaultGUIFont(hDlg, message, IDC_COMBO2);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_CONNECT)) return TRUE;

    switch (message)
    {

        case WM_INITDIALOG:

            MYDBGASSERT(g_pCustomActionList);
            if (NULL == g_pCustomActionList)
            {
                return TRUE;
            }

            //
            //  We keep the full path to the program in this static string.
            //
            ZeroMemory(szFullPathToProgram, sizeof(szFullPathToProgram));

            //
            //  Check to see if we got an initialization parameter
            //
            if (lParam)
            {
                //
                //  Thus we were passed a CustomActionListItem structure.  It either contains a
                //  type and a description, meaning that this is an edit and we should lookup the
                //  data, or we got just a type and we just need to pre-set the type combo to the
                //  type the user was currently viewing in the listbox.
                //

                pItem = (CustomActionListItem*)lParam;

                if (pItem->szDescription[0])
                {
                    hr = g_pCustomActionList->GetExistingActionData(g_hInstance, pItem->szDescription, pItem->Type, &pTempItem);

                    if (SUCCEEDED(hr))
                    {
                        //
                        //  Let's set the dialog title to say that we are editing an entry.  If we fail to retrive
                        //  the string the dialog may look a little funny but should still be functional so we
                        //  won't try to bail out.
                        //
                        pszTemp = CmLoadString(g_hInstance, IDS_CA_EDIT_TITLE);

                        if (pszTemp)
                        {
                            MYVERIFY(SendMessage (hDlg, WM_SETTEXT, 0, (LPARAM)pszTemp));
                            CmFree(pszTemp);
                        }

                        //
                        //  Okay, we have data so lets set the item fields.  Don't set the description if it
                        //  is only the temporary description that we concatenated from the program and the
                        //  arguments.
                        //
                        if (FALSE == pTempItem->bTempDescription)
                        {
                            MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDIT3), WM_SETTEXT, 0, (LPARAM)pTempItem->szDescription));
                        }

                        //
                        //  Set the program edit control, note we only show the filename if the user is including the
                        //  binary in the package.  Also note that we save the full path in szFullPathToProgram so that
                        //  we have it for later.
                        //
                        if (pTempItem->bIncludeBinary)
                        {
                            GetFileName(pTempItem->szProgram, szTemp);
                            lstrcpyn(szFullPathToProgram, pTempItem->szProgram, CELEMS(szFullPathToProgram));
                        }
                        else
                        {                        
                            lstrcpyn(szTemp, pTempItem->szProgram, CELEMS(szTemp));
                        }

                        MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDIT1), WM_SETTEXT, 0, (LPARAM)szTemp));                        

                        //
                        //  Set the include program checkbox
                        //
                        
                        MYVERIFY(0 != CheckDlgButton(hDlg, IDC_CHECK1, pTempItem->bIncludeBinary));

                        //
                        //  Set the parameters edit control.  Note that we put the function name and the parameters
                        //  back together if necessary.
                        //
                        if (NULL != pTempItem->pszParameters)
                        {
                            LPTSTR pszParamToDisplay = NULL;

                            if (pTempItem->szFunctionName[0])
                            {
                                pszParamToDisplay = CmStrCpyAlloc(pTempItem->szFunctionName);
                                MYDBGASSERT(pszParamToDisplay);

                                if (pszParamToDisplay && pTempItem->pszParameters[0])
                                {
                                    pszParamToDisplay = CmStrCatAlloc(&pszParamToDisplay, TEXT(" "));
                                    MYDBGASSERT(pszParamToDisplay);

                                    if (pszParamToDisplay)
                                    {
                                        pszParamToDisplay = CmStrCatAlloc(&pszParamToDisplay, pTempItem->pszParameters);
                                        MYDBGASSERT(pszParamToDisplay);
                                    }
                                }
                            }
                            else
                            {
                                pszParamToDisplay = CmStrCpyAlloc(pTempItem->pszParameters);
                                MYDBGASSERT(pszParamToDisplay);
                            }

                            if (pszParamToDisplay)
                            {
                                MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDIT2), WM_SETTEXT, 0, (LPARAM)pszParamToDisplay));
                                CmFree(pszParamToDisplay);
                            }
                        }
                        else
                        {
                            CMASSERTMSG(FALSE, TEXT("pTempItem->pszParameters is NULL"));
                        }
                    }
                }

                //
                //  Figure out what type of custom action we are editing or trying to add (we pre-seed the add type with
                //  the type the user was viewing.  If they were viewing all we set it to the first in the combo).
                //
                Type = pItem->Type;
                
                hr = g_pCustomActionList->MapFlagsToIndex((pTempItem ? pTempItem->dwFlags : 0), (int*)&ExecutionIndex);

                if (FAILED(hr))
                {
                    CMASSERTMSG(FALSE, TEXT("ProcessCustomActionPopup -- MapFlagsToIndex failed, setting execution state to Always."));
                    ExecutionIndex = (CustomActionExecutionStates)0; // set it to the first item in the enum
                }
            }
            else
            {
                pItem = NULL;
                Type = (CustomActionTypes)0; // set it to the first item in the enum
                ExecutionIndex = (CustomActionExecutionStates)0; // set it to the first item in the enum
            }

            if (pTempItem)
            {
                CmFree(pTempItem->pszParameters);
                CmFree(pTempItem);
                pTempItem = NULL;
            }

            //
            //  Setup the custom action types combobox, note that we set bAddAll to FALSE so that we don't add the
            //  All connect action type used for viewing the connect actions on the main dialog.
            //
            hr = g_pCustomActionList->AddCustomActionTypesToComboBox(hDlg, IDC_COMBO1, g_hInstance, g_bUseTunneling, FALSE);

            //
            //  Pick a connect action type
            //
            hr = g_pCustomActionList->GetTypeStringFromType(g_hInstance, Type, &pszTypeString);

            if (SUCCEEDED(hr))
            {
                lResult = SendDlgItemMessage(hDlg, IDC_COMBO1, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)pszTypeString);

                if (CB_ERR != lResult)
                {
                    MYVERIFY(CB_ERR != SendDlgItemMessage(hDlg, IDC_COMBO1, CB_SETCURSEL, (WPARAM)lResult, (LPARAM)0));
                }

                CmFree(pszTypeString);
            }

            //
            //  Next initialize the the combo that tells us when to run a connect action.  If we are tunneling
            //  then the user can pick to run the connection for direct connections only, dialup connections only,
            //  all connections that involve dialup, all connections that involve a tunnel, or all connections.
            //
            hr = g_pCustomActionList->AddExecutionTypesToComboBox(hDlg, IDC_COMBO2, g_hInstance, g_bUseTunneling);

            //
            //  Pick when the connect action will execute if it is enabled
            //
            if (g_bUseTunneling)
            {
                lResult = SendDlgItemMessage(hDlg, IDC_COMBO2, CB_GETCOUNT, (WPARAM)0, (LPARAM)0);
                if ((CB_ERR != lResult) && (lResult > 0))
                {
                    MYVERIFY(CB_ERR != SendDlgItemMessage(hDlg, IDC_COMBO2, CB_SETCURSEL, (WPARAM)ExecutionIndex, (LPARAM)0));
                }
            }

            break;
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_BUTTON1: // Browse
                    {
                        UINT uFilterArray[2] = {IDS_CONACTFILTER, IDS_ALLFILTER};
                        TCHAR* pszMaskArray[2] = {TEXT("*.exe;*.com;*.bat;*.dll"), TEXT("*.*")};
                                          
                        iTemp = DoBrowse(hDlg, uFilterArray, pszMaskArray, 2, IDC_EDIT1, TEXT("exe"), g_szLastBrowsePath);

                        MYDBGASSERT(0 != iTemp);

                        if (0 < iTemp) // -1 means the user cancelled
                        {
                            //
                            //  Check the include binary button for the user
                            //
                            MYVERIFY(0 != CheckDlgButton(hDlg, IDC_CHECK1, TRUE));

                            //
                            //  We want to copy the full path to the filename into szFullPathToProgram so
                            //  that we have it for later in case the user wants to include it in the profile.
                            //
                            lstrcpyn(szFullPathToProgram, g_szLastBrowsePath, CELEMS(szFullPathToProgram));

                            //
                            //  We also want to save the last browse path so that when the user next
                            //  opens the browse dialog they will be in the same place they last
                            //  browsed from.
                            //
                            LPTSTR pszLastSlash = CmStrrchr(g_szLastBrowsePath, TEXT('\\'));

                            if (pszLastSlash)
                            {
                                pszLastSlash = CharNext(pszLastSlash);
                                *pszLastSlash = TEXT('\0');
                            }
                            else
                            {
                                g_szLastBrowsePath[0] = TEXT('\0');                        
                            }        
                        }
                    }
                    break;

                case IDOK:

                    //
                    //  Make sure we have a valid custom action list
                    //
                    MYDBGASSERT(g_pCustomActionList);
                    if (NULL == g_pCustomActionList)
                    {
                        return TRUE;
                    }

                    //
                    //  Get the text from the Program Edit Control, verifying
                    //  we can convert it to something ANSI
                    //
                    if (-1 == GetTextFromControl(hDlg, IDC_EDIT1, szTemp, MAX_PATH, TRUE)) // bDisplayError == TRUE
                    {
                        SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
                        return TRUE;
                    }

                    //
                    //  Check to make sure the program field isn't blank.
                    //
                    if (TEXT('\0') == szTemp[0])
                    {
                        MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NEEDPROG, MB_OK));
                        SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
                        return TRUE;
                    }

                    //
                    //  Make sure that the program doesn't have a comma or a plus
                    //  sign in it as that will mess up our parsing routines.  There
                    //  is no need to allow users to use such odd ball file names.
                    //
                    if (CmStrchr(szTemp, TEXT('+')) || CmStrchr(szTemp, TEXT(',')))
                    {
                        MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NOPLUSORCOMMAINPROG, MB_OK));
                        SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
                        return TRUE;                        
                    }

                    //
                    //  Now check to see if we need to verify that the file exists.
                    //  We only want to do that if they have the include program files
                    //  checkbox checked.
                    //
                    ZeroMemory(&NewItem, sizeof(CustomActionListItem));
                    NewItem.bIncludeBinary = IsDlgButtonChecked(hDlg, IDC_CHECK1);

                    if (NewItem.bIncludeBinary)
                    {
                        if (!VerifyFile(hDlg, IDC_EDIT1, szFullPathToProgram, TRUE)) 
                        {
                            return TRUE;
                        }  
                        else
                        {
                            lstrcpyn(NewItem.szProgram, szFullPathToProgram, CELEMS(NewItem.szProgram));
                        }
                    }
                    else
                    {
                        //
                        //  Copy the file as is, but warn the user if they have
                        //  a string with a path but doesn't start with a environment
                        //  variable.
                        //
                        iTemp = IDNO;

                        CmStrTrim(szTemp);

                        LPTSTR pszSlash = CmStrchr(szTemp, TEXT('\\'));
                        
                        if (pszSlash && (TEXT('%') != szTemp[0]))
                        {
                            iTemp = ShowMessage(hDlg, IDS_PATH_WITH_NO_ENV, MB_YESNO | MB_ICONWARNING);
                        }

                        if (IDNO == iTemp)
                        {
                            lstrcpyn(NewItem.szProgram, szTemp, CELEMS(NewItem.szProgram));                                            
                        }
                        else
                        {
                            return TRUE;
                        }
                    }

                    //
                    //  Get the Text from the Params edit control, make sure to validate
                    //  that we can convert it to ANSI
                    //
                    hControl = GetDlgItem(hDlg, IDC_EDIT2);
                    MYDBGASSERT(hControl);
                    pszTemp = NULL;

                    if (hControl)
                    {
                        iTemp = GetCurrentEditControlTextAlloc(hControl, &pszTemp);

                        if (-1 == iTemp)
                        {
                            SetFocus(GetDlgItem(hDlg, IDC_EDIT2));
                            return TRUE;
                        }
                    }

                    //
                    //  Check to see if we have a dll for a program.  If so, the first parameter is the function name.
                    //
                    if (pszTemp)
                    {
                        CmStrTrim(pszTemp);

                        iTemp = lstrlen(NewItem.szProgram) - 4; // 4 == lstrlen (TEXT(".dll"));

                        if (0 == lstrcmpi(TEXT(".dll"), (NewItem.szProgram + iTemp)))
                        {
                            //
                            //  Make sure that we have a parameter string
                            //
                            if (pszTemp && pszTemp[0])
                            {
                                LPTSTR pszEndOfFunctionName = CmStrchr(pszTemp, TEXT(' '));

                                if (pszEndOfFunctionName)
                                {                                   
                                    LPTSTR pszParams = CharNext(pszEndOfFunctionName);
                                    *pszEndOfFunctionName = TEXT('\0');

                                    lstrcpyn(NewItem.szFunctionName, pszTemp, CELEMS(NewItem.szFunctionName));
                                    NewItem.pszParameters = CmStrCpyAlloc(pszParams);
                                }
                                else
                                {
                                    lstrcpyn(NewItem.szFunctionName, pszTemp, CELEMS(NewItem.szFunctionName));
                                }
                            }
                            else
                            {
                                MYVERIFY (IDOK == ShowMessage(hDlg, IDS_DLLMUSTHAVEPARAM, MB_OK));
                                SetFocus(GetDlgItem(hDlg, IDC_EDIT2));
                                return TRUE;
                            }

                            CmFree(pszTemp);
                        }
                        else
                        {
                            NewItem.pszParameters = pszTemp;
                            pszTemp = NULL;
                        }
                    }
                    else
                    {
                        NewItem.pszParameters = CmStrCpyAlloc(TEXT(""));
                        MYDBGASSERT(NewItem.pszParameters);
                    }

                    //
                    //  Get the Text from the Description edit control
                    //
                    if (-1 == GetTextFromControl(hDlg, IDC_EDIT3, NewItem.szDescription, CELEMS(NewItem.szDescription), TRUE)) // bDisplayError == TRUE
                    {
                        SetFocus(GetDlgItem(hDlg, IDC_EDIT3));
                        return TRUE;
                    }

                    //
                    //  If the description was empty, then fill it in from the program and the parameters.  Also
                    //  remember to keep track of the fact that this is only a temporary description.
                    //
                    if (TEXT('\0') == NewItem.szDescription[0])
                    {
                        hr = g_pCustomActionList->FillInTempDescription(&NewItem);
                        MYDBGASSERT(SUCCEEDED(hr));
                    }

                    //
                    //  Figure out the type of custom action
                    //
                    hr = MapComboSelectionToType(hDlg, IDC_COMBO1, FALSE, g_bUseTunneling, &(NewItem.Type)); // bIncludesAll == FALSE

                    if ((ONINTCONNECT == NewItem.Type) && NewItem.szFunctionName[0])
                    {
                        MYVERIFY (IDOK == ShowMessage(hDlg, IDS_NODLLAUTOAPP, MB_OK));
                        return TRUE;
                    }

                    //
                    //  Now build the flags section
                    //
                    lResult = SendDlgItemMessage(hDlg, IDC_COMBO2, CB_GETCURSEL, 0, (LPARAM)0);

                    if (lResult != LB_ERR)
                    {
                        hr = g_pCustomActionList->MapIndexToFlags((int)lResult, &(NewItem.dwFlags));

                        if (FAILED(hr))
                        {
                            MYDBGASSERT(FALSE);
                            NewItem.dwFlags = 0;
                        }
                    }
                    else
                    {
                        MYDBGASSERT(FALSE);
                        NewItem.dwFlags = 0;                    
                    }

                    //
                    //  Now, lets try to add the New or Edited entry.  If we have a description
                    //  in pItem->szDescription then we need to call edit, otherwise add.
                    //                    
                    if (pItem && pItem->szDescription[0])
                    {
                        hr = g_pCustomActionList->Edit(g_hInstance, pItem, &NewItem, g_szShortServiceName);
                    }
                    else
                    {
                        hr = g_pCustomActionList->Add(g_hInstance, &NewItem, g_szShortServiceName);
                    }

                    //
                    //  Check to see if we failed because a duplicate exists
                    //
                    if (HRESULT_FROM_WIN32(ERROR_FILE_EXISTS) == hr)
                    {
                        //
                        //  The user has tried to add an entry which already exists.  Inform the
                        //  user and see if they want to overwrite.
                        //
                        pszTypeString = NULL;
                        hr = g_pCustomActionList->GetTypeStringFromType(g_hInstance, NewItem.Type, &pszTypeString);

                        MYDBGASSERT(pszTypeString);

                        if (pszTypeString)
                        {
                            LPTSTR pszMsg = CmFmtMsg(g_hInstance, IDS_CANAMEEXISTS, NewItem.szDescription, pszTypeString);

                            MYDBGASSERT(pszMsg);
                            if (pszMsg)
                            {
                                iTemp = MessageBox(hDlg, pszMsg, g_szAppTitle, MB_YESNO | MB_APPLMODAL | MB_DEFBUTTON2 | MB_ICONEXCLAMATION);

                                if (IDYES == iTemp)
                                {                                
                                    //
                                    //  Okay, they want to replace it.  Note that the old item is only 
                                    //  used to get the szDescription and the Type thus
                                    //  it is safe to call Edit with NewItem as both Old and New.
                                    //

                                    if (pItem && pItem->szDescription[0])
                                    {
                                        hr = g_pCustomActionList->Delete (g_hInstance, pItem->szDescription, pItem->Type);
                                        MYDBGASSERT(SUCCEEDED(hr));
                                    }

                                    hr = g_pCustomActionList->Edit(g_hInstance, &NewItem, &NewItem, g_szShortServiceName);

                                    MYDBGASSERT(SUCCEEDED(hr));

                                    if (SUCCEEDED(hr))
                                    {
                                        MYVERIFY(0 != EndDialog(hDlg, IDOK));
                                        
                                        if (pItem)
                                        {
                                            //
                                            //  Make sure the type and description are up to date in pItem if we have one
                                            //
                                            lstrcpyn(pItem->szDescription, NewItem.szDescription, CELEMS(pItem->szDescription));
                                            pItem->Type = NewItem.Type;
                                        }
                                    }
                                }
                                else
                                {
                                    //
                                    //  Let's put the user back to the description field if it has text in it, otherwise
                                    //  we want to put the user in the program field.
                                    //
                                    LRESULT lTextLen = SendDlgItemMessage(hDlg, IDC_EDIT3, WM_GETTEXTLENGTH, (WPARAM)0, (LPARAM)0);

                                    SetFocus(GetDlgItem(hDlg, lTextLen ? IDC_EDIT3 : IDC_EDIT1));
                                }

                                CmFree(pszMsg);
                            }

                            CmFree(pszTypeString);
                        }
                    }
                    else if (FAILED(hr))
                    {
                        CMASSERTMSG(FALSE, TEXT("ProcessCustomActionPopUp -- unknown failure when trying to add or edit a connect action."));
                    }
                    else
                    {
                        if (pItem)
                        {
                            //
                            //  Make sure the type and description are up to date in pItem if we have one
                            //
                            lstrcpyn(pItem->szDescription, NewItem.szDescription, CELEMS(pItem->szDescription));
                            pItem->Type = NewItem.Type;
                        }

                        MYVERIFY(0 != EndDialog(hDlg, IDOK));
                    }

                    CmFree(NewItem.pszParameters);
                    NewItem.pszParameters = NULL;
                    return (TRUE);

                case IDCANCEL:
                    MYVERIFY(0 != EndDialog(hDlg, IDCANCEL));
                    return (TRUE);

                default:
                    break;
            }
            break;

        default:
            return FALSE;
    }
    return FALSE;   
}


// Read files under the [Extra Files] section in the .inf
static void ReadExtraList()
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szTemp2[MAX_PATH+1];
    TCHAR szNum[MAX_PATH+1];
    ExtraData TmpExtraData;
    int ConnectCnt = 0;
    HANDLE hInf;

    _itot(ConnectCnt,szNum,10); //lint !e534 itoa doesn't return anything useful for error handling
    
    
    // 
    // The following call to GetPrivateProfileString could return an empty string
    // so we don't want to use the MYVERIFY macro on it.
    // 

    ZeroMemory(szTemp, sizeof(szTemp));
    GetPrivateProfileString(c_pszExtraFiles, szNum, TEXT(""), szTemp, CELEMS(szTemp), g_szInfFile);    //lint !e534
    
    while (*szTemp)
    {
        _tcscpy(TmpExtraData.szPathname, szTemp);
        GetFileName(TmpExtraData.szPathname, TmpExtraData.szName);

        MYVERIFY(CELEMS(szTemp2) > (UINT)wsprintf(szTemp2, TEXT("%s\\%s"), g_szOutdir, TmpExtraData.szName));

        hInf = CreateFile(szTemp2,GENERIC_READ,0,NULL,OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL,NULL);

        if (hInf != INVALID_HANDLE_VALUE)
        {
            _tcscpy(TmpExtraData.szPathname,szTemp2);
            MYVERIFY(0 != CloseHandle(hInf));
        }

        MYVERIFY(FALSE != createListBxRecord(&g_pHeadExtra,&g_pTailExtra,(void *)&TmpExtraData,sizeof(TmpExtraData),TmpExtraData.szName));

        ++ConnectCnt;
        _itot(ConnectCnt,szNum,10); //lint !e534 itoa doesn't return anything useful for error handling

        // 
        // The following call to GetPrivateProfileString could return an empty string
        // so we don't want to use the MYVERIFY macro on it.
        // 

        ZeroMemory(szTemp, sizeof(szTemp));
        
        GetPrivateProfileString(c_pszExtraFiles, szNum, TEXT(""), szTemp, CELEMS(szTemp), g_szInfFile);    //lint !e534

    }           
}



//+----------------------------------------------------------------------------
//
// Function:  ReadMergeList
//
// Synopsis:  This function reads entries from the [Merge Profiles] section of the inf file.
//            Any entries found are added to the g_pHeadMerge Linked list.
//
// Arguments: None
//
// Returns:   Nothing
//
// History:   Quintinb Created Header and restructured to use dwNumChars    1/7/98
//
//+----------------------------------------------------------------------------
static void ReadMergeList()
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szNum[MAX_PATH+1];
    int filenum = 0;
    DWORD dwNumChars;

    //
    //  Convert the number zero to the string "0"
    //

    _itot(filenum,szNum,10);    //lint !e534 itoa doesn't return anything useful for error handling
    
    //
    //  Try to get a merged profile entry from the INF
    //
    
    dwNumChars = GetPrivateProfileString(c_pszMergeProfiles, szNum,TEXT(""), szTemp, 
        CELEMS(szTemp), g_szInfFile);
    
    while ((dwNumChars > 0) &&  (TEXT('\0') != szTemp[0]))
    {
        //
        //  If we are in this loop then we have a profile entry
        //

        MYVERIFY(FALSE != createListBxRecord(&g_pHeadMerge,&g_pTailMerge,(void *)NULL,0,szTemp));
        
        //
        //  Increment the filenumber to look for the next entry
        //

        ++filenum;
        
        //
        //  Convert the filenumber to a string
        //

        _itot(filenum,szNum,10);    //lint !e534 itoa doesn't return anything useful for error handling
        
        //
        //  Try to read in the next merge entry
        //

        dwNumChars = GetPrivateProfileString(c_pszMergeProfiles, szNum, TEXT(""), szTemp, 
            CELEMS(szTemp), g_szInfFile);

    }           
}


static void WriteExtraList()
{
    ExtraData * pExtraData;
    ListBxList * LoopPtr;
    TCHAR szNum[MAX_PATH+1];
    TCHAR szName[MAX_PATH+1];
    int filenum = 0;

    MYVERIFY(0 != WritePrivateProfileSection(c_pszExtraFiles, TEXT("\0\0"), g_szInfFile));

    if (g_pHeadExtra == NULL)
    {
        return;
    }
    LoopPtr = g_pHeadExtra;

    // WRITE IN ALL ENTRIES
    while( LoopPtr != NULL)
    {
        pExtraData = (ExtraData *)LoopPtr->ListBxData;
        {
            _itot(filenum,szNum,10);    //lint !e534 itoa doesn't return anything useful for error handling

            GetFileName(pExtraData->szPathname,szName);
            MYVERIFY(0 != WritePrivateProfileString(c_pszExtraFiles, szNum, szName, g_szInfFile));
            filenum = filenum+1;
        }

        LoopPtr = LoopPtr->next;
    }

    //
    //  By calling WritePrivateProfileString with all NULL's we flush the file cache 
    //  (win95 only).  This call will return 0.
    //

    WritePrivateProfileString(NULL, NULL, NULL, g_szInfFile); //lint !e534 this call will always return 0

}

static void WriteMergeList()
{
    ListBxList * LoopPtr;
    TCHAR szNum[MAX_PATH+1];
    int filenum = 0;

    MYVERIFY(0 != WritePrivateProfileSection(c_pszMergeProfiles,TEXT("\0\0"),g_szInfFile));

    if (g_pHeadMerge == NULL)
    {
        return;
    }
    LoopPtr = g_pHeadMerge;

    // WRITE IN ALL ENTRIES
    while( LoopPtr != NULL)
    {
        _itot(filenum,szNum,10);    //lint !e534 itoa doesn't return anything useful for error handling
        MYVERIFY(0 != WritePrivateProfileString(c_pszMergeProfiles, szNum,LoopPtr->szName, g_szInfFile));
        filenum = filenum+1;
        LoopPtr = LoopPtr->next;
    }

    //
    //  By calling WritePrivateProfileString with all NULL's we flush the file cache (win95 only).  This call will
    //  return 0.
    //

    WritePrivateProfileString(NULL, NULL, NULL, g_szInfFile); //lint !e534 this call will always return 0.
}

//+----------------------------------------------------------------------------
//
// Function:  IsFile8dot3
//
// Synopsis:  Returns TRUE if the filename is in the 8.3 dos filename format
//
// Arguments: LPTSTR pszFileName - just the filename of the file to be checked (no path)
//
// Returns:   BOOL - TRUE or FALSE if the file is 8.3
//
// History:   quintinb created    11/26/97
//
//+----------------------------------------------------------------------------
BOOL IsFile8dot3(LPTSTR pszFileName)
{

    TCHAR szTemp[MAX_PATH+1];
    TCHAR * pszPtr;

    if (!pszFileName)
    {
        return FALSE;
    }

    if (TEXT('\0') == pszFileName[0])
    {
        return TRUE;
    }

    _tcscpy(szTemp, pszFileName);

    pszPtr = _tcsrchr(szTemp, TEXT('.'));

    //
    // If there is an extension check the length
    //

    if (pszPtr)
    {
        if (_tcslen(pszPtr) > 4)
        {
            return FALSE;
        }

        //
        // Extension is ok check name part
        //

        *pszPtr = 0;
    }
        
    if (_tcslen(szTemp) > 8)
    {
        return FALSE;
    }   

    return TRUE;
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessCustomActions
//
// Synopsis:  Processes windows messages for the page in CMAK that allows users
//            to manipulate custom actions (add, edit, delete, move, etc.)
//
// Arguments: WND hDlg - dialog window handle
//            UINT message - message identifier
//            WPARAM wParam - wParam Value 
//            LPARAM lParam - lParam Value
//
//
// History:   quintinb  Created     02/25/00
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessCustomActions(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    INT_PTR nResult;
    int iTemp;
    HRESULT hr;
    static HWND hListView;
    NMHDR* pnmHeader = (NMHDR*)lParam;
    LPNMLISTVIEW pNMListView;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_CONNECT)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_LISTVIEW);
    SetDefaultGUIFont(hDlg,message,IDC_COMBO1);

    switch (message)
    {
        case WM_INITDIALOG:
        {
            if (NULL == g_pCustomActionList)
            {
                g_pCustomActionList = new CustomActionList;

                MYDBGASSERT(g_pCustomActionList);

                if (NULL == g_pCustomActionList)
                {
                    return FALSE;
                }

                //
                //  Read in the custom actions from the Cms File
                //

                hr = g_pCustomActionList->ReadCustomActionsFromCms(g_hInstance, g_szCmsFile, g_szShortServiceName);
                CMASSERTMSG(SUCCEEDED(hr), TEXT("ProcessCustomActions -- Loading custom actions failed."));
            }

            //
            //  Cache the List View window handle
            //
            hListView = GetDlgItem(hDlg, IDC_LISTVIEW);

            //
            //  Load the arrow images for the move up and move down buttons
            //
            HICON hUpArrow = (HICON)LoadImage(g_hInstance, MAKEINTRESOURCE(IDI_UP_ARROW), IMAGE_ICON, 0, 0, 0);
            HICON hDownArrow = (HICON)LoadImage(g_hInstance, MAKEINTRESOURCE(IDI_DOWN_ARROW), IMAGE_ICON, 0, 0, 0);

            //
            //  Set the arrow button bit maps
            //
            SendMessage(GetDlgItem(hDlg, IDC_BUTTON4), BM_SETIMAGE, IMAGE_ICON, (LPARAM)hUpArrow);
            SendMessage(GetDlgItem(hDlg, IDC_BUTTON5), BM_SETIMAGE, IMAGE_ICON, (LPARAM)hDownArrow);

            //
            //  Set the Column headings
            //
            AddListViewColumnHeadings(g_hInstance, hListView);

           break;
        }
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_BUTTON1: //add

                    OnProcessCustomActionsAdd(g_hInstance, hDlg, hListView, g_bUseTunneling);
                    break;

                case IDC_BUTTON2: //edit

                    OnProcessCustomActionsEdit(g_hInstance, hDlg, hListView, g_bUseTunneling);
                    break;

                case IDC_BUTTON3: //delete

                    OnProcessCustomActionsDelete(g_hInstance, hDlg, hListView, g_bUseTunneling);
                    break;

                case IDC_BUTTON4: //UP
                    OnProcessCustomActionsMoveUp(g_hInstance, hDlg, hListView, g_bUseTunneling);
                    break;

                case IDC_BUTTON5: //down
                    OnProcessCustomActionsMoveDown(g_hInstance, hDlg, hListView, g_bUseTunneling);
                    break;

                case IDC_COMBO1: // type of connect action to display
                    if (HIWORD(wParam) == CBN_SELCHANGE)
                    {
                        UINT uStringId;
                        CustomActionTypes Type;

                        hr = MapComboSelectionToType(hDlg, IDC_COMBO1, TRUE, g_bUseTunneling, &Type); // TRUE == bIncludesAll

                        MYDBGASSERT(SUCCEEDED(hr));
                        if (SUCCEEDED(hr))
                        {
                            if (ALL == Type)
                            {
                                uStringId = IDS_TYPE_COL_TITLE;
                            }
                            else
                            {
                                uStringId = IDS_PROGRAM_COL_TITLE;                            
                            }

                            UpdateListViewColumnHeadings(g_hInstance, hListView, uStringId, 1); // 1 == second column
                            RefreshListView(g_hInstance, hDlg, IDC_COMBO1, hListView, 0, g_bUseTunneling);
                        }
                    }

                    break;

                default:
                    break;
            }

            break;

        case WM_NOTIFY:


            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {
                case LVN_ITEMCHANGED:

                    //
                    //  We want to process item changed messages for when the selection changes.  This
                    //  way when the user selects an item in the list (either using the arrow keys or
                    //  the mouse) we will accurately update the arrow keys.  In order to cut down on the
                    //  number of calls we filter out the unselected messages.
                    //
                    pNMListView = (LPNMLISTVIEW) lParam;


                    if ((LVIF_STATE & pNMListView->uChanged) && (LVIS_SELECTED & pNMListView->uNewState))
                    {
                        int iTempItem = pNMListView->iItem;
                        RefreshEditDeleteMoveButtonStates(g_hInstance, hDlg, hListView, IDC_COMBO1, &iTempItem, g_bUseTunneling);
                    }

                    break;

                case NM_DBLCLK:
                case NM_RETURN:
                    if (ListView_GetItemCount(hListView))
                    {
                        OnProcessCustomActionsEdit(g_hInstance, hDlg, hListView, g_bUseTunneling);                    
                    }

                    break;

                case LVN_KEYDOWN:
                    {
                        //
                        //  User hit the right click key or typed Shift+F10
                        //
                        NMLVKEYDOWN* pKeyDown = (NMLVKEYDOWN*)lParam;
                        if (((VK_F10 == pKeyDown->wVKey) && (0 > GetKeyState(VK_SHIFT))) || (VK_APPS == pKeyDown->wVKey))
                        {
                            //
                            //  Figure out what item is currently selected and gets its position
                            //
                            iTemp = ListView_GetSelectionMark(hListView);
                            NMITEMACTIVATE ItemActivate = {0};

                            if (-1 != iTemp)
                            {
                                POINT ptPoint = {0};
                                if (ListView_GetItemPosition(hListView, iTemp, &ptPoint))
                                {
                                    RECT ItemRect;

                                    if (ListView_GetItemRect(hListView, iTemp, &ItemRect, LVIR_LABEL))
                                    {
                                        LONG lIndent = (ItemRect.bottom - ItemRect.top) / 2;
                                        ItemActivate.ptAction.x = ptPoint.x + lIndent;
                                        ItemActivate.ptAction.y = ptPoint.y + lIndent;
                                        ItemActivate.iItem = iTemp;
                                        OnProcessCustomActionsContextMenu(g_hInstance, hDlg, hListView, &ItemActivate, g_bUseTunneling, IDC_COMBO1);
                                    }
                                }
                            }
                        }
                    }
                    break;

                case NM_RCLICK:
                    OnProcessCustomActionsContextMenu(g_hInstance, hDlg, hListView, (NMITEMACTIVATE*)lParam, g_bUseTunneling, IDC_COMBO1);
                    break;

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));

                    //
                    //  Make sure we have a custom action class to work with
                    //
                    if (NULL == g_pCustomActionList)
                    {
                        g_pCustomActionList = new CustomActionList;

                        MYDBGASSERT(g_pCustomActionList);

                        if (NULL == g_pCustomActionList)
                        {
                            return FALSE;
                        }

                        //
                        //  Read in the custom actions from the Cms File
                        //

                        hr = g_pCustomActionList->ReadCustomActionsFromCms(g_hInstance, g_szCmsFile, g_szShortServiceName);
                        CMASSERTMSG(SUCCEEDED(hr), TEXT("ProcessCustomActions -- Loading custom actions failed."));
                    }

                    //
                    //  Setup the ListView control and the corresponding Combo box, note that we set bAddAll to TRUE so
                    //  that the All option is added.
                    //
                    hr = g_pCustomActionList->AddCustomActionTypesToComboBox(hDlg, IDC_COMBO1, g_hInstance, g_bUseTunneling, TRUE);

                    nResult = SendDlgItemMessage(hDlg, IDC_COMBO1, CB_GETCOUNT, (WPARAM)0, (LPARAM)0);
                    if ((CB_ERR != nResult) && (nResult > 0))
                    {
                        MYVERIFY(CB_ERR != SendDlgItemMessage(hDlg, IDC_COMBO1, CB_SETCURSEL, (WPARAM)0, (LPARAM)0));
                    }

                    //
                    //  Add built in custom actions
                    //
                    { // adding scope

                        BOOL bAddCmdlForVpn = FALSE;

                        if (g_szVpnFile[0])
                        {
                            //
                            //  We have a VPN file so let's check and see if they defined an UpdateUrl
                            //
                            GetPrivateProfileString(c_pszCmSectionSettings, c_pszCmEntryVpnUpdateUrl, TEXT(""), szTemp, MAX_PATH, g_szVpnFile);

                            if (szTemp[0])
                            {
                                bAddCmdlForVpn = TRUE;
                            }
                        }

                        hr = g_pCustomActionList->AddOrRemoveCmdl(g_hInstance, bAddCmdlForVpn, TRUE); // TRUE == bForVpn
                        MYDBGASSERT(SUCCEEDED(hr));

                        hr = g_pCustomActionList->AddOrRemoveCmdl(g_hInstance, (g_bUpdatePhonebook || ReferencedDownLoad()), FALSE); // FALSE == bForVpn
                        MYDBGASSERT(SUCCEEDED(hr));
                    }
                    //
                    //  Add the items to the list view control
                    //
                    RefreshListView(g_hInstance, hDlg, IDC_COMBO1, hListView, 0, g_bUseTunneling);

                    break;

                case PSN_WIZBACK:
                case PSN_WIZNEXT:
                    
                    //
                    //  Set bUseTunneling == TRUE even though we may not be tunneling.  The reason for this is that
                    //  the user may have had a tunneling profile and then turned off tunneling.  If they turn
                    //  it back on again we don't want to lose all of their Pre-Tunnel actions nor do we want to
                    //  lose all of the flag settings that they have added to each action.  We will make sure
                    //  to use the actual g_bUseTunneling value when we write the actions to the cms file in 
                    //  WriteCMSFile.
                    //
                    MYDBGASSERT(g_pCustomActionList);
                    if (g_pCustomActionList)
                    {
                        hr = g_pCustomActionList->WriteCustomActionsToCms(g_szCmsFile, g_szShortServiceName, TRUE);
                        CMASSERTMSG(SUCCEEDED(hr), TEXT("ProcessCustomActions -- Failed to write out connect actions"));
                    }

                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessStatusMenuPopup
//
// Synopsis:  Processes Messages for the Popup dialog for Adding/Editing Status
//            Area Icon Menu items
//
// History:   quintinb Created Header and renamed from ProcessPage2G1    8/6/98
//
//+----------------------------------------------------------------------------
// USES GLOBAL VARIABLE DLGEDITITEM as input and output to the page
// You must sent DlgEditItem to the initial value of this page.
//

INT_PTR APIENTRY ProcessStatusMenuPopup(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szMsg[MAX_PATH+1];

    BOOL bChecked;
    static TCHAR szOld[MAX_PATH+1];
    IconMenu TempEditItem;
    SetDefaultGUIFont(hDlg,message,IDC_EDIT1);
    SetDefaultGUIFont(hDlg,message,IDC_EDIT2);
    SetDefaultGUIFont(hDlg,message,IDC_EDIT3);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_MENU)) return TRUE;

    switch (message)
    {

        case WM_INITDIALOG:

            //
            //  If we are editing we need to change the title
            //
            if (TEXT('\0') != DlgEditItem.szProgram[0])
            {
                LPTSTR pszTemp = CmLoadString(g_hInstance, IDS_EDIT_SHORTCUT_TITLE);

                if (pszTemp)
                {
                    MYVERIFY(SendMessage (hDlg, WM_SETTEXT, 0, (LPARAM)pszTemp));
                    CmFree(pszTemp);
                }
            }

            _tcscpy (szOld, DlgEditItem.szName);
            MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDIT1), WM_SETTEXT, 0, (LPARAM)DlgEditItem.szName));
            MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDIT2), WM_SETTEXT, 0, (LPARAM)GetName(DlgEditItem.szProgram)));
            MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDIT3), WM_SETTEXT, 0, (LPARAM)DlgEditItem.szParams));
            MYVERIFY(0 != CheckDlgButton(hDlg, IDC_CHECK1, (UINT)DlgEditItem.bDoCopy));

            break;

        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_BUTTON1:
                    {
                        UINT uFilter = IDS_PROGFILTER;
                        TCHAR* szMask = TEXT("*.exe;*.com;*.bat");

                        int iReturn = DoBrowse(hDlg, &uFilter, &szMask, 1, IDC_EDIT2, TEXT("exe"), DlgEditItem.szProgram);

                        MYDBGASSERT(0 != iReturn);
                        if (iReturn && (-1 != iReturn))
                        {
                            //
                            //  Check the include binary button for the user
                            //
                            MYVERIFY(0 != CheckDlgButton(hDlg, IDC_CHECK1, TRUE));
                        }
                    }
                    break;

                case IDOK:
                    if (-1 == GetTextFromControl(hDlg, IDC_EDIT1, DlgEditItem.szName, MAX_PATH, TRUE)) // bDisplayError == TRUE
                    {
                        SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
                        return TRUE;
                    }

                    if (-1 == GetTextFromControl(hDlg, IDC_EDIT2, szTemp, MAX_PATH, TRUE)) // bDisplayError == TRUE
                    {
                        SetFocus(GetDlgItem(hDlg, IDC_EDIT2));
                        return TRUE;
                    }
                    
                    if (szTemp[0] == TEXT('\0'))
                    {
                        MYVERIFY(IDOK == ShowMessage(hDlg,IDS_NEEDPROG,MB_OK));
                        SetFocus(GetDlgItem(hDlg, IDC_EDIT2));
                        return TRUE;
                    }

                    CheckNameChange(DlgEditItem.szProgram,szTemp);

                    if (NULL != _tcschr(DlgEditItem.szProgram, TEXT('=')))
                    {
                        MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NOEQUALSINMENU, MB_OK));
                        SetFocus(GetDlgItem(hDlg, IDC_EDIT2));
                        return TRUE;
                    }

                    if (-1 == GetTextFromControl(hDlg, IDC_EDIT3, DlgEditItem.szParams, MAX_PATH, TRUE)) // bDisplayError == TRUE
                    {
                        SetFocus(GetDlgItem(hDlg, IDC_EDIT3));
                        return TRUE;
                    }
                    
                    if (DlgEditItem.szName[0] == TEXT('\0'))
                    {
                        GetFileName(DlgEditItem.szProgram,DlgEditItem.szName);
                    }

                    if (_tcschr(DlgEditItem.szName, TEXT('=')))
                    {
                        MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NOEQUALSINMENU, MB_OK));
                        SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
                        return TRUE;
                    }

                    bChecked = IsDlgButtonChecked(hDlg,IDC_CHECK1);
                    if (bChecked)
                    {
                        if (!VerifyFile(hDlg,IDC_EDIT2,DlgEditItem.szProgram,TRUE)) 
                        {
                            DlgEditItem.bDoCopy = FALSE;
                            return TRUE;
                        }
                        else
                        {
                            DlgEditItem.bDoCopy = TRUE;
                        }
                    }
                    else
                    {
                        DlgEditItem.bDoCopy = FALSE;
                    }

                    if ((0 != _tcscmp(szOld, DlgEditItem.szName)) && 
                        (GetIconMenuItem(DlgEditItem.szName, &TempEditItem)))
                    {
                        //
                        //  We have a duplicate entry, prompt the user to replace or try
                        //  again.
                        //

                        MYVERIFY(0 != LoadString(g_hInstance, IDS_MENUITEMEXISTS, szTemp, MAX_PATH));
                        //
                        // write the previously used name in the string
                        //
                        wsprintf(szMsg, szTemp, DlgEditItem.szName);
                        
                        //
                        //  If the user doesn't want to replace the duplicate item then we should set the focus to the description
                        //  edit control if it has text in it, otherwise we should set it to the program edit control.
                        //
                        if (IDNO == MessageBox(hDlg, szMsg, g_szAppTitle, MB_YESNO | MB_APPLMODAL | MB_DEFBUTTON2 | MB_ICONEXCLAMATION))
                        {
                            LRESULT lTextLen = SendDlgItemMessage(hDlg, IDC_EDIT1, WM_GETTEXTLENGTH, (WPARAM)0, (LPARAM)0);

                            SetFocus(GetDlgItem(hDlg, lTextLen ? IDC_EDIT1 : IDC_EDIT2));

                            return TRUE;
                        }
                    }

                    MYVERIFY(0 != EndDialog(hDlg,IDOK));
                    return (TRUE);

                case IDCANCEL:
                    MYVERIFY(0 != EndDialog(hDlg,IDCANCEL));
                    return (TRUE);

                default:
                    break;
            }
            break;

        default:
            return FALSE;
    }
    return FALSE;   
}   //lint !e715 we don't reference lParam

BOOL createListBxRecord(ListBxList ** HeadPtrListBx, ListBxList ** TailPtrListBx, void * pData, DWORD dwSize, LPCTSTR lpName)
{
    ListBxList * ptr;
    void * dataptr;
    unsigned int n;
    // check for same named record and update
    if ( *HeadPtrListBx != NULL )
    {
        ptr = *HeadPtrListBx;
        while (ptr != NULL)
        {
            if (_tcsicmp(lpName, ptr->szName) == 0)
            {
                memcpy(ptr->ListBxData,pData,dwSize);
                return (TRUE);
            }
            ptr = ptr->next;
        }
    }
            
    n = sizeof( struct ListBxStruct );
    ptr = (ListBxList *) CmMalloc(n);
    if (ptr == NULL )
    {
        return FALSE;
    }

    _tcscpy(ptr->szName, lpName);

    if (pData)
    {
        dataptr = CmMalloc(dwSize);    

        if (dataptr)
        {
            memcpy(dataptr, pData, dwSize);
            ptr->ListBxData = dataptr;
        }
        else
        {
            CmFree(ptr);
            return FALSE;
        }
    }

    ptr->next = NULL;
    if ( *HeadPtrListBx == NULL )     // If this is the first record in the linked list
    {
        *HeadPtrListBx = ptr;
    }
    else
    {
        (*TailPtrListBx)->next = ptr;
    }

    *TailPtrListBx = ptr;

    return TRUE;
}

// delete named IconMenu item from linked list

void DeleteListBxRecord(ListBxList ** HeadPtrListBx,ListBxList ** TailPtrListBx, LPTSTR lpName)
{
    ListBxList * ptr;
    ListBxList * prevptr;

    if ( HeadPtrListBx != NULL )
    {
        ptr = *HeadPtrListBx;
        prevptr = NULL;
        while (ptr != NULL)
        {
            if (_tcsicmp(lpName,ptr->szName) == 0)
            {
                if (prevptr == NULL)
                {
                    *HeadPtrListBx = ptr->next;
                    if (*HeadPtrListBx == NULL)
                    {
                        *TailPtrListBx = NULL;
                    }
                    else 
                    {
                        if ((*HeadPtrListBx)->next == NULL)
                        {
                            *TailPtrListBx = *HeadPtrListBx;
                        }
                    }
                }
                else
                {
                    prevptr->next = ptr->next;
                    if (prevptr->next == NULL)
                    {
                        *TailPtrListBx = prevptr;
                    }
                }
                CmFree(ptr->ListBxData);
                CmFree(ptr);
                return;
            }
            prevptr = ptr;
            ptr = ptr->next;
        }
    }
                
}

BOOL FindListItemByName(LPTSTR pszName, ListBxList* pHeadOfList, ListBxList** pFoundItem)
{
    if (NULL == pszName)
    {
        CMASSERTMSG(FALSE, TEXT("FindListItemByName -- Invalid parameter"));
        return FALSE;
    }
    
    if (NULL != pHeadOfList)
    {
        ListBxList * pCurrent = pHeadOfList;

        while (NULL != pCurrent)
        {
            if (0 == lstrcmpi(pszName, pCurrent->szName))
            {
                //
                //  Return the pointer to pCurrent if the caller asked for it
                //
                if (pFoundItem)
                {
                    *pFoundItem = pCurrent;
                }

                return TRUE;
            }

            pCurrent = pCurrent->next;
        }
    }

    return FALSE;
}

//+----------------------------------------------------------------------------
//
// Function:  updateRecord
//
// Synopsis:    Function updates an entry in the list of tray icon data structures
//              thus the entry is not added and then deleted when the user edits an
//              entry.  This takes away the putting the entry at the bottom of the list
//              problem cited in the bug.
//
// Arguments: PTSTR szName - New name of the entry
//            LPTSTR szProgram - Program string to add to the Tray Icon Entry
//            LPTSTR szParams - Parameter string to add to the Tray Icon Entry
//            BOOL bDoCopy - Value of whether this program should be included with the profile data item
//            LPTSTR szOld - Name of the entry to update
//
// Returns:   BOOL - TRUE if able to update the record
//                   FALSE if not able to find it
//
// Side Effects:    Replaces the entry named by szOld with the entry data and name for
//                  entry called szName.

// History:   quintinb  Created for bugfix 14399      9-9-97
//
//+----------------------------------------------------------------------------
static BOOL updateRecord(LPTSTR szName, LPTSTR szProgram, LPTSTR szParams, BOOL bDoCopy, LPTSTR szOld)
{
   IconMenu * ptr;

    // check for same named record and update
    if ( g_pHeadIcon != NULL )
    {
        ptr = g_pHeadIcon;
        while (ptr != NULL)
        {
            if (_tcsicmp(szOld,ptr->szName) == 0)
            {
                _tcscpy(ptr->szProgram,szProgram);
                _tcscpy(ptr->szParams,szParams);
                ptr->bDoCopy = bDoCopy;
                _tcscpy(ptr->szName, szName);
                return (TRUE);
            }
            ptr = ptr->next;
        }
    }
    return (FALSE);

}
// note, as of bug 14399 updating should be done with the above function
BOOL createRecord(LPCTSTR szName, LPCTSTR szProgram, LPCTSTR szParams, BOOL bDoCopy)
{
   IconMenu * ptr;
   unsigned int n;
    // check for same named record and update
    if ( g_pHeadIcon != NULL )
    {
        ptr = g_pHeadIcon;
        while (ptr != NULL)
        {
            if (_tcsicmp(szName,ptr->szName) == 0)
            {
                _tcscpy(ptr->szProgram,szProgram);
                _tcscpy(ptr->szParams,szParams);
                ptr->bDoCopy = bDoCopy;
                return (TRUE);
            }
            ptr = ptr->next;
        }
    }
                
   // 
   n = sizeof( struct IconMenuStruct );
   ptr = (IconMenu *) CmMalloc(n);
   if ( ptr == NULL )
   {
       return FALSE;
   }
   _tcscpy(ptr->szName,szName);
   _tcscpy(ptr->szProgram,szProgram);
   _tcscpy(ptr->szParams,szParams);
   ptr->bDoCopy = bDoCopy;

   ptr->next = NULL;
   if ( g_pHeadIcon == NULL )     // If this is the first record in the linked list
   {
       g_pHeadIcon = ptr;
   }
   else
   {
       g_pTailIcon->next = ptr;
   }
   g_pTailIcon = ptr;

   return TRUE;
}


// delete named IconMenu item from linked list

static void DeleteRecord(LPTSTR lpName)
{
    IconMenu * ptr;
    IconMenu * prevptr;

    if ( g_pHeadIcon != NULL )
    {
        ptr = g_pHeadIcon;
        prevptr = NULL;
        while (ptr != NULL)
        {
            if (_tcsicmp(lpName,ptr->szName) == 0)
            {
                if (prevptr == NULL)
                {
                    g_pHeadIcon = ptr->next;
                    if (g_pHeadIcon == NULL)
                    {
                        g_pTailIcon = NULL;
                    }
                    else 
                    {
                        if (g_pHeadIcon->next == NULL)
                        {
                            g_pTailIcon = g_pHeadIcon;
                        }
                    }
                }
                else
                {
                    prevptr->next = ptr->next;
                    if (prevptr->next == NULL)
                    {
                        g_pTailIcon = prevptr;
                    }
                }
                
                CmFree(ptr);
                return;
            }
            prevptr = ptr;
            ptr = ptr->next;
        }
    }
                
}

static BOOL MoveRecord(LPTSTR lpName, int direction)
{
    IconMenu * ptr;
    IconMenu * prevptr;
    IconMenu * nextptr;
    IconMenu TempIconMenu;

    if ( g_pHeadIcon != NULL )
    {
        ptr = g_pHeadIcon;
        prevptr = NULL;
        while (ptr != NULL)
        {
            if (_tcsicmp(lpName,ptr->szName) == 0)
            {
                if (((direction > 0)&&(ptr->next == NULL))||
                   ((direction < 0)&&(prevptr == NULL)))
                   return FALSE;

                if ((direction > 0)&&(ptr->next != NULL))
                {
                    //swap contents with next element
                    nextptr = ptr->next;
                    _tcscpy(TempIconMenu.szName,ptr->szName);
                    _tcscpy(TempIconMenu.szProgram,ptr->szProgram);
                    _tcscpy(TempIconMenu.szParams,ptr->szParams);
                    TempIconMenu.bDoCopy = ptr->bDoCopy;

                    _tcscpy(ptr->szName,nextptr->szName);
                    _tcscpy(ptr->szProgram,nextptr->szProgram);
                    _tcscpy(ptr->szParams,nextptr->szParams);
                    ptr->bDoCopy = nextptr->bDoCopy;

                    _tcscpy(nextptr->szName,TempIconMenu.szName);
                    _tcscpy(nextptr->szProgram,TempIconMenu.szProgram);
                    _tcscpy(nextptr->szParams,TempIconMenu.szParams);
                    nextptr->bDoCopy = TempIconMenu.bDoCopy;

                }
                else 
                {
                    if ((direction < 0)&&(prevptr != NULL))
                    {
                        _tcscpy(TempIconMenu.szName,ptr->szName);
                        _tcscpy(TempIconMenu.szProgram,ptr->szProgram);
                        _tcscpy(TempIconMenu.szParams,ptr->szParams);
                        TempIconMenu.bDoCopy = ptr->bDoCopy;

                        _tcscpy(ptr->szName,prevptr->szName);
                        _tcscpy(ptr->szProgram,prevptr->szProgram);
                        _tcscpy(ptr->szParams,prevptr->szParams);
                        ptr->bDoCopy = prevptr->bDoCopy;

                        _tcscpy(prevptr->szName,TempIconMenu.szName);
                        _tcscpy(prevptr->szProgram,TempIconMenu.szProgram);
                        _tcscpy(prevptr->szParams,TempIconMenu.szParams);
                        prevptr->bDoCopy = TempIconMenu.bDoCopy;
                    }
                }
                return TRUE;
            }
            prevptr = ptr;
            ptr = ptr->next;
        }
    }
    return TRUE;                
}

// retrieve named IconMenu item from linked list

BOOL GetIconMenuItem(LPTSTR lpName, IconMenu * EditItem)
{
    IconMenu * ptr;
    if ( g_pHeadIcon != NULL )
    {
        ptr = g_pHeadIcon;
        while (ptr != NULL)
        {
            if (_tcsicmp(lpName,ptr->szName) == 0)
            {
                _tcscpy(EditItem->szName,ptr->szName);
                _tcscpy(EditItem->szProgram,ptr->szProgram);
                _tcscpy(EditItem->szParams,ptr->szParams);
                EditItem->bDoCopy = ptr->bDoCopy;
                return TRUE;
            }
            ptr = ptr->next;
        }
    }
    return FALSE;
                
}

static BOOL WriteCopyMenuItemFiles(HANDLE hInf,LPTSTR pszFailFile, BOOL bWriteShortName)
{
    IconMenu * ptr;

    if (g_pHeadIcon != NULL)
    {
        ptr = g_pHeadIcon;
        while (ptr != NULL)
        {
            if (ptr->bDoCopy)
            {               
                if (!WriteCopy(hInf, ptr->szProgram, bWriteShortName))
                {
                    _tcscpy(pszFailFile, ptr->szProgram);
                    return FALSE;
                }
            }

            ptr = ptr->next;
        }
    }
    return TRUE;
}

static BOOL WriteCopyConActFiles(HANDLE hInf, LPTSTR pszFailFile, BOOL bWriteShortName)
{
    TCHAR szTemp[MAX_PATH+1];
    HRESULT hr = E_INVALIDARG;

    MYDBGASSERT(INVALID_HANDLE_VALUE != hInf);
    MYDBGASSERT(pszFailFile);
    MYDBGASSERT(g_pCustomActionList);

    if ((INVALID_HANDLE_VALUE != hInf) && pszFailFile && g_pCustomActionList)
    {
        CustomActionListEnumerator EnumPrograms(g_pCustomActionList);

        do
        {
            hr = EnumPrograms.GetNextIncludedProgram(szTemp, MAX_PATH);

            if (SUCCEEDED(hr) && (S_FALSE != hr))
            {
                if (!WriteCopy(hInf, szTemp, bWriteShortName))
                {
                    _tcscpy(pszFailFile, szTemp);

                    hr = E_UNEXPECTED;
                }
            }

        } while (SUCCEEDED(hr) && (S_FALSE != hr));
    }

    return SUCCEEDED(hr);
}


static BOOL WriteCopyExtraFiles(HANDLE hInf,LPTSTR pszFailFile, BOOL bWriteShortName)
{
    ListBxList * ptr;
    ExtraData * pExtraData;

    if (g_pHeadExtra != NULL)
    {
        ptr = g_pHeadExtra;
        while (ptr != NULL)
        {
            pExtraData = (ExtraData *)(ptr->ListBxData);

            if (!WriteCopy(hInf, pExtraData->szPathname, bWriteShortName))
            {
                _tcscpy(pszFailFile, pExtraData->szPathname);
                return FALSE;
            }
            ptr = ptr->next;
        }
    }
    return TRUE;
}

static BOOL WriteCopyDnsFiles(HANDLE hInf, LPTSTR pszFailFile, BOOL bWriteShortName)
{
    ListBxList * ptr;
    CDunSetting* pDunSetting;

    if (g_pHeadDunEntry != NULL)
    {
        ptr = g_pHeadDunEntry;
        while (ptr != NULL)
        {
            pDunSetting = (CDunSetting*)(ptr->ListBxData);
            if (!WriteCopy(hInf, pDunSetting->szScript, bWriteShortName))
            {
                _tcscpy(pszFailFile, pDunSetting->szScript);
                return FALSE;
            }
            ptr = ptr->next;
        }
    }
    return TRUE;
}

void WriteDelMenuItemFiles(HANDLE hInf)
{
    IconMenu * ptr;

    if ( g_pHeadIcon != NULL )
    {
        ptr = g_pHeadIcon;
        while (ptr != NULL)
        {
            if (ptr->bDoCopy)
            {
                MYVERIFY(FALSE != WriteInfLine(hInf,ptr->szProgram));
            }
        
            ptr = ptr->next;
        }
    }
}

static BOOL WriteRefsFiles(HANDLE hInf,BOOL WriteCM)
{
    ListBxList * ptr;
    TCHAR szTemp[MAX_PATH+1];

    if ( g_pHeadRefs != NULL )
    {
        ptr = g_pHeadRefs;
        while (ptr != NULL)
        {
            if ((_tcsstr(ptr->szName,c_pszCmpExt) == NULL) && (!WriteCM))
            {
                MYVERIFY(FALSE != WriteInfLine(hInf,ptr->szName));
            }
            else 
            {
                if ((_tcsstr(ptr->szName,c_pszCmpExt) != NULL) && (WriteCM))
                {
                    _tcscpy(szTemp,ptr->szName);
                    _tcscat(szTemp, TEXT(",,,16")); // set to not overwrite existing file
                    MYVERIFY(FALSE != WriteInfLine(hInf,szTemp));
                }
            }

            ptr = ptr->next;
        }
    }
    return TRUE;
}

static BOOL WriteShortRefsFiles(HANDLE hInf,BOOL WriteCM)
{
    ListBxList * ptr;
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szShort[MAX_PATH + 1];
    RenameData TmpRenameData;
    TCHAR szCurrentDir[MAX_PATH+1];

    if (g_pHeadRefs != NULL)
    {
        ptr = g_pHeadRefs;
        // hack to fix short filename resolution
        // change dir to cmaktemp dir and use getshortpathname

        MYVERIFY(0 != GetCurrentDirectory(MAX_PATH, szCurrentDir));
        MYVERIFY(0 != SetCurrentDirectory(g_szTempDir));
        while (ptr != NULL)
        {
            if ((_tcsstr(ptr->szName,c_pszCmpExt) == NULL) && (!WriteCM))
            {
                // writing non-cmp files so I want to make sure that I use
                // the short file name if it is actually a long filename.
                
                if (GetShortPathName(ptr->szName, szShort, MAX_PATH))
                {
                    _tcscpy(szTemp, szShort);

                    if (_tcsicmp(szShort,ptr->szName) != 0)
                    {
                        _tcscpy(TmpRenameData.szShortName,szShort);
                        _tcscpy(TmpRenameData.szLongName,ptr->szName);
                        MYVERIFY(FALSE != createListBxRecord(&g_pHeadRename,&g_pTailRename,(void *)&TmpRenameData,sizeof(TmpRenameData),TmpRenameData.szShortName));
                    }
                } 
                else 
                {
                    _tcscpy(szTemp, ptr->szName);
                }

                MYVERIFY(FALSE != WriteInfLine(hInf,szTemp));
            } 
            else 
            {
                if ((_tcsstr(ptr->szName,c_pszCmpExt) != NULL) && (WriteCM)) 
                {
                    _tcscpy(szTemp,ptr->szName);
                    _tcscat(szTemp, TEXT(",,,16")); // set to not overwrite existing file
                    MYVERIFY(FALSE != WriteInfLine(hInf,szTemp));
                }
            }

            ptr = ptr->next;
        }

        MYVERIFY(0 != SetCurrentDirectory(szCurrentDir));
    }
    return TRUE;
}

static BOOL WriteLongRefsFiles(HANDLE hInf)
{
    ListBxList * ptr;
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szShort[MAX_PATH + 1];
    RenameData TmpRenameData;
    TCHAR szCurrentDir[MAX_PATH+1];

    if (g_pHeadRefs != NULL)
    {
        ptr = g_pHeadRefs;

        while (ptr != NULL)
        {
            GetFileName(ptr->szName, szTemp);

            MYVERIFY(FALSE != WriteInfLine(hInf, szTemp));
            
            ptr = ptr->next;
        }
    }
    return TRUE;
}

BOOL WriteDelConActFiles(HANDLE hInf)
{
    TCHAR szTemp[MAX_PATH+1];
    HRESULT hr = E_INVALIDARG;

    MYDBGASSERT(INVALID_HANDLE_VALUE != hInf);
    MYDBGASSERT(g_pCustomActionList);

    if ((INVALID_HANDLE_VALUE != hInf) && g_pCustomActionList)
    {

        CustomActionListEnumerator EnumPrograms(g_pCustomActionList);

        do
        {
            hr = EnumPrograms.GetNextIncludedProgram(szTemp, MAX_PATH);

            if (SUCCEEDED(hr) && (S_FALSE != hr))
            {
                if (FALSE == WriteInfLine(hInf, szTemp))
                {
                    hr = E_UNEXPECTED;
                }
            }

        } while (SUCCEEDED(hr) && (S_FALSE != hr));
    }

    MYDBGASSERT(SUCCEEDED(hr));

    return SUCCEEDED(hr);
}


void WriteDelExtraFiles(HANDLE hInf)
{
    ListBxList * ptr;
    ExtraData * pExtraData;

    if ( g_pHeadExtra != NULL )
    {
        ptr = g_pHeadExtra;
        while (ptr != NULL)
        {
            pExtraData = (ExtraData *)(ptr->ListBxData);
            MYVERIFY(FALSE != WriteInfLine(hInf,pExtraData->szPathname));
            ptr = ptr->next;
        }
    }
}

void WriteDelDnsFiles(HANDLE hInf)
{

    ListBxList * ptr;
    CDunSetting * pDunSetting;

    if (NULL != g_pHeadDunEntry)
    {
        ptr = g_pHeadDunEntry;
        while (ptr != NULL)
        {
            pDunSetting = (CDunSetting*)(ptr->ListBxData);

            MYVERIFY(FALSE != WriteInfLine(hInf, pDunSetting->szScript));
            
            ptr = ptr->next;
        }
    }
}

void WriteSrcMenuItemFiles(HANDLE hInf)
{
    IconMenu * ptr;

    if ( g_pHeadIcon != NULL )
    {
        ptr = g_pHeadIcon;
        while (ptr != NULL)
        {
            if (ptr->bDoCopy)
            {
                MYVERIFY(FALSE != WriteSrcInfLine(hInf,ptr->szProgram));
            }
            
            ptr = ptr->next;
        }
    }
}

BOOL WriteSrcConActFiles(HANDLE hInf)
{
    TCHAR szTemp[MAX_PATH+1];
    HRESULT hr = E_INVALIDARG;

    MYDBGASSERT(INVALID_HANDLE_VALUE != hInf);
    MYDBGASSERT(g_pCustomActionList);

    if ((INVALID_HANDLE_VALUE != hInf) && g_pCustomActionList)
    {

        CustomActionListEnumerator EnumPrograms(g_pCustomActionList);

        do
        {
            hr = EnumPrograms.GetNextIncludedProgram(szTemp, MAX_PATH);

            if (SUCCEEDED(hr) && (S_FALSE != hr))
            {
                if (FALSE == WriteSrcInfLine(hInf, szTemp))
                {
                    hr = E_UNEXPECTED;
                }
            }

        } while (SUCCEEDED(hr) && (S_FALSE != hr));
    }

    return SUCCEEDED(hr);
}
//+----------------------------------------------------------------------------
//
// Function:  WriteSrcRefsFiles
//
// Synopsis:  This function writes all the files on the HeadRef list to the 
//            [SourceDisksFiles] section of the INF.  Note that it has to change 
//            directory to the temp dir so that the WriteSrcInfLine won't fail
//            (it needs to locate the file to see if a short name should be used).
//
// Arguments: HANDLE hInf - Handle to the open inf file to pass to WriteSrcInfLine
//
// Returns:   Returns TRUE if all the files were written out successfully
//
// History:   quintinb  Created Header and added hack to fix failure of WriteSrcInfLine
//                      because it couldn't find the file to find its short name 1/22/98
//
//+----------------------------------------------------------------------------

BOOL WriteSrcRefsFiles(HANDLE hInf)
{
    ListBxList * ptr;
    BOOL bSuccess = TRUE;
    TCHAR szSavedDir[MAX_PATH+1];

    //
    //  Save the current directory and then set the current dir to
    //  the temp dir so that WriteSrcInfLine can find the shortfilename
    //  of the referenced files.
    //

    if ( g_pHeadRefs != NULL )
    {

        if (0 == GetCurrentDirectory(MAX_PATH, szSavedDir))
        {
            return FALSE;
        }
        
        if (0 == SetCurrentDirectory(g_szTempDir))
        {
            return FALSE;
        }

        ptr = g_pHeadRefs;
        while (ptr != NULL)
        {
            bSuccess = (bSuccess && WriteSrcInfLine(hInf,ptr->szName));
            ptr = ptr->next;
        }

        MYVERIFY(0 != SetCurrentDirectory(szSavedDir));
    }


    return bSuccess;
}

void WriteSrcExtraFiles(HANDLE hInf)
{
    ListBxList * ptr;
    ExtraData * pExtraData;
    
    if ( g_pHeadExtra != NULL )
    {
        ptr = g_pHeadExtra;
        while (ptr != NULL)
        {
            pExtraData = (ExtraData *)(ptr->ListBxData);
            MYVERIFY(FALSE != WriteSrcInfLine(hInf,pExtraData->szPathname));
            ptr = ptr->next;
        }
    }
}

void WriteSrcDnsFiles(HANDLE hInf)
{
    ListBxList * ptr;
    CDunSetting* pDunSetting;

    if (NULL != g_pHeadDunEntry)
    {
        ptr = g_pHeadDunEntry;

        while (NULL != ptr)
        {
            pDunSetting = (CDunSetting*)(ptr->ListBxData);

            MYVERIFY(FALSE != WriteSrcInfLine(hInf, pDunSetting->szScript));
            
            ptr = ptr->next;
        }
    }
}

BOOL WriteSEDConActFiles(HWND hDlg, int* pFileNum, LPCTSTR szSed)
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szFileName[MAX_PATH+1];
    HRESULT hr = E_INVALIDARG;

    MYDBGASSERT(hDlg);
    MYDBGASSERT(pFileNum);
    MYDBGASSERT(szSed);
    MYDBGASSERT(g_pCustomActionList);

    if (hDlg && pFileNum && szSed && g_pCustomActionList)
    {
        CustomActionListEnumerator EnumPrograms(g_pCustomActionList);

        do
        {
            hr = EnumPrograms.GetNextIncludedProgram(szTemp, MAX_PATH);

            if (SUCCEEDED(hr) && (S_FALSE != hr))
            {
                GetFileName(szTemp, szFileName);

                if (FALSE == WriteSED(hDlg, szFileName, pFileNum, szSed))
                {
                    hr = E_UNEXPECTED;
                }
            }

        } while (SUCCEEDED(hr) && (S_FALSE != hr));
    }

    return SUCCEEDED(hr);
}

BOOL WriteSEDExtraFiles(HWND hDlg, int* pFileNum, LPCTSTR szSed)
{
    ListBxList * ptr;
    ExtraData * pExtraData;
    BOOL bReturn = TRUE;

    if ( g_pHeadExtra != NULL )
    {
        ptr = g_pHeadExtra;
        while (ptr != NULL)
        {
            pExtraData = (ExtraData *)(ptr->ListBxData);
            bReturn &= WriteSED(hDlg, pExtraData->szPathname, pFileNum, szSed);
            ptr = ptr->next;
        }
    }

    return bReturn;
}

BOOL WriteSEDDnsFiles(HWND hDlg, int* pFileNum, LPCTSTR szSed)
{
    BOOL bReturn = TRUE;
    ListBxList * ptr;
    CDunSetting* pDunSetting;
    
    if (NULL !=  g_pHeadDunEntry)
    {
        ptr = g_pHeadDunEntry;

        while (NULL != ptr)
        {
            pDunSetting = (CDunSetting*)(ptr->ListBxData);

            bReturn &= WriteSED(hDlg, pDunSetting->szScript, pFileNum, szSed);
            
            ptr = ptr->next;
        }
    }

    return bReturn;
}

BOOL WriteSEDRefsFiles(HWND hDlg, int* pFileNum, LPCTSTR szSed)
{
    ListBxList * ptr;
    BOOL bReturn = TRUE;

    if ( g_pHeadRefs != NULL )
    {
        ptr = g_pHeadRefs;
        while (ptr != NULL)
        {
            bReturn &= WriteSED(hDlg, ptr->szName, pFileNum, szSed);
            ptr = ptr->next;
        }
    }
    return bReturn;
}

BOOL WriteSEDMenuItemFiles(HWND hDlg, int* pFileNum, LPCTSTR szSed)
{
    IconMenu * ptr;
    BOOL bReturn = TRUE;

    if ( g_pHeadIcon != NULL )
    {
        ptr = g_pHeadIcon;
        while (ptr != NULL)
        {
            if (ptr->bDoCopy)
            {
                bReturn &= WriteSED(hDlg, ptr->szProgram, pFileNum, szSed);
            }
            ptr = ptr->next;
        }
    }

    return bReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  WriteRenameSection
//
// Synopsis:  This function verifies that the name used in the rename data structure
//            is correct (the files name in the temp directory could be different
//            if the file was moved from a directory with multiple similarly named files) and then
//            writes the rename section to the inf.
//
// Arguments: HANDLE hInf - handle to the inf to add the rename section to.
//
// Returns:   Nothing
//
// History:   quintinb Created Header and added checking functionality   2/22/98
//
//+----------------------------------------------------------------------------
void WriteRenameSection(HANDLE hInf)
{
    ListBxList * ptr;
    TCHAR szOut[MAX_PATH+1];
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szPathToFileInTempDir[MAX_PATH+1];

    RenameData * pRenameData;

    if ( g_pHeadRename != NULL )
    {
        ptr = g_pHeadRename;
        MYVERIFY(FALSE != WriteInf(hInf,TEXT("\r\n")));
        MYVERIFY(FALSE != WriteInf(hInf,TEXT("[Xnstall.RenameReg]\r\n")));
        WriteInf(hInf, TEXT("HKLM,%KEY_RENAME%\\CMRENAME,,,\"%49001%\\%ShortSvcName%\"\r\n"));//lint !e534 compile doesn't like the MYVERIFY macro and big strings

        while (ptr != NULL)
        {
            pRenameData = (RenameData *)(ptr->ListBxData);

            //
            //  Get the current ShortName for the File
            //

            GetFileName(pRenameData->szLongName, szTemp);            
            MYVERIFY(CELEMS(szPathToFileInTempDir) > (UINT)wsprintf(szPathToFileInTempDir, 
                TEXT("%s\\%s"), g_szTempDir, szTemp));

            MYVERIFY(0 != GetShortPathName(szPathToFileInTempDir, szTemp, MAX_PATH));

            GetFileName(szTemp, pRenameData->szShortName);

            //
            //  Now Write out the files
            //
            _tcscpy(szOut,TEXT("HKLM,%KEY_RENAME%\\CMRENAME,"));
            _tcscat(szOut,pRenameData->szShortName);
            _tcscat(szOut,TEXT(",,\""));
            _tcscat(szOut,pRenameData->szLongName);
            _tcscat(szOut,TEXT("\"\r\n"));
            MYDBGASSERT(_tcslen(szOut) <= sizeof(szOut));
            MYVERIFY(FALSE != WriteInf(hInf,szOut));
            ptr = ptr->next;
        }
    }
}

void WriteEraseLongName(HANDLE hInf)
{
    ListBxList * ptr;
    TCHAR szOut[MAX_PATH+1];
    RenameData * pRenameData;

    if ( g_pHeadRename != NULL )
    {
        ptr = g_pHeadRename;
        while (ptr != NULL)
        {
            pRenameData = (RenameData *)(ptr->ListBxData);
            pRenameData->szShortName[7] = pRenameData->szShortName[7]+1;
            _tcscpy(szOut,pRenameData->szShortName);
            _tcscat(szOut,TEXT("\r\n"));
            MYVERIFY(FALSE != WriteInf(hInf,szOut));
            ptr = ptr->next;
        }
    }
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessMenuItem
//
// Synopsis:  This function retrieves the data associated with the given keyname
//            under the [Menu Options] section of the given cms file.  It then
//            processes the data line into a program part and a parameters part.
//            Then using the keyname, the program string, and the params string
//            it adds an entry to the Status Area Menu Item linked list.
//
// Arguments: LPCTSTR pszKeyName - Name of the Menu Item
//            LPCTSTR pszCmsFile - CMS file containing the menu items
//            LPCTSTR pszProfilesDir - directory containing the profiles dir 
//                                     (to help determine if the file was included or not)
//
// Returns:   BOOL - TRUE if successful
//
// History:   quintinb Created     6/14/99
//
//+----------------------------------------------------------------------------
BOOL ProcessMenuItem(LPCTSTR pszKeyName, LPCTSTR pszCmsFile, LPCTSTR pszProfilesDir)
{

    //
    //  Check parameters
    //
    if ((NULL == pszKeyName) || (NULL == pszCmsFile) || 
        (TEXT('\0') == pszKeyName[0]) || (TEXT('\0') == pszCmsFile[0]))
    {
        CMTRACE(TEXT("ProcessMenuItem -- bad parameter passed."));
        return FALSE;
    }

    BOOL bFileIncluded = FALSE;
    BOOL bLongFileName = FALSE;
    BOOL bReturn = FALSE;
    LPTSTR pszParams = NULL;
    LPTSTR pszProgram = NULL;
    TCHAR szProgram[MAX_PATH+1];
    TCHAR SeperatorChar = TEXT('\0');

    //
    //  Get the Menu Item specified by pszKeyName
    //
    LPTSTR pszLine = GetPrivateProfileStringWithAlloc(c_pszCmSectionMenuOptions, pszKeyName, TEXT(""), pszCmsFile);

    if ((NULL == pszLine) || (TEXT('\0') == pszLine[0]))
    {
        CMTRACE(TEXT("ProcessMenuItem -- GetPrivateProfileStringWithAlloc failed"));
        goto exit;
    }

    //
    //  Now that we have a menu item, begin processing.  Since we have the keyname, we already
    //  have the name of the menu item.  We now could have any of the following strings:
    //
    //  +Program Name+ Params
    //  +Program Name+
    //  ProgName Params
    //  ProgName
    //
    //  Note that we surround long filenames with the '+' char.
    //

    CmStrTrim(pszLine);
    if (TEXT('+') == pszLine[0])
    {
        bLongFileName = TRUE;
        SeperatorChar = TEXT('+');

        pszProgram = CharNext(pszLine); // move past the initial +
    }
    else
    {
        bLongFileName = FALSE;
        SeperatorChar = TEXT(' ');

        pszProgram = pszLine;
    }

    pszParams = CmStrchr(pszProgram, SeperatorChar);

    if (pszParams)
    {
        LPTSTR pszTemp = pszParams;
        pszParams = CharNext(pszParams); // pszParams is either a NULL string or it is the parameters with a space.

        *pszTemp = TEXT('\0');
    }
    else
    {
        if (bLongFileName)
        {
            CMTRACE1(TEXT("ProcessMenuItem -- Unexpected Menu Item format: %s"), pszLine);
            goto exit;        
        }
        else
        {
            //
            //  Then we don't have any parameters, just a Program
            //
            pszParams = CmEndOfStr(pszProgram);
        }
    }

    CmStrTrim(pszParams);
    CmStrTrim(pszProgram);

    //
    //  Now check to see if the file exists in the profile or not
    //
    MYVERIFY(CELEMS(szProgram) > (UINT)wsprintf(szProgram, TEXT("%s%s"), pszProfilesDir, pszProgram));
    
    bFileIncluded = FileExists(szProgram);
    if (bFileIncluded)
    {
        //
        //  If we are in this if block then we have an edited profile that contains menu items.
        //  Use the full path to add to the record list.
        //
        pszProgram = szProgram; // memory will be cleaned up below because we only had one 
                                // allocation that we split up into several pieces.
    }

    bReturn = createRecord(pszKeyName, pszProgram, pszParams, bFileIncluded);

exit:

    CmFree(pszLine);
    return bReturn;
}



//+----------------------------------------------------------------------------
//
// Function:  ReadIconMenu
//
// Synopsis:  This function converts the Menu Options section of the given CMS
//            into the Status Area Menu Items linked list that internally 
//            represents it.
//
// Arguments: LPCTSTR pszCmsFile - Cms File to read the menu items from
//            LPCTSTR pszProfilesDir - full path to the Profiles directory 
//                                     (c:\program files\cmak\profiles usually)
//
// Returns:   BOOL - Returns TRUE if Successful
//
// History:   Created Header    6/14/99
//            quintinb Rewrote for Unicode Conversion   6/14/99
//
//+----------------------------------------------------------------------------
BOOL ReadIconMenu(LPCTSTR pszCmsFile, LPCTSTR pszProfilesDir)
{
    BOOL bReturn = TRUE;
    LPTSTR pszCurrentKeyName = NULL;

    //
    //  By calling WritePrivateProfileString with all NULL's we flush the file cache 
    //  (win95 only).  This call will return 0.
    //

    WritePrivateProfileString(NULL, NULL, NULL, g_szCmsFile); //lint !e534 this call will always return 0

    //
    //  First we want to get all of the keynames in the Menu Options section
    //
    LPTSTR pszKeyNames = GetPrivateProfileStringWithAlloc(c_pszCmSectionMenuOptions, NULL, TEXT(""), pszCmsFile);

    if (NULL == pszKeyNames)
    {
        //
        //  Nothing to process
        //
        goto exit;
    }

    pszCurrentKeyName = pszKeyNames;

    while (TEXT('\0') != (*pszCurrentKeyName))
    {        
        //
        //  Process the command line
        //
        bReturn = bReturn && ProcessMenuItem(pszCurrentKeyName, pszCmsFile, pszProfilesDir);
        
        //
        //  Find the next string by going to the end of the string
        //  and then going one more char.  Note that we cannot use
        //  CharNext here but must use just ++.
        //
        pszCurrentKeyName = CmEndOfStr(pszCurrentKeyName);
        pszCurrentKeyName++;
    }

exit:
    CmFree(pszKeyNames);

    return bReturn;
}

static void WriteIconMenu()
{
    IconMenu * LoopPtr;
    TCHAR szTemp[2*MAX_PATH+1];
    TCHAR szName[MAX_PATH+1];
    BOOL longname;

    // CLEAR OUT SECTION
    MYVERIFY(0 != WritePrivateProfileSection(c_pszCmSectionMenuOptions,TEXT("\0\0"),g_szCmsFile));

    if (g_pHeadIcon == NULL)
    {
        return;
    }
    LoopPtr = g_pHeadIcon;

    // WRITE IN ALL ENTRIES
    while( LoopPtr != NULL)
    {
        GetFileName(LoopPtr->szProgram,szName);

        if (IsFile8dot3(szName))
        {
            longname = FALSE;
        }
        else
        {
            longname = TRUE;            
        }

        // surround long file names with plus signs - quotes won't work cause 
        // they get stripped by the reading routines
        if (longname)
        {
            _tcscpy(szTemp,TEXT("+"));
        }
        else
        {
            szTemp[0] = TEXT('\0');
        }

        if (LoopPtr->bDoCopy)
        {
            _tcscat(szTemp,g_szShortServiceName);
            _tcscat(szTemp,TEXT("\\"));
        }

        _tcscat(szTemp,szName);

        if (longname)
        {
            _tcscat(szTemp,TEXT("+"));
        }

        _tcscat(szTemp,TEXT(" "));
        _tcscat(szTemp,LoopPtr->szParams);
        MYDBGASSERT(_tcslen(szTemp) <= CELEMS(szTemp));
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionMenuOptions,LoopPtr->szName,szTemp,g_szCmsFile));
        LoopPtr = LoopPtr->next;
    }
    
    //
    //  By calling WritePrivateProfileString with all NULL's we flush the file cache 
    //  (win95 only).  This call will return 0.
    //

    WritePrivateProfileString(NULL, NULL, NULL, g_szCmsFile); //lint !e534 this call will always return 0

}

static void RefreshIconMenu(HWND hwndDlg)
{
    IconMenu * LoopPtr;

    SendDlgItemMessage(hwndDlg,IDC_LIST1,LB_RESETCONTENT,0,(LPARAM)0); //lint !e534 LB_RESETCONTENT doesn't return anything
    if (g_pHeadIcon == NULL)
    {
        return;
    }
    LoopPtr = g_pHeadIcon;
    while( LoopPtr != NULL)
    {
        MYVERIFY(LB_ERR != SendDlgItemMessage(hwndDlg, IDC_LIST1, LB_ADDSTRING, 0,
            (LPARAM) LoopPtr->szName));

        LoopPtr = LoopPtr->next;
    }
}

void UpdateEditDeleteMoveButtons(HWND hDlg, IconMenu* pHeadIcon)
{
    
    LRESULT lResult;
    BOOL bEnableDeleteAndEdit = FALSE;
    BOOL bEnableMoveUp = FALSE;
    BOOL bEnableMoveDown = FALSE;

    lResult = SendDlgItemMessage(hDlg, IDC_LIST1, LB_GETCOUNT, 0, 0);
    
    if (LB_ERR != lResult)
    {
        //
        //  Enable the Delete and Edit Buttons because we have at least 1 item.
        //
        bEnableDeleteAndEdit = (0 < lResult);

        //
        //  If we have more than 1 item, then we need to enable the moveup and movedown
        //  buttons, depending on which item is selected.
        //
        if (1 < lResult)
        {

            bEnableMoveUp = TRUE;
            bEnableMoveDown = TRUE;

            //
            //  Get the name of the currently selected item
            //
            TCHAR szCurrentItem[MAX_PATH+1];
            lResult = SendDlgItemMessage(hDlg, IDC_LIST1, LB_GETCURSEL, 0, 0);

            if (LB_ERR != lResult)
            {
                lResult = SendDlgItemMessage(hDlg, IDC_LIST1, LB_GETTEXT, lResult, (LPARAM)szCurrentItem);

                if (LB_ERR != lResult)
                {
                    IconMenu* pFollower = NULL;
                    IconMenu* pCurrent = pHeadIcon;

                    while (pCurrent)
                    {
                        if (0 == lstrcmpi(szCurrentItem, pCurrent->szName))
                        {
                            if (NULL == pFollower)
                            {
                                //
                                //  First item in the list, disable move up
                                //
                                bEnableMoveUp = FALSE;
                            }
                            else if (NULL == pCurrent->next)
                            {
                                //
                                //  Last item in the list, disable move down
                                //
                                bEnableMoveDown = FALSE;
                            }

                            break;
                        }

                        pFollower = pCurrent;
                        pCurrent = pCurrent->next;
                    }
                }
            }
        }
    }

    HWND hCurrentFocus = GetFocus();
    HWND hEditButton = GetDlgItem(hDlg, IDC_BUTTON2);
    HWND hDeleteButton = GetDlgItem(hDlg, IDC_BUTTON3);
    HWND hMoveUpButton = GetDlgItem(hDlg, IDC_BUTTON4);
    HWND hMoveDownButton = GetDlgItem(hDlg, IDC_BUTTON5);
    HWND hControl;

    if (hEditButton)
    {
        EnableWindow(hEditButton, bEnableDeleteAndEdit);
    }            

    if (hDeleteButton)
    {
        EnableWindow(hDeleteButton, bEnableDeleteAndEdit);
    }            

    if (hMoveUpButton)
    {
        EnableWindow(hMoveUpButton, bEnableMoveUp);
    }            

    if (hMoveDownButton)
    {
        EnableWindow(hMoveDownButton, bEnableMoveDown);
    }
    
    if (FALSE == IsWindowEnabled(hCurrentFocus))
    {
        if (hDeleteButton == hCurrentFocus)
        {
            //
            //  If delete is disabled and contained the focus, shift it to the Add button
            //
            hControl = GetDlgItem(hDlg, IDC_BUTTON1);
            SendMessage(hDlg, DM_SETDEFID, IDC_BUTTON1, (LPARAM)0L); //lint !e534 DM_SETDEFID doesn't return error info
            SetFocus(hControl);
        }
        else if ((hMoveUpButton == hCurrentFocus) && IsWindowEnabled(hMoveDownButton))
        {
            SetFocus(hMoveDownButton);
            SendMessage(hDlg, DM_SETDEFID, IDC_BUTTON5, (LPARAM)0L); //lint !e534 DM_SETDEFID doesn't return error info
        }
        else if ((hMoveDownButton == hCurrentFocus) && IsWindowEnabled(hMoveUpButton))
        {
            SetFocus(hMoveUpButton);
            SendMessage(hDlg, DM_SETDEFID, IDC_BUTTON4, (LPARAM)0L); //lint !e534 DM_SETDEFID doesn't return error info
        }
        else
        {
            //
            //  If all else fails set the focus to the list control
            //
            hControl = GetDlgItem(hDlg, IDC_LIST1);
            SetFocus(hControl);
        }    
    }
}

BOOL OnProcessStatusMenuIconsEdit(HWND hDlg)
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szOld[MAX_PATH+1];
    INT_PTR nResult;

    nResult = SendDlgItemMessage(hDlg, IDC_LIST1, LB_GETCURSEL, 0, (LPARAM)0);

    if (nResult == LB_ERR)
    {
        MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NOSELECTION, MB_OK));
        return TRUE;
    }

    MYVERIFY(LB_ERR != SendDlgItemMessage(hDlg, IDC_LIST1, LB_GETTEXT, (WPARAM)nResult, (LPARAM)szTemp));

    MYVERIFY(FALSE != GetIconMenuItem(szTemp, &DlgEditItem));

    _tcscpy(szOld, szTemp);
    
    nResult = DialogBoxParam(NULL, MAKEINTRESOURCE(IDD_MENU_ITEM_POPUP), hDlg, ProcessStatusMenuPopup, (LPARAM)0);
    
    if ((IDOK == nResult) && (TEXT('\0') != DlgEditItem.szName[0]))
    {
        if (0 == lstrcmpi(szOld, DlgEditItem.szName))
        {
            MYVERIFY(FALSE != updateRecord(DlgEditItem.szName, DlgEditItem.szProgram, 
                DlgEditItem.szParams, DlgEditItem.bDoCopy, szOld));                 
        }
        else
        {
            DeleteRecord(szOld);
            MYVERIFY(TRUE == createRecord(DlgEditItem.szName, DlgEditItem.szProgram, 
                DlgEditItem.szParams, DlgEditItem.bDoCopy));
        }
    
        RefreshIconMenu(hDlg);
        
        WriteIconMenu();
        
        nResult = SendDlgItemMessage(hDlg, IDC_LIST1, LB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)DlgEditItem.szName);
        
        if (LB_ERR != nResult)
        {
            MYVERIFY(LB_ERR != SendDlgItemMessage(hDlg,IDC_LIST1,LB_SETCURSEL,(WPARAM)nResult,(LPARAM)0));
        }

        UpdateEditDeleteMoveButtons(hDlg, g_pHeadIcon);
    }

    return TRUE;
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessStatusMenuIcons
//
// Synopsis:  Customize the status area icon menu
//
//
// History:   quintinb  Created Header and renamed from ProcessPage2F1    8/6/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessStatusMenuIcons(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szOld[MAX_PATH+1];
    INT_PTR nResult;
    int direction;
    NMHDR* pnmHeader = (NMHDR*)lParam;
    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_MENU)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_LIST1);

    switch (message)
    {
        case WM_INITDIALOG:
            {
                //
                //  Load the arrow images for the move up and move down buttons
                //
                HICON hUpArrow = (HICON)LoadImage(g_hInstance, MAKEINTRESOURCE(IDI_UP_ARROW), IMAGE_ICON, 0, 0, 0);
                HICON hDownArrow = (HICON)LoadImage(g_hInstance, MAKEINTRESOURCE(IDI_DOWN_ARROW), IMAGE_ICON, 0, 0, 0);

                //
                //  Set the arrow button bit maps
                //
                SendMessage(GetDlgItem(hDlg, IDC_BUTTON4), BM_SETIMAGE, IMAGE_ICON, (LPARAM)hUpArrow);
                SendMessage(GetDlgItem(hDlg, IDC_BUTTON5), BM_SETIMAGE, IMAGE_ICON, (LPARAM)hDownArrow);
            }
            break;

        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_BUTTON1: //add
                    
                    ZeroMemory(&DlgEditItem,sizeof(DlgEditItem));
                    
                    nResult = DialogBoxParam(NULL, MAKEINTRESOURCE(IDD_MENU_ITEM_POPUP), hDlg, ProcessStatusMenuPopup, (LPARAM)0);

                    if ((nResult == IDOK) && (DlgEditItem.szName[0] != 0))
                    {
                        MYVERIFY(FALSE != createRecord(DlgEditItem.szName, DlgEditItem.szProgram, DlgEditItem.szParams, DlgEditItem.bDoCopy));
                        RefreshIconMenu(hDlg);
                        WriteIconMenu();

                        nResult = SendDlgItemMessage(hDlg, IDC_LIST1, LB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)DlgEditItem.szName);                     
                        
                        if (LB_ERR != nResult)
                        {
                            MYVERIFY(LB_ERR != SendDlgItemMessage(hDlg,IDC_LIST1,LB_SETCURSEL,(WPARAM)nResult,(LPARAM)0));
                        }

                        UpdateEditDeleteMoveButtons(hDlg, g_pHeadIcon);
                    }
                    return (TRUE);
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case IDC_BUTTON2: //edit
                    OnProcessStatusMenuIconsEdit(hDlg);

                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case IDC_BUTTON3: //delete
                    nResult = SendDlgItemMessage(hDlg,IDC_LIST1,LB_GETCURSEL,0,(LPARAM)0);
                    if (nResult == LB_ERR)
                    {
                        MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NOSELECTION, MB_OK));
                        return TRUE;
                    }
                    
                    MYVERIFY(LB_ERR != SendDlgItemMessage(hDlg, IDC_LIST1, LB_GETTEXT, (WPARAM)nResult, 
                        (LPARAM)szTemp));

                    DeleteRecord(szTemp);

                    RefreshIconMenu(hDlg);

                    //
                    //  Reset the cursor selection to the first in the list, unless the list is empty.
                    //
                    nResult = SendDlgItemMessage(hDlg, IDC_LIST1, LB_GETCOUNT, (WPARAM)0, (LPARAM)0);

                    if (nResult)
                    {
                        MYVERIFY(LB_ERR != SendDlgItemMessage(hDlg, IDC_LIST1, LB_SETCURSEL, (WPARAM)0, (LPARAM)0));
                    }
                    
                    UpdateEditDeleteMoveButtons(hDlg, g_pHeadIcon);
                    
                    WriteIconMenu();
                    return (TRUE);

                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case IDC_BUTTON4: //UP
                case IDC_BUTTON5: //down
                    if (LOWORD(wParam) == IDC_BUTTON4)
                    {
                        direction = -1;
                    }
                    else
                    {
                        direction = 1;
                    }

                    nResult = SendDlgItemMessage(hDlg,IDC_LIST1,LB_GETCURSEL,0,(LPARAM)0);

                    if (nResult == LB_ERR)
                    {
                        MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NOSELECTION, MB_OK));
                        return TRUE;
                    }

                    MYVERIFY(LB_ERR != SendDlgItemMessage(hDlg, IDC_LIST1, LB_GETTEXT,
                        (WPARAM)nResult, (LPARAM)szTemp));

                    if (MoveRecord(szTemp,direction))
                    {
                        RefreshIconMenu(hDlg);
                        
                        MYVERIFY(LB_ERR != SendDlgItemMessage(hDlg, IDC_LIST1, LB_SETCURSEL, 
                            (WPARAM)(nResult + direction), (LPARAM)0));
                        
                        UpdateEditDeleteMoveButtons(hDlg, g_pHeadIcon);
                    }

                    WriteIconMenu();
                    
                    return (TRUE);

                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case IDC_LIST1:
                    if (LBN_DBLCLK == HIWORD(wParam))
                    {
                        OnProcessStatusMenuIconsEdit(hDlg);
                    }
                    else if (LBN_SELCHANGE == HIWORD(wParam))
                    {
                        //
                        //  The selection in the list box changed, update the move buttons if needed
                        //
                        UpdateEditDeleteMoveButtons(hDlg, g_pHeadIcon);
                    }
                    break;
                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {
                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));

                    if (g_pHeadIcon == NULL)
                    {
                        MYVERIFY(FALSE != ReadIconMenu(g_szCmsFile, g_szOsdir));
                    }
                    
                    RefreshIconMenu(hDlg);

                    //
                    //  Reset the cursor selection to the first in the list, unless the list is empty.
                    //  Then we should set focus on the Add button
                    //
                    nResult = SendDlgItemMessage(hDlg, IDC_LIST1, LB_GETCOUNT, (WPARAM)0, (LPARAM)0);

                    if (nResult)
                    {
                        MYVERIFY(LB_ERR != SendDlgItemMessage(hDlg, IDC_LIST1, LB_SETCURSEL, (WPARAM)0, (LPARAM)0));
                    }
                    else
                    {
                        SetFocus(GetDlgItem(hDlg, IDC_BUTTON1));
                    }

                    UpdateEditDeleteMoveButtons(hDlg, g_pHeadIcon);
                    break;

                case PSN_WIZBACK:
                    WriteIconMenu();

                    break;
                case PSN_WIZNEXT:
                    WriteIconMenu();
                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

//+----------------------------------------------------------------------------
//
// Function:  DisplayBitmap
//
// Synopsis:  This function takes a BMPDATA structure with a valid HDIBitmap data
//            (device Independent bitmap data) and creates a device dependent bitmap
//            and displays it on the specified bitmap window control.
//
// Arguments: HWND hDlg - Window handle of the dialog containing the Bitmap control
//            int iBitmapControl - Resource ID of the bitmap window control
//            HPALETTE* phMasterPalette - pointer to the master palette
//            BMPDATA* pBmpData - pointer to the BMPDATA to display
//
// Returns:   Nothing
//
// History:   quintinb Created   8/6/98
//
//+----------------------------------------------------------------------------
void DisplayBitmap(HWND hDlg, int iBitmapControl, HPALETTE* phMasterPalette, BMPDATA* pBmpData)
{
    MYDBGASSERT(NULL != pBmpData);
    MYDBGASSERT(pBmpData->hDIBitmap);
    MYDBGASSERT(NULL != phMasterPalette);
    if ((NULL != pBmpData) && (pBmpData->hDIBitmap) && (NULL != phMasterPalette))
    {       
        pBmpData->phMasterPalette = phMasterPalette;
        pBmpData->bForceBackground = FALSE; // Paint as a Foreground App

        if (CreateBitmapData(pBmpData->hDIBitmap, pBmpData, hDlg, TRUE))
        {
            SendDlgItemMessage(hDlg, iBitmapControl, STM_SETIMAGE, 
                IMAGE_BITMAP, 
                (LPARAM) pBmpData); //lint !e534 STM_SETIMAGE doesn't return error info
        }
    }
}

//+----------------------------------------------------------------------------
//
// Function:  ProcesssSigninBitmap
//
// Synopsis:  Customize the sign-in bitmap -- this function processes the
//            messages for the page in CMAK that handles customizing the 
//            sign-in dialog bitmap.
//
//
// History:   quintinb   Created Header    8/6/98
//            quintinb   Rewrote to use new shared bitmap handling code  8/6/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessSigninBitmap(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR* pszBitmap;
    NMHDR* pnmHeader = (NMHDR*)lParam;
    static TCHAR szDisplay[MAX_PATH+1]; // keeps unselected custom entry
    static BMPDATA BmpData;
    static HPALETTE hMasterPalette;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_BITMAPS)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_EDITSPLASH);

    switch (message)
    {

        case WM_INITDIALOG:
            SetFocus(GetDlgItem(hDlg, IDC_EDITSPLASH));
            break;

        case WM_PALETTEISCHANGING:
            break;

        case WM_PALETTECHANGED:
            
            if ((wParam != (WPARAM) hDlg) && (BmpData.hDIBitmap))
            {
                //
                // Handle the palette change.
                //              
                CMTRACE2(TEXT("ProcessSigninBitmap handling WM_PALETTECHANGED message, wParam=0x%x, hDlg=0x%x."), wParam, hDlg);
                PaletteChanged(&BmpData, hDlg, IDC_DEFAULTBRAND); 
            }
            
            return TRUE;
            break;  //lint !e527 Unreachable but please keep in case someone removes the return

        case WM_QUERYNEWPALETTE:

            QueryNewPalette(&BmpData, hDlg, IDC_DEFAULTBRAND);

            return TRUE;
            
            break;  //lint !e527 Unreachable but please keep in case someone removes the return

        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_RADIO1:

                    //
                    //  Display the Default Bitmap
                    //

                    EnableWindow(GetDlgItem(hDlg,IDC_EDITSPLASH),FALSE);
                    _tcscpy(szDisplay, g_szBrandBmp);
                    
                    //
                    //  Load the default Bitmap
                    //
                    ReleaseBitmapData(&BmpData);
                    BmpData.hDIBitmap = CmLoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_CM_DEFAULT));
                    
                    //
                    //  Display it
                    //
                    DisplayBitmap(hDlg, IDC_DEFAULTBRAND, &hMasterPalette, &BmpData);

                    break;

                case IDC_RADIO2:
                    //
                    //  Display a custom Bitmap
                    //
                    EnableWindow(GetDlgItem(hDlg, IDC_EDITSPLASH), TRUE);
                    
                    if (TEXT('\0') != g_szBrandBmp[0])
                    {
                        pszBitmap = g_szBrandBmp;
                    }
                    else if (TEXT('\0') != szDisplay[0])
                    {
                        pszBitmap = szDisplay;
                    }
                    else
                    {
                        break;
                    }

                    //
                    //  Load the Custom Bitmap
                    //
                    ReleaseBitmapData(&BmpData);
                    BmpData.hDIBitmap = CmLoadBitmap(g_hInstance, pszBitmap);
                
                    //
                    //  Display it
                    //
                    DisplayBitmap(hDlg, IDC_DEFAULTBRAND, &hMasterPalette, &BmpData);

                    break;

                case IDC_BROWSEBMP1:
                    EnableWindow(GetDlgItem(hDlg, IDC_EDITSPLASH), TRUE);

                    MYVERIFY(0 != CheckRadioButton(hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO2));

                    {
                        UINT uFilter = IDS_BMPFILTER;
                        TCHAR* szMask = TEXT("*.bmp");

                        MYVERIFY(0 != DoBrowse(hDlg, &uFilter, &szMask, 1,
                            IDC_EDITSPLASH, TEXT("bmp"), g_szBrandBmp));
                    }

                    //
                    //  If we have a custom bitmap name, load and display it
                    //
                    
                    if (TEXT('\0') != g_szBrandBmp[0])
                    {
                        ReleaseBitmapData(&BmpData);
                        BmpData.hDIBitmap = CmLoadBitmap(g_hInstance, g_szBrandBmp);
                
                        //
                        //  Display it
                        //
                        DisplayBitmap(hDlg, IDC_DEFAULTBRAND, &hMasterPalette, &BmpData);
                    }
                        
                    break;

                case IDC_EDITSPLASH:

                    if (HIWORD(wParam) == EN_KILLFOCUS) 
                    {
                        //
                        //  Notice that we do not do a file check on the text retrieved from the control.
                        //  We do this because, changing focus is an awkward time to do this check and brings
                        //  up the error dialog way to often.  We will catch this on Back or Next anyway so let
                        //  it go by here.
                        //
                        GetTextFromControl(hDlg, IDC_EDITSPLASH, szTemp, MAX_PATH, FALSE); // bDisplayError == FALSE
                  
                        CheckNameChange(g_szBrandBmp, szTemp);

                        if (TEXT('\0') != g_szBrandBmp[0])
                        {
                            //
                            //  Load the Custom Bitmap
                            //
                            ReleaseBitmapData(&BmpData);
                            BmpData.hDIBitmap = CmLoadBitmap(g_hInstance, g_szBrandBmp);
            
                            //
                            //  Display it
                            //
                            DisplayBitmap(hDlg, IDC_DEFAULTBRAND, &hMasterPalette, &BmpData);
                        }
                        return TRUE;
                    }
                    break;

                default:
                    break;
            }
            break;

            case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));

                    //
                    //  Get the bitmap string from the CMS and verify that the file
                    //  exists.
                    //
                    
                    ZeroMemory(g_szBrandBmp, sizeof(g_szBrandBmp));
                    ZeroMemory(&BmpData, sizeof(BMPDATA));

                    GetPrivateProfileString(c_pszCmSection, c_pszCmEntryLogo, TEXT(""), 
                        g_szBrandBmp, CELEMS(g_szBrandBmp), g_szCmsFile);   //lint !e534
                    
                    if (TEXT('\0') == g_szBrandBmp[0])
                    {
                        //
                        //  Then we use the default CM bitmap, disable edit control
                        //
                        MYVERIFY(0 != CheckRadioButton(hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO1));
                        EnableWindow(GetDlgItem(hDlg, IDC_EDITSPLASH), FALSE);
                        //
                        //  Note that we  use szDisplay here just in case the use selects a
                        //  bitmap and then switches back to default.
                        //
                        MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDITSPLASH), 
                            WM_SETTEXT, 0, (LPARAM)GetName(szDisplay)));

                        //
                        //  Load the default Bitmap
                        //
                        ReleaseBitmapData(&BmpData);
                        BmpData.hDIBitmap = CmLoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_CM_DEFAULT));
                    }
                    else
                    {
                        //
                        //  Use whatever bitmap is specified in the CMS.
                        //
                        MYVERIFY(0 != CheckRadioButton(hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO2));
                        EnableWindow(GetDlgItem(hDlg, IDC_EDITSPLASH), TRUE);
                        
                        MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDITSPLASH), 
                            WM_SETTEXT, 0, (LPARAM)GetName(g_szBrandBmp)));
                        
                        MYVERIFY(FALSE != VerifyFile(hDlg, IDC_EDITSPLASH, g_szBrandBmp, FALSE));

                        //
                        //  Load the specified Bitmap
                        //

                        if (!FileExists(g_szBrandBmp))
                        {
                            TCHAR szFile[MAX_PATH+1];

                            // LOOK UP THE FILE IN THE PROFILE DIRECTORY
                            GetFileName(g_szBrandBmp, szFile);
                            MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s%s\\%s"), 
                                g_szOsdir, g_szShortServiceName, szFile));
                            
                            if (!FileExists(szTemp))
                            {
                                return FALSE; //GIVE UP;
                            }
                            else
                            {
                                _tcscpy(g_szBrandBmp, szTemp);
                            }
                        }
                        
                        if (TEXT('\0') != g_szBrandBmp[0])
                        {
                            //
                            //  Load the custom Bitmap
                            //
                            ReleaseBitmapData(&BmpData);
                            BmpData.hDIBitmap = CmLoadBitmap(g_hInstance, g_szBrandBmp);
                        }
                    }

                    //
                    // If we have a handle, create a new Device Dependent bitmap 
                    // and display it.
                    //
                    DisplayBitmap(hDlg, IDC_DEFAULTBRAND, &hMasterPalette, &BmpData);

                    break;

                case PSN_WIZBACK:

                case PSN_WIZNEXT:

                    //
                    //  Make sure that the user typed in a Bitmap name if they selected
                    //  to have a custom bitmap.
                    //
                    if (IsDlgButtonChecked(hDlg, IDC_RADIO2) == BST_CHECKED)
                    {
                        if (-1 == GetTextFromControl(hDlg, IDC_EDITSPLASH, szTemp, MAX_PATH, TRUE)) // bDisplayError == TRUE
                        {
                            SetFocus(GetDlgItem(hDlg, IDC_EDITSPLASH));
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }

                        if (!VerifyFile(hDlg, IDC_EDITSPLASH, g_szBrandBmp, TRUE))
                        {
                            return 1;
                        }
                        else if (TEXT('\0') == g_szBrandBmp[0])
                        {
                            MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NOBMP, MB_OK));

                            SetFocus(GetDlgItem(hDlg, IDC_EDITSPLASH));
                            
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }
                        else
                        {
                            //
                            //  Try to Load the bitmap to make sure it is valid
                            //

                            TCHAR szTemp1[MAX_PATH+1];

                            ReleaseBitmapData(&BmpData);
                            BmpData.hDIBitmap = CmLoadBitmap(g_hInstance, g_szBrandBmp);
                            
                            if (NULL == BmpData.hDIBitmap)
                            {
                                //
                                //  Use szTemp1 to hold the format string
                                //
                                MYVERIFY(0 != LoadString(g_hInstance, IDS_INVALIDBMP, szTemp1, MAX_PATH));
                                MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, szTemp1, g_szBrandBmp));

                                MessageBox(hDlg, szTemp, g_szAppTitle, MB_OK);
                                
                                SetFocus(GetDlgItem(hDlg, IDC_EDITSPLASH));
                            
                                MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                                return 1;
                            }                        
                        }
                    }
                    else
                    {
                        g_szBrandBmp[0] = TEXT('\0');
                    }


                    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryLogo,
                                                               g_szBrandBmp, g_szCmsFile));
                    
                    //
                    //  By calling WritePrivateProfileString with all NULL's we flush the file cache 
                    //  (win95 only).  This call will return 0.
                    //

                    WritePrivateProfileString(NULL, NULL, NULL, g_szCmpFile); //lint !e534 this call will always return 0

                    //
                    // Fall through to cleanup code in RESET handler
                    //

                case PSN_RESET: 
                    
                    //
                    //  Cleanup the Graphics Objects
                    //
                    ReleaseBitmapData(&BmpData);

                    if (NULL != hMasterPalette)
                    {
                        DeleteObject(hMasterPalette);
                        hMasterPalette = NULL;
                    }

                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessPhoneBookBitmap
//
// Synopsis:  Customize the Phone Book bitmap -- this function processes the
//            messages for the page in CMAK that handles customizing the 
//            pb dialog bitmap.
//
//
// History:   quintinb   Created Header    8/6/98
//            quintinb   Rewrote to use new shared bitmap handling code  8/6/98
//            quintinb   Renamed from ProcessPage4
//
//+----------------------------------------------------------------------------

INT_PTR APIENTRY ProcessPhoneBookBitmap(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szFile[MAX_PATH+1];
    TCHAR* pszBitmap;
    NMHDR* pnmHeader = (NMHDR*)lParam;
    static TCHAR szDisplay[MAX_PATH+1]; // keeps unselected custom entry
    static BMPDATA BmpData;
    static HPALETTE hMasterPalette;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_BITMAPS)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_EDITSPLASH);

    switch (message)
    {

        case WM_INITDIALOG:
            SetFocus(GetDlgItem(hDlg, IDC_EDITSPLASH));
            break;

        case WM_PALETTEISCHANGING:
            break;

        case WM_PALETTECHANGED: 
            if ((wParam != (WPARAM) hDlg) && (BmpData.hDIBitmap))
            {
                //
                // Handle the palette change.
                //              
                CMTRACE2(TEXT("ProcessSigninBitmap handling WM_PALETTECHANGED message, wParam=0x%x, hDlg=0x%x."), wParam, hDlg);
                PaletteChanged(&BmpData, hDlg, IDC_PDEFAULTBRAND); 
            }
            
            return TRUE;
            break;  //lint !e527 Unreachable but please keep in case someone removes the return

        case WM_QUERYNEWPALETTE:
            QueryNewPalette(&BmpData, hDlg, IDC_PDEFAULTBRAND);

            return TRUE;
            
            break;  //lint !e527 Unreachable but please keep in case someone removes the return

        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_RADIO1:
                    //
                    //  Display the Default Bitmap
                    //

                    EnableWindow(GetDlgItem(hDlg,IDC_EDITSPLASH),FALSE);
                    _tcscpy(szDisplay, g_szPhoneBmp);
                    
                    //
                    //  Load the default Bitmap
                    //
                    ReleaseBitmapData(&BmpData);
                    BmpData.hDIBitmap = CmLoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_CM_PB_DEFAULT));
                    
                    //
                    //  Display it
                    //
                    DisplayBitmap(hDlg, IDC_PDEFAULTBRAND, &hMasterPalette, &BmpData);

                    break;

                case IDC_RADIO2:
                    //
                    //  Display a custom Bitmap
                    //
                    EnableWindow(GetDlgItem(hDlg, IDC_EDITSPLASH), TRUE);
                    
                    if (TEXT('\0') != g_szPhoneBmp[0])
                    {
                        pszBitmap = g_szPhoneBmp;
                    }
                    else if (TEXT('\0') != szDisplay[0])
                    {
                        pszBitmap = szDisplay;
                    }
                    else
                    {
                        //
                        //  Nothing has been specified yet
                        //
                        break;
                    }

                    //
                    //  Load the Custom Bitmap
                    //
                    ReleaseBitmapData(&BmpData);
                    BmpData.hDIBitmap = CmLoadBitmap(g_hInstance, pszBitmap);
                
                    //
                    //  Display it
                    //
                    DisplayBitmap(hDlg, IDC_PDEFAULTBRAND, &hMasterPalette, &BmpData);

                    break;

                case IDC_BROWSEBMP2:
                    EnableWindow(GetDlgItem(hDlg,IDC_EDITSPLASH),TRUE);

                    MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO1,IDC_RADIO2,IDC_RADIO2));

                    {
                        UINT uFilter = IDS_BMPFILTER;
                        TCHAR* szMask = TEXT("*.bmp");
                        MYVERIFY(0 != DoBrowse(hDlg, &uFilter, &szMask, 1,
                            IDC_EDITSPLASH, TEXT("bmp"), g_szPhoneBmp));
                    }

                    //
                    //  If we have a custom bitmap name, load and display it
                    //
                    
                    if (TEXT('\0') != g_szPhoneBmp[0])
                    {
                        //
                        //  Load the Custom Bitmap
                        //
                        ReleaseBitmapData(&BmpData);
                        BmpData.hDIBitmap = CmLoadBitmap(g_hInstance, g_szPhoneBmp);
            
                        //
                        //  Display it
                        //
                        DisplayBitmap(hDlg, IDC_PDEFAULTBRAND, &hMasterPalette, &BmpData);
                    }
                    
                    break;

                case IDC_EDITSPLASH:
                    if (HIWORD(wParam) == EN_KILLFOCUS)
                    {
                        //
                        //  Note that we do not check whether we can convert the files to ANSI on Change of Focus
                        //  the reason is because the user would get too many error messages and they would be somewhat
                        //  confusing.  Instead we will catch this on Next/Back and ignore it here.
                        //
                        GetTextFromControl(hDlg, IDC_EDITSPLASH, szTemp, MAX_PATH, FALSE); // bDisplayError == FALSE

                        CheckNameChange(g_szPhoneBmp, szTemp);
                        
                        if (TEXT('\0') != g_szPhoneBmp[0])
                        {
                            //
                            //  Load the Custom Bitmap
                            //
                            ReleaseBitmapData(&BmpData);
                            BmpData.hDIBitmap = CmLoadBitmap(g_hInstance, g_szPhoneBmp);
        
                            //
                            //  Display it
                            //
                            DisplayBitmap(hDlg, IDC_PDEFAULTBRAND, &hMasterPalette, &BmpData);
                        }
                        
                        return TRUE;
                    }

                    break;

                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));
                    
                    ZeroMemory(g_szPhoneBmp, sizeof(g_szPhoneBmp));
                    ZeroMemory(&BmpData, sizeof(BMPDATA));
                    
                    GetPrivateProfileString(c_pszCmSection, c_pszCmEntryPbLogo, TEXT(""), 
                        g_szPhoneBmp, CELEMS(g_szPhoneBmp), g_szCmsFile); //lint !e534
                    
                    if (TEXT('\0') != g_szPhoneBmp[0])
                    {
                        //
                        //  We want to Display a Custom Bitmap
                        //
                        MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO1,IDC_RADIO2,IDC_RADIO2));

                        EnableWindow(GetDlgItem(hDlg, IDC_EDITSPLASH), TRUE);
                        
                        MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDITSPLASH), WM_SETTEXT, 
                            0, (LPARAM)GetName(g_szPhoneBmp)));

                        MYVERIFY(FALSE != VerifyFile(hDlg, IDC_EDITSPLASH, g_szPhoneBmp, FALSE));
                        
                        if (!FileExists(g_szPhoneBmp)) 
                        {
                            //
                            //  We couldn't find it the first time so build the path to the profile
                            //  directory and try again.
                            //
                            GetFileName(g_szPhoneBmp, szFile);
                            MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s%s\\%s"), 
                                g_szOsdir, g_szShortServiceName, szFile));
    
                            if (!FileExists(szTemp)) 
                            {
                                //
                                //  We can't find it so give up.
                                //
                                return FALSE;
                            }
                            else
                            {
                                _tcscpy(g_szPhoneBmp, szTemp);
                            }
                        }
                        
                        //
                        //  Load the Custom Bitmap
                        //
                        ReleaseBitmapData(&BmpData);
                        BmpData.hDIBitmap = CmLoadBitmap(g_hInstance, g_szPhoneBmp);

                    }
                    else
                    {
                        //
                        //  We want to Display the Default Bitmap
                        //
                        MYVERIFY(0 != CheckRadioButton(hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO1));

                        EnableWindow(GetDlgItem(hDlg, IDC_EDITSPLASH), FALSE);
                        
                        MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDITSPLASH), WM_SETTEXT, 
                            0, (LPARAM)GetName(szDisplay)));

                        //
                        //  Load the default Bitmap
                        //
                        ReleaseBitmapData(&BmpData);
                        BmpData.hDIBitmap = CmLoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_CM_PB_DEFAULT));

                    }

                    //
                    //  Display it
                    //
                    DisplayBitmap(hDlg, IDC_PDEFAULTBRAND, &hMasterPalette, &BmpData);
                    
                    break;

                case PSN_WIZBACK:

                case PSN_WIZNEXT:
                    
                    //
                    // First check to see if the user entered a bmp file if they
                    // selected that they wanted to display a custom bitmap.
                    //
                    if (IsDlgButtonChecked(hDlg, IDC_RADIO2) == BST_CHECKED)
                    {
                        if (-1 == GetTextFromControl(hDlg, IDC_EDITSPLASH, szTemp, MAX_PATH, TRUE)) // bDisplayError == TRUE
                        {
                            SetFocus(GetDlgItem(hDlg, IDC_EDITSPLASH));
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }
                        
                        if (!VerifyFile(hDlg, IDC_EDITSPLASH, g_szPhoneBmp, TRUE)) 
                        {
                            return 1;
                        }
                        else if (TEXT('\0') == g_szPhoneBmp[0])
                        {
                            MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NOBMP, MB_OK));

                            SetFocus(GetDlgItem(hDlg, IDC_EDITSPLASH));
                            
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }
                        else
                        {
                            ReleaseBitmapData(&BmpData);
                            BmpData.hDIBitmap = CmLoadBitmap(g_hInstance, g_szPhoneBmp);

                            if (NULL == BmpData.hDIBitmap)
                            {
                                TCHAR szTemp1[MAX_PATH+1];

                                //
                                //  Then we have an invalid bitmap file.  Inform the user.
                                //  Using szTemp1 as a temp var for the format string.
                                //
                                MYVERIFY(0 != LoadString(g_hInstance, IDS_INVALIDBMP, szTemp1, MAX_PATH));                   
                                MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, szTemp1, g_szPhoneBmp));
                               
                                MessageBox(hDlg, szTemp, g_szAppTitle, MB_OK);

                                SetFocus(GetDlgItem(hDlg, IDC_EDITSPLASH));
                            
                                MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                                return 1;
                            }
                        }
                    }
                    else
                    {
                        g_szPhoneBmp[0] = TEXT('\0');
                    }

                    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection,c_pszCmEntryPbLogo,g_szPhoneBmp,g_szCmsFile));
                                        //
                    //  By calling WritePrivateProfileString with all NULL's we flush the file cache 
                    //  (win95 only).  This call will return 0.
                    //

                    WritePrivateProfileString(NULL, NULL, NULL, g_szCmpFile); //lint !e534 this call will always return 0

                    //
                    // Fall through to cleanup code in RESET handler
                    //

                case PSN_RESET: 

                    //
                    //  Cleanup the Graphics Objects
                    //
                    ReleaseBitmapData(&BmpData);

                    if (NULL != hMasterPalette)
                    {
                        DeleteObject(hMasterPalette);
                        hMasterPalette = NULL;
                    }

                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}


BOOL UpdateIcon(HWND hDlg,DWORD ctrlID,LPTSTR lpFile,BOOL issmall)
{
    HANDLE hRes = NULL;
    DWORD nResult;
    LPTSTR lpfilename;
    TCHAR szTemp[MAX_PATH+1] = TEXT("");
    BOOL bReturn = FALSE;

    //
    //  Don't do the ANSI conversion check on the Icons here because this function
    //  is only called from the Kill Focus windows message.  Thus we don't want to
    //  put up an error message here.  It will be caught by the Next/Back messages
    //  anyway so ignore it here.
    //
    GetTextFromControl(hDlg, ctrlID, szTemp, MAX_PATH, FALSE); // bDisplayError == FALSE

    CheckNameChange(lpFile, szTemp);

    lstrcpy(szTemp, lpFile); // we need a temp to hold lpFile so that it can be modified by Search Path as necessary.
    nResult = SearchPath(NULL, szTemp, NULL, MAX_PATH, lpFile, &lpfilename);
    if (nResult != 0)
    {
        if (issmall)
        {
            hRes = LoadImage(NULL, lpFile, IMAGE_ICON, 16, 16, LR_LOADFROMFILE);
        }
        else
        {
            hRes = LoadImage(NULL, lpFile, IMAGE_ICON, 32, 32, LR_LOADFROMFILE);
        }
    }

    return (NULL != hRes);
}

BOOL VerifyIcon(HWND hDlg,DWORD ctrlID,LPTSTR lpFile,DWORD iconID,BOOL issmall,LPTSTR lpDispFile)
{
    TCHAR szTemp2[MAX_PATH+1];
    TCHAR szMsg[MAX_PATH+1];
    HANDLE hRes;

    if ((lpFile[0] == TEXT('\0')) && (lpDispFile[0] != TEXT('\0')))
    {
        _tcscpy(lpFile,lpDispFile);
    }

    if (!VerifyFile(hDlg,ctrlID,lpFile,TRUE)) 
    {
        return FALSE;
    }
    else
    {
        //check for blank entry
        if (lpFile[0] == TEXT('\0'))
            return TRUE;

        if (issmall)
        {
            hRes = LoadImage(NULL,lpFile,IMAGE_ICON,16,16,LR_LOADFROMFILE);
        }
        else
        {
            hRes = LoadImage(NULL,lpFile,IMAGE_ICON,32,32,LR_LOADFROMFILE);
        }

        if (hRes == 0)
        {
            MYVERIFY(0 != LoadString(g_hInstance,IDS_INVALIDICO,szMsg,MAX_PATH));
            MYVERIFY(CELEMS(szTemp2) > (UINT)wsprintf(szTemp2,szMsg,lpFile));
            MessageBox(hDlg, szTemp2, g_szAppTitle, MB_OK);
            SetFocus(GetDlgItem(hDlg, ctrlID));
            
            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
            return FALSE;
        }
        else
        {
            SendDlgItemMessage(hDlg,iconID,STM_SETIMAGE,IMAGE_ICON,(LPARAM) hRes); //lint !e534 STM_SETIMAGE doesn't return error info
        }
        return TRUE;
    }
}

//+----------------------------------------------------------------------------
//
// Function:  InitIconEntry
//
// Synopsis:  This function takes a resource ID of a key under the Connection Manager
//            section and retrives the value and stores it in lpFile.  It then sets the text
//            in the passed in edit control and verifies that the file exists.  Should the
//            not exist, then the string will be set to the empty string.
//
// Arguments: HWND hDlg - Window handle of the icon dialog
//            LPCTSTR pszKey - the flag string of the Icon to retrieve
//            LPTSTR lpFile - String buffer to write the icon path in
//            UINT CtrlId - Edit Control that is supposed to receive the icon string
//
// Returns:   Nothing
//
// History:   quintinb  Created Header    8/4/98
//
//+----------------------------------------------------------------------------
void InitIconEntry(HWND hDlg, LPCTSTR pszKey, LPTSTR lpFile, UINT CtrlId)
{
    //
    //  The following call to GetPrivateProfileString could return a blank string, thus don't
    //  use the MYVERIFY macro on it.
    //

    ZeroMemory(lpFile, sizeof(lpFile));
    GetPrivateProfileString(c_pszCmSection, pszKey, TEXT(""), lpFile, 
        MAX_PATH, g_szCmsFile);  //lint !e534

    //
    //  Both of the following functions will correctly handle a blank string.
    //

    MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, CtrlId), WM_SETTEXT, 0, 
        (LPARAM)GetName(lpFile)));

    MYVERIFY(FALSE != VerifyFile(hDlg, CtrlId, lpFile, FALSE));

}

//+----------------------------------------------------------------------------
//
// Function:  RefreshIconDisplay
//
// Synopsis:  This fucntion is used to refresh the icons shown on the icons page.
//            It takes a path to an Icon and tries to load it.  If the load fails
//            or if the boolean SetDefault is set, then it loads the default icon
//            specified by the Instance handle and the integer resource ID (iDefault).
//            The icon is displayed to the dwControlID passed into the function.
//
// Arguments: HWND hDlg - 
//            HINSTANCE hInstance - 
//            LPTSTR szIconFile - 
//            int iDefault - 
//            int xSize - 
//            int ySize - 
//            DWORD dwControlID - 
//            BOOL SetDefault - 
//
// Returns:   Nothing
//
// History:   quintinb Created Header    8/4/98
//            quintinb Changed Default setting to take a resource ID instead of
//                     a string.  Thus we won't have to ship the icon files.
//
//+----------------------------------------------------------------------------
void RefreshIconDisplay(HWND hDlg, HINSTANCE hInstance, LPTSTR szIconFile, int iDefault, int xSize, int ySize, DWORD dwControlID, BOOL SetDefault)
{    
    HANDLE hRes;
    
    if (SetDefault) 
    {
        hRes = NULL;
    }
    else
    {
        hRes = LoadImage(NULL, szIconFile, IMAGE_ICON, xSize, ySize, LR_LOADFROMFILE);
    }
    
    if (NULL == hRes)
    {   
        //
        // IF ICON IS NOT VALID OR WE WERE ASKED FOR THE DEFAULT, SO LOAD THE DEFAULT
        //
        
        hRes = LoadImage(hInstance, MAKEINTRESOURCE(iDefault), IMAGE_ICON, xSize, ySize, 
            LR_DEFAULTCOLOR);
    }

    if (NULL != hRes)
    {
        SendDlgItemMessage(hDlg, dwControlID, STM_SETIMAGE, IMAGE_ICON, (LPARAM) hRes); //lint !e534 STM_SETIMAGE doesn't return error info
    }
}
//+----------------------------------------------------------------------------
//
// Function:  EnableCustomIconControls
//
// Synopsis:  Function to enable or disable all of the controls associated with
//            the custom icons.  If the bEnabled value is TRUE the controls are
//            enabled, otherwise the controls are disabled.
//
// Arguments: WND hDlg - window handle of the icon dialog
//            BOOL bEnabled - whether the controls are enabled or disabled
//
// History:   quintinb Created     11/12/99
//
//+----------------------------------------------------------------------------
void EnableCustomIconControls(HWND hDlg, BOOL bEnabled)
{
    EnableWindow(GetDlgItem(hDlg, IDC_EDITLARGE), bEnabled);
    EnableWindow(GetDlgItem(hDlg, IDC_LABEL1), bEnabled);    


    EnableWindow(GetDlgItem(hDlg, IDC_EDITSMALL), bEnabled);
    EnableWindow(GetDlgItem(hDlg, IDC_LABEL2), bEnabled);


    EnableWindow(GetDlgItem(hDlg, IDC_EDITTRAY), bEnabled);
    EnableWindow(GetDlgItem(hDlg, IDC_LABEL3), bEnabled);

    //
    //  Comment about using defaults for unspecified icons
    //
    EnableWindow(GetDlgItem(hDlg,IDC_LABEL4), bEnabled);

}

//+----------------------------------------------------------------------------
//
// Function:  ProcessIcons
//
// Synopsis:  Function that processes messages for the page in CMAK that allows
//            the user to add custom icons to their profile.
//
// Arguments: WND hDlg - window handle of the dialog
//            UINT message - message ID
//            WPARAM wParam - wParam of the message
//            LPARAM lParam - lParma of the message
//
//
// History:   quintinb Created Header    12/5/97
//            quintinb modified to handle both w16 and w32 dialogs
//            quintinb added fix for 35622, custom large icon not displaying on page load
//            quintinb removed 16 bit support 7-8-98
//            quintinb Renamed from ProcessPage5   8-6-98
//            quintinb Added EnableCustomIconControls and changed browse button
//                     behavior for consistency 367112  11-12-99
//
//+----------------------------------------------------------------------------
//  Customize icons

INT_PTR APIENTRY ProcessIcons(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    static TCHAR szDispLargeIco[MAX_PATH+1];
    static TCHAR szDispSmallIco[MAX_PATH+1];
    static TCHAR szDispTrayIco[MAX_PATH+1];
    NMHDR* pnmHeader = (NMHDR*)lParam;
    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_ICONS)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_EDITLARGE);
    SetDefaultGUIFont(hDlg,message,IDC_EDITSMALL);
    SetDefaultGUIFont(hDlg,message,IDC_EDITTRAY);

    switch (message)
    {
        case WM_INITDIALOG:
            
            SetFocus(GetDlgItem(hDlg, IDC_EDITLARGE));

            break;

        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_RADIO1:
                    EnableCustomIconControls (hDlg, FALSE);

                    RefreshIconDisplay(hDlg, g_hInstance, g_szLargeIco, IDI_CM_ICON, 32, 32, IDC_ICONLARGE, TRUE);
                    RefreshIconDisplay(hDlg, g_hInstance, g_szSmallIco, IDI_CM_ICON, 16, 16, IDC_ICONSMALL, TRUE);
                    RefreshIconDisplay(hDlg, g_hInstance, g_szTrayIco, IDI_CM_ICON, 16, 16, IDC_ICONTRAY, TRUE);
                    
                    _tcscpy(szDispTrayIco,g_szTrayIco);
                    _tcscpy(szDispLargeIco,g_szLargeIco);
                    _tcscpy(szDispSmallIco,g_szSmallIco);

                    break;

                case IDC_RADIO2:
                    EnableCustomIconControls (hDlg, TRUE);
                    
                    if (!VerifyIcon(hDlg,IDC_EDITLARGE,g_szLargeIco,IDC_ICONLARGE,FALSE,szDispLargeIco)) 
                    {
                        return 1;
                    }
                    if (!VerifyIcon(hDlg,IDC_EDITSMALL,g_szSmallIco,IDC_ICONSMALL,TRUE,szDispSmallIco))
                    {
                        return 1;
                    }
                    if (!VerifyIcon(hDlg,IDC_EDITTRAY,g_szTrayIco,IDC_ICONTRAY,TRUE,szDispTrayIco))
                    {
                        return 1;
                    }
                    break;

                case IDC_EDITLARGE:
                    if (HIWORD(wParam) == EN_KILLFOCUS)
                    {                        
                        BOOL bIconUpdated = UpdateIcon(hDlg, IDC_EDITLARGE, g_szLargeIco, FALSE);
                        
                        //
                        //  If icon wasn't updated than load the defaults
                        //

                        RefreshIconDisplay(hDlg, g_hInstance, g_szLargeIco, IDI_CM_ICON, 32, 32, IDC_ICONLARGE, !bIconUpdated);

                        return TRUE;
                    }   
                    break;

                case IDC_EDITSMALL:
                    if (HIWORD(wParam) == EN_KILLFOCUS)
                    {
                        BOOL bIconUpdated = UpdateIcon(hDlg,IDC_EDITSMALL,g_szSmallIco,TRUE);
                        
                        //
                        //  If icon wasn't updated than load the defaults
                        //

                        RefreshIconDisplay(hDlg, g_hInstance, g_szSmallIco, IDI_CM_ICON, 16, 16, IDC_ICONSMALL, !bIconUpdated);
                        
                        return TRUE;
                    }
                    break;

                case IDC_EDITTRAY:
                    
                    if (HIWORD(wParam) == EN_KILLFOCUS)
                    {
                        BOOL bIconUpdated = UpdateIcon(hDlg,IDC_EDITTRAY,g_szTrayIco,TRUE);

                        //
                        //  If icon wasn't updated than load the defaults
                        //

                        RefreshIconDisplay(hDlg, g_hInstance, g_szTrayIco, IDI_CM_ICON, 16, 16, IDC_ICONTRAY, !bIconUpdated);
                        
                        return TRUE;
                    }
                    break;

                case IDC_BROWSE1:
                    {
                        UINT uFilter = IDS_ICOFILTER;
                        TCHAR* szMask = TEXT("*.ico");
                        MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO1,IDC_RADIO2,IDC_RADIO2));
                        EnableCustomIconControls (hDlg, TRUE);

                        if (DoBrowse(hDlg, &uFilter, &szMask, 1, IDC_EDITLARGE, TEXT("ico"), g_szLargeIco))
                        {
                            RefreshIconDisplay(hDlg, g_hInstance, g_szLargeIco, IDI_CM_ICON, 32, 32, IDC_ICONLARGE, FALSE);
                        }
                    }

                    break;

                case IDC_BROWSE2:
                    {
                        UINT uFilter = IDS_ICOFILTER;
                        TCHAR* szMask = TEXT("*.ico");
                        MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO1,IDC_RADIO2,IDC_RADIO2));
                        EnableCustomIconControls (hDlg, TRUE);

                        if (DoBrowse(hDlg, &uFilter, &szMask, 1, IDC_EDITSMALL, TEXT("ico"), g_szSmallIco))
                        {
                            RefreshIconDisplay(hDlg, g_hInstance, g_szSmallIco, IDI_CM_ICON, 16, 16, IDC_ICONSMALL, FALSE);
                        }
                    }

                    break;

                case IDC_BROWSE3:
                    {
                        UINT uFilter = IDS_ICOFILTER;
                        TCHAR* szMask = TEXT("*.ico");
                        MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO1,IDC_RADIO2,IDC_RADIO2));
                        EnableCustomIconControls (hDlg, TRUE);

                        if (DoBrowse(hDlg, &uFilter, &szMask, 1, IDC_EDITTRAY, TEXT("ico"), g_szTrayIco))
                        {
                            RefreshIconDisplay(hDlg, g_hInstance, g_szTrayIco, IDI_CM_ICON, 16, 16, IDC_ICONTRAY, FALSE);
                        }
                    }

                    break;

                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));
                    
                    InitIconEntry(hDlg, c_pszCmEntryBigIcon, g_szLargeIco, IDC_EDITLARGE);                    
                    InitIconEntry(hDlg, c_pszCmEntrySmallIcon, g_szSmallIco, IDC_EDITSMALL);
                    InitIconEntry(hDlg, c_pszCmEntryTrayIcon, g_szTrayIco, IDC_EDITTRAY);
                    
                    if ((g_szTrayIco[0] == TEXT('\0'))&&(g_szLargeIco[0] == TEXT('\0'))&&(g_szSmallIco[0] == TEXT('\0')))
                    {
                        MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO1,IDC_RADIO2,IDC_RADIO1));
                        EnableCustomIconControls (hDlg, FALSE);

                        MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDITLARGE), WM_SETTEXT, 0, (LPARAM)GetName(szDispLargeIco)));
                    
                        MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDITSMALL), WM_SETTEXT, 0, (LPARAM)GetName(szDispSmallIco)));

                        MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDITTRAY), WM_SETTEXT, 0, (LPARAM)GetName(szDispTrayIco)));                        

                    }
                    else
                    {
                        MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO1,IDC_RADIO2,IDC_RADIO2));
                        EnableCustomIconControls (hDlg, TRUE);
                    }

                    RefreshIconDisplay(hDlg, g_hInstance, g_szLargeIco, IDI_CM_ICON, 32, 32, IDC_ICONLARGE, FALSE);
                    RefreshIconDisplay(hDlg, g_hInstance, g_szSmallIco, IDI_CM_ICON, 16, 16, IDC_ICONSMALL, FALSE);
                    RefreshIconDisplay(hDlg, g_hInstance, g_szTrayIco, IDI_CM_ICON, 16, 16, IDC_ICONTRAY, FALSE);

                    break;

                case PSN_WIZBACK:
                case PSN_WIZNEXT:
                    
                    if (IsDlgButtonChecked(hDlg, IDC_RADIO1)!=BST_CHECKED) 
                    {
                        if (!VerifyIcon(hDlg,IDC_EDITLARGE,g_szLargeIco,IDC_ICONLARGE,FALSE,TEXT(""))) 
                        {
                            return 1;
                        }
                        if (!VerifyIcon(hDlg,IDC_EDITSMALL,g_szSmallIco,IDC_ICONSMALL,TRUE,TEXT("")))
                        {
                            return 1;
                        }
                        if (!VerifyIcon(hDlg,IDC_EDITTRAY,g_szTrayIco,IDC_ICONTRAY,TRUE,TEXT("")))
                        {
                            return 1;
                        }
                    }
                    else
                    {

                        g_szTrayIco[0] = TEXT('\0');
                        g_szLargeIco[0] = TEXT('\0');
                        g_szSmallIco[0] = TEXT('\0');
                    }

                    // USE ICON IN CM AS ICON FOR DESKTOP IF NOT LARGE ICON SPECIFIED
                    if (TEXT('\0') != g_szLargeIco[0])
                    {
                        // SPECIFY ICON NAME FOR THE DESKTOP
                        GetFileName(g_szLargeIco,szTemp);
                        QS_WritePrivateProfileString(c_pszInfSectionStrings, c_pszDesktopIcon, szTemp, g_szInfFile);
                    }

                    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryBigIcon, g_szLargeIco, g_szCmsFile));
                    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryTrayIcon, g_szTrayIco, g_szCmsFile));
                    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntrySmallIcon, g_szSmallIco, g_szCmsFile));
                    
                    //
                    //  By calling WritePrivateProfileString with all NULL's we flush the file cache 
                    //  (win95 only).  This call will return 0.
                    //
                    WritePrivateProfileString(NULL, NULL, NULL, g_szCmsFile); //lint !e534 this call will always return 0
                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessPhoneBook
//
// Synopsis:  Setup the phone book
//
//
// History:     quintinb hid pbr browse button and edit control.  Rewrote pbr/pbk logic for bug 
//                  fix 14188 on 9-9-97
//              quintinb added VerifyFileFormat check on .pbk file for bug fix 28416
//              quintinb (11-18-97 29954) removed hidden pbr button and edit control from the dialog.  Removed
//                  old verification code.  Updated code to remove references to IDC_EDITREGION.
//              quintinb (7-2-98)   removed verifyfileformat call mentioned above because cm16 was pulled
//              quintinb (8-6-98)   Renamed from ProcessPage6
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessPhoneBook(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szMsg[2*MAX_PATH+1];
    TCHAR* pzTmp;
    HANDLE hFile = INVALID_HANDLE_VALUE;
    static TCHAR szMorePhone[MAX_PATH+1];
    NMHDR* pnmHeader = (NMHDR*)lParam;


    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_PHONEBK)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_EDITPHONE);
    SetDefaultGUIFont(hDlg,message,IDC_EDIT1);

    switch (message)
    {
        case WM_INITDIALOG:
            SetFocus(GetDlgItem(hDlg, IDC_EDITPHONE));
            SendDlgItemMessage(hDlg, IDC_EDIT1, EM_SETLIMITTEXT, (WPARAM)MAX_PATH, (LPARAM)0); //lint !e534 EM_SETLIMITTEXT doesn't return anything useful

            break;

        case WM_COMMAND:
            switch (LOWORD(wParam)) 
            {

                case IDC_BROWSE1:
                    {
                        UINT uFilter = IDS_PBKFILTER;
                        TCHAR* szMask = TEXT("*.pbk");

                        MYVERIFY(0 != DoBrowse(hDlg,  &uFilter, &szMask, 1,
                            IDC_EDITPHONE, c_pszPbk, g_szPhonebk));
                    }

                    break;

                case IDC_CHECK1:

                    g_bUpdatePhonebook = IsDlgButtonChecked(hDlg,IDC_CHECK1);
                    
                    if (g_bUpdatePhonebook)
                    {
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmakStatus, c_pszUpdatePhonebook, c_pszOne, g_szInfFile));
                    }
                    else
                    {
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmakStatus, c_pszUpdatePhonebook, c_pszZero, g_szInfFile));
                    }

                    break;

                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:

                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));
                    
                    //
                    //  The following two calls to GetPrivateProfileString could return blank 
                    //  strings, thus we won't check the return with the MYVERIFY macro.
                    //

                    ZeroMemory(szMorePhone, sizeof(szMorePhone));
                    GetPrivateProfileString(c_pszCmSection, c_pszCmEntryPbMessage, TEXT(""), 
                        szMorePhone, CELEMS(szMorePhone), g_szCmsFile);    //lint !e534
                    MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDIT1), WM_SETTEXT, 0, 
                        (LPARAM)szMorePhone));

                    ZeroMemory(g_szPhonebk, sizeof(g_szPhonebk));
                    
                    GetPrivateProfileString(c_pszCmSectionIsp, c_pszCmEntryIspPbFile, TEXT(""), 
                        g_szPhonebk, CELEMS(g_szPhonebk), g_szCmsFile); //lint !e534            
                    
                    MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDITPHONE), WM_SETTEXT, 0, 
                        (LPARAM)GetName(g_szPhonebk)));
                    
                    //
                    //  The following call will handle a blank g_szPhonebk by returning FALSE and setting
                    //  the control on the dialog to blank.  Don't use MYVERIFY.
                    //

                    VerifyPhonebk(hDlg, IDC_EDITPHONE, g_szPhonebk);    //lint !e534

                    MYVERIFY(0 != GetPrivateProfileString(c_pszCmakStatus, c_pszUpdatePhonebook, 
                        c_pszOne, szTemp, CELEMS(szTemp), g_szInfFile));

                    if (TEXT('1') == szTemp[0])
                    {
                        g_bUpdatePhonebook = TRUE;
                        MYVERIFY(0 != CheckDlgButton(hDlg, IDC_CHECK1, TRUE));
                    }
                    else
                    {
                        g_bUpdatePhonebook = FALSE;
                        MYVERIFY(0 != CheckDlgButton(hDlg, IDC_CHECK1, FALSE));
                    }

                    break;

                case PSN_WIZBACK:

                    // fall through for further processing

                case PSN_WIZNEXT:
                                
                    //
                    // quintinb, 9-9-97 for bug fix 14188
                    // cases:   use browse button: both up to date, shortname(g_szPhonebk) == szTemp
                    //          type unc into edit control:  szTemp up to date, g_szPhonebk = szTemp must be done
                    //          type filename into edit control:  szTemp up to date, g_szPhonebk = getcurrentdir + \\ + szTemp must be done
                    //          unc left over from previous, both same
                    //
                    
                    //
                    // get text in the edit control and put in szTemp
                    //
                    if (-1 == GetTextFromControl(hDlg, IDC_EDITPHONE, szTemp, MAX_PATH, TRUE)) // bDisplayError == TRUE
                    {
                        SetFocus(GetDlgItem(hDlg, IDC_EDITPHONE));
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                        return 1;
                    }
                    
                    //
                    // first get szTemp and g_szPhonebk consistent
                    //
                    
                    if (szTemp[0] != TEXT('\0'))
                    {                   
                        //
                        // if in here then we know that we have some text to work with
                        // first test if the two strings are exactly equal or the shortname of g_szPhonebk 
                        // equals szTemp
                        //

                        if (0 != _tcscmp(szTemp, g_szPhonebk)) 
                        {
                            if (0 != _tcscmp(szTemp, GetName(g_szPhonebk)))
                            {
                                //
                                // if not then g_szPhonebk and szTemp are out of sync, must update g_szPhonebk
                                // szTemp contains a backslash so it is probably a full path
                                //
                                if ( _tcsstr(szTemp, TEXT("\\")) )
                                {
                                    // probably contains a unc
                                    _tcscpy(g_szPhonebk, szTemp);
                                } 
                                else 
                                {
                                    // use GetFullPathName to return a name
                                    MYVERIFY(0 != GetFullPathName(szTemp, MAX_PATH, g_szPhonebk, &pzTmp));
                                }
                            }
                        }

                        //
                        // Okay, check that we can open the file now. We need 
                        // to change the current dir to the cmak dir since 
                        // g_szPhonebk can be a relative path from a CMS file
                        //

                        MYVERIFY(0 != GetCurrentDirectory(MAX_PATH+1, szTemp));
                        MYVERIFY(0 != SetCurrentDirectory(g_szOsdir));

                        hFile = CreateFile(g_szPhonebk,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);

                        //
                        // Restore the cur dir
                        //

                        MYVERIFY(0 != SetCurrentDirectory(szTemp));
                        
                        if (INVALID_HANDLE_VALUE == hFile)
                        {
                            // then we have an error and have exhausted our possibilities
                            //

                            MYVERIFY(IDOK == ShowMessage(hDlg, IDS_BADOUTEXE, MB_OK));
                            
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }

                        MYVERIFY(0 != CloseHandle(hFile));

                        //
                        // if we got here then everything is sync-ed, make sure that the file is a pbk file
                        //
                        pzTmp = g_szPhonebk + _tcslen(g_szPhonebk) - _tcslen(c_pszPbk);
                        if (_tcsicmp(pzTmp, c_pszPbk) != 0)
                        {
                            MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NOTPBK, MB_OK));
                            
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }

                        //
                        // now update the pbr file entry
                        //
                        _tcscpy(g_szRegion, g_szPhonebk);
                        pzTmp = g_szRegion + _tcslen(g_szPhonebk) - _tcslen(c_pszPbk);
                        _tcscpy(pzTmp, TEXT("pbr"));
                        // removed for 29954
                        //SendMessage(GetDlgItem(hDlg, IDC_EDITREGION), WM_SETTEXT, 0, (LPARAM)GetName(g_szRegion));
                        
                        //
                        // Now open the pbr file to see that it exists. We need
                        // to change the current dir to the cmak dir since 
                        // g_szPhonebk can be a relative path from a CMS file.
                        //

                        MYVERIFY(0 != GetCurrentDirectory(MAX_PATH+1, szTemp));
                        MYVERIFY(0 != SetCurrentDirectory(g_szOsdir));

                        hFile = CreateFile(g_szRegion,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);

                        //
                        // Restore the current directory
                        //

                        MYVERIFY(0 != SetCurrentDirectory(szTemp));
                        
                        if (INVALID_HANDLE_VALUE == hFile)
                        {
                            //
                            // then we can't find the pbr file
                            //
                            MYVERIFY(0 != LoadString(g_hInstance,IDS_NEEDSPBR,szTemp,MAX_PATH));
                            MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szTemp, GetName(g_szRegion), g_szPhonebk, GetName(g_szRegion)));
                            MessageBox(hDlg, szMsg, g_szAppTitle, MB_OK);
                            SetFocus(GetDlgItem(hDlg, IDC_EDITPHONE));
                            
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }
                        MYVERIFY(0 != CloseHandle(hFile));

                    } 
                    else 
                    {
                        //
                        // just in case user wants to clear out the phonebk edit control
                        //
                        g_szPhonebk[0] = TEXT('\0');
                        g_szRegion[0] = TEXT('\0');

                    }

                    // end bugfix for 14188

                    if (g_bUpdatePhonebook)
                    {
                        GetFileName(g_szPhonebk, szTemp);

                        if (FALSE == IsFile8dot3(szTemp))
                        {
                            LPTSTR pszMsg = CmFmtMsg(g_hInstance, IDS_BADPBNAME, szTemp);

                            if (pszMsg)
                            {
                                MessageBox(hDlg, pszMsg, g_szAppTitle, MB_OK);
                                CmFree(pszMsg);
                            }
                            
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }
                    }
                    // end of changes for 28416
                    if (-1 == GetTextFromControl(hDlg, IDC_EDIT1, szTemp, MAX_PATH, TRUE)) // bDisplayError == TRUE
                    {
                        SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                        return 1;
                    }
                    
                    CmStrTrim(szTemp);
                    MYVERIFY(TRUE == SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)0, (LPARAM) szTemp));
                    _tcscpy(szMorePhone,szTemp);
                    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryPbMessage, szMorePhone, g_szCmsFile));
                    
                    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionIsp, c_pszCmEntryIspPbFile, g_szPhonebk, g_szCmsFile));
                    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionIsp, c_pszCmEntryIspRegionFile, g_szRegion, g_szCmsFile));


                    if (pnmHeader && (PSN_WIZBACK == pnmHeader->code)) 
                    {
                        if (g_bUseTunneling)
                        {
                            //
                            //  If we are going back, skip the Pre-shared key page if
                            //  no DUN entries have Preshared key enabled.
                            //
                            //  Note: g_bPresharedKeyNeeded should be current here, no need
                            //        to call DoesSomeVPNsettingUsePresharedKey()
                            //
                            if (!g_bPresharedKeyNeeded)
                            {
                                MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, IDD_VPN_ENTRIES));
                            }
                        }
                        else
                        {
                            //
                            //  If we are going back, skip the VPN entries dialog if we don't have any tunneling enabled.
                            //
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, IDD_TUNNELING));
                        }
                    }

                    //
                    //  If we are going forward, skip the phonebook update page unless we are doing the PB download
                    //
                    if (pnmHeader && (PSN_WIZNEXT == pnmHeader->code) && !g_bUpdatePhonebook)
                    {
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, IDD_DUN_ENTRIES));
                    }
                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessPhoneBookUpdate
//
// Synopsis:  Specify Phone Book Files and Updates
//
//
// History:   Created Header    8/6/98
//            quintinb  Renamed from ProcessPage6A  8/6/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessPhoneBookUpdate(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{

    TCHAR szTemp[MAX_PATH+1];
    int j, iLen;
    LPTSTR pUrl,pch;
    BOOL showerr;
    NMHDR* pnmHeader = (NMHDR*)lParam;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_PHONEBK)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_EDIT1);
    SetDefaultGUIFont(hDlg,message,IDC_EDITURL);

    switch (message)
    {
        case WM_INITDIALOG:

            SendDlgItemMessage(hDlg, IDC_EDITURL, EM_SETLIMITTEXT, (WPARAM)(MAX_PATH - 50), (LPARAM)0);//lint !e534 EM_SETLIMITTEXT doesn't return anything useful

            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));
                    
                    //
                    //  The following two calls to GetPrivateProfileString could return an empty
                    //  string.  We shouldn't use MYVERIFY on the return code.
                    //
                    ZeroMemory(g_szPhoneName, sizeof(g_szPhoneName));
                    ZeroMemory(g_szUrl,sizeof(g_szUrl));

                    GetPrivateProfileString(c_pszCmakStatus, c_pszPhoneName, TEXT(""), 
                        g_szPhoneName, CELEMS(g_szPhoneName), g_szInfFile);  //lint !e534
                    
                    GetPrivateProfileString(c_pszCmSectionIsp, c_pszCmEntryIspUrl, TEXT(""), g_szUrl, 
                        CELEMS(g_szUrl), g_szCmsFile);   //lint !e534
                                        
                    // skip past initial http://
                    if (*g_szUrl)
                    {
                        pUrl = _tcsstr(g_szUrl, c_pszCpsUrl);
                        if (pUrl)
                        {
                            *pUrl = 0; //chop off dll filename
                        }

                        MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDITURL), WM_SETTEXT, 0, (LPARAM)&g_szUrl[7]));

                    }
                    else
                    {
                        MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDITURL), WM_SETTEXT, 0, (LPARAM)TEXT("")));
                    }

                    if (*g_szPhonebk)
                    {
                        GetBaseName(g_szPhonebk,szTemp);
                        MYVERIFY(TRUE == SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)0, (LPARAM) szTemp));
                        EnableWindow(GetDlgItem(hDlg,IDC_EDIT1),FALSE);
                    }
                    else
                    {
                        EnableWindow(GetDlgItem(hDlg, IDC_EDIT1), TRUE);
                        if (*g_szPhoneName)
                        {
                            MYVERIFY(TRUE == SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)0, (LPARAM) g_szPhoneName));
                        }
                        else
                        {
                            MYVERIFY(TRUE == SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)0, (LPARAM) TEXT("")));
                        }
                    }

                    break;

                case PSN_WIZBACK:

                case PSN_WIZNEXT:

                    showerr = (pnmHeader && (PSN_WIZNEXT == pnmHeader->code));

                    if (-1 == GetTextFromControl(hDlg, IDC_EDIT1, g_szPhoneName, MAX_PATH, TRUE)) // bDisplayError == TRUE
                    {
                        SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                        return 1;
                    }

//                  if ((g_szPhoneName[0] == TEXT('\0')) && (g_pHeadMerge == NULL) && showerr) - 20094
                    if ((g_szPhoneName[0] == TEXT('\0')) && showerr)
                    {
                        MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NEEDPHONENAME, MB_OK));
                        SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
                        
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                        return 1;
                    }

                    iLen = lstrlen(g_szBadFilenameChars); 
                    pch = g_szPhoneName;
                    while(*pch != _T('\0'))
                    {
                        for (j = 0; j < iLen; ++j)
                        {
                            if ((*pch == g_szBadFilenameChars[j]) && showerr)
                            {
                                LPTSTR pszMsg = CmFmtMsg(g_hInstance, IDS_PHONENAMEERR, g_szBadFilenameChars);

                                if (pszMsg)
                                {
                                    MessageBox(hDlg, pszMsg, g_szAppTitle, MB_OK);
                                    CmFree(pszMsg);
                                }

                                SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
                                
                                MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                                return 1;
                            }
                        }
                        pch = CharNext(pch);
                    }

                    //
                    //  Note that 8.3 means 8 bytes not 8 Characters.  Thus we have a limit of 4 DBCS
                    //  characters.
                    //
#ifdef UNICODE
                    LPSTR pszAnsiPhoneName;

                    pszAnsiPhoneName = WzToSzWithAlloc(g_szPhoneName);

                    if ((lstrlenA(pszAnsiPhoneName) > 8) && showerr)
#else
                    if ((strlen(g_szPhoneName) > 8) && showerr)
#endif
                    {
                        LPTSTR pszMsg = CmFmtMsg(g_hInstance, IDS_PHONENAMEERR, g_szBadFilenameChars);

                        if (pszMsg)
                        {
                            MessageBox(hDlg, pszMsg, g_szAppTitle, MB_OK);
                            CmFree(pszMsg);
                        }

                        SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
                        
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                        return 1;
                    }

#ifdef UNICODE
                    CmFree(pszAnsiPhoneName);
#endif

                    if (-1 == GetTextFromControl(hDlg, IDC_EDITURL, szTemp, MAX_PATH, TRUE)) // bDisplayError == TRUE
                    {
                        SetFocus(GetDlgItem(hDlg, IDC_EDITURL));
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                        return 1;
                    }

                    if (szTemp[0] != TEXT('\0'))
                    {
                        MYVERIFY(CELEMS(g_szUrl) > (UINT)wsprintf(g_szUrl, TEXT("http://%s%s"), szTemp, c_pszCpsUrl));
                    }
                    else
                    {
                        g_szUrl[0] = TEXT('\0');
                    }
                    
                    if ((g_szUrl[0] == TEXT('\0')) && showerr)
                    {
                        MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NOURL, MB_OK));

                        SetFocus(GetDlgItem(hDlg, IDC_EDITURL));
                        
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                        return 1;
                    }
                    
                    MYVERIFY(0 != WritePrivateProfileString(c_pszCmakStatus, c_pszPhoneName, g_szPhoneName, g_szInfFile));

                    if (TEXT('\0') != g_szUrl[0]) 
                    {
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionIsp,c_pszCmEntryIspUrl,g_szUrl,g_szCmsFile));
                    }
                    else
                    {
                        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionIsp,c_pszCmEntryIspUrl,TEXT(""),g_szCmsFile));
                    }

                    // the Next button was pressed or the back button was pressed
                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

//+----------------------------------------------------------------------------
//
// Function:  RemoveReferencesFromCMS
//
// Synopsis:    This function searches for any previous References line in
//              the ISP section of the cms file.  If it finds a References
//              line, then it parses it to find what other profiles are
//              mentioned in the CMS.  Then it will search for and remove
//              any of the following lines in the ISP section that correspond
//              to these references:
//                  CMSFile&test2=test3\test2.cms
//                  FilterA&test2=NosurchargeSignon
//                  FilterB&test2=SurchargeSignon
// 
// note the function removes the reference line itself too.
//
// Arguments: None
//
// Returns:   Nothing
//
// History:   quintinb  created for bug fix 10537   8/28/97
//
//+----------------------------------------------------------------------------
void RemoveReferencesFromCMS()
{
    TCHAR szKey[MAX_PATH+1];
    TCHAR szReferences[MAX_PATH+1];
    TCHAR* pszToken;
    DWORD dwNumChars;

    dwNumChars = GetPrivateProfileString(c_pszCmSectionIsp, c_pszCmEntryIspReferences, TEXT(""), 
        szReferences,MAX_PATH, g_szCmsFile);

    if ((dwNumChars >0) && (TEXT('\0') != szReferences[0]))
    {
        // I have references, so we must parse them out and delete them
        
        pszToken = _tcstok( szReferences, TEXT(" "));   
        while( pszToken != NULL )
        {
            MYVERIFY(CELEMS(szKey) > (UINT)wsprintf(szKey, TEXT("%s%s"), 
                c_pszCmEntryIspCmsFile, pszToken));
            MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionIsp, szKey, NULL, 
                g_szCmsFile));

            MYVERIFY(CELEMS(szKey) > (UINT)wsprintf(szKey, TEXT("%s%s"), 
                c_pszCmEntryIspFilterA, pszToken));
            MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionIsp, szKey, NULL, 
                g_szCmsFile));
            
            MYVERIFY(CELEMS(szKey) > (UINT)wsprintf(szKey, TEXT("%s%s"), 
                c_pszCmEntryIspFilterB, pszToken));
            MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionIsp, szKey, NULL, 
                g_szCmsFile));

            pszToken = _tcstok( NULL, TEXT(" ") );   
        }
        // after deleting the individual keys, must delete the references line itself
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionIsp, c_pszCmEntryIspReferences, NULL, g_szCmsFile));
        
    }

}

//+----------------------------------------------------------------------------
//
// Function:  RefreshDualingListBoxes
//
// Synopsis:  This function refreshes two listboxes from the given two linked
//            lists.  The destination listbox is filled from the destination
//            linked list and then the source listbox is filled with all of the
//            items in the source linked list that don't appear in the destination
//            linked list and that aren't the name of the current profile to edit.
//            Thus you effectively have one list where the items either show up
//            in the source listbox or the destination listbox.  Please note that
//            there is one exception with the merged profile lists that this
//            code was created for (items can exist in the merged list that we
//            don't have profile source from, see the Delete/Remove code in
//            ProcessMergedProfiles for more details).  Also note that we
//            enable/disable the corresponding Add and Remove buttons depending
//            on the state of the lists.
// 
//
// Arguments: HWND hDlg - window handle of the dialog containing all of the controls
//            UINT uSourceListControlId - control id of the source listbox
//            UINT uDestListControlId - control id of the dest listbox
//            ListBxList* pSourceList - linked list to fill the source listbox from
//            ListBxList* pDestList - linked list to fill the dest listbox from
//            LPCTSTR pszShortName - short service name of the current profile
//            UINT uAddCtrlId - control id of the Add button (add from source to dest)
//            UINT uRemoveCtrlId - control id of the remove button (remove from dest to source)
//
// Returns:   BOOL - TRUE if successful
//
// History:   quintinb  created     03/09/00
//
//+----------------------------------------------------------------------------
BOOL RefreshDualingListBoxes(HWND hDlg, UINT uSourceListControlId, UINT uDestListControlId, ListBxList* pSourceList, ListBxList* pDestList, LPCTSTR pszShortName, UINT uAddCtrlId, UINT uRemoveCtrlId)
{
    if ((NULL == hDlg) || (0 == uSourceListControlId) || (0 == uDestListControlId))
    {
        CMASSERTMSG(FALSE, TEXT("RefreshDualingListBoxes -- Invalid argument passed"));
        return FALSE;
    }

    //
    //  Reset both of the listboxes
    //
    LRESULT lResult = SendDlgItemMessage(hDlg, uSourceListControlId, LB_RESETCONTENT, (WPARAM)0, (LPARAM)0);

    MYDBGASSERT(LB_ERR != lResult);

    lResult = SendDlgItemMessage(hDlg, uDestListControlId, LB_RESETCONTENT, (WPARAM)0, (LPARAM)0);

    MYDBGASSERT(LB_ERR != lResult);


    //
    //  Add the destination items to the destination listbox
    //
    ListBxList* pCurrent = pDestList;

    while (pCurrent)
    {
        lResult = SendDlgItemMessage(hDlg, uDestListControlId, LB_ADDSTRING, (WPARAM)0, (LPARAM)pCurrent->szName);

        MYDBGASSERT(LB_ERR != lResult);

        pCurrent = pCurrent->next;
    }

    //
    //  Add the source items to the source listbox, making sure to filter out items that are already
    //  in the destination list
    //
    pCurrent = pSourceList;

    while (pCurrent)
    {
        if ((FALSE == FindListItemByName(pCurrent->szName, pDestList, NULL)) && (0 != lstrcmpi(pCurrent->szName, pszShortName)))
        {
            lResult = SendDlgItemMessage(hDlg, uSourceListControlId, LB_ADDSTRING, (WPARAM)0, (LPARAM)pCurrent->szName);

            MYDBGASSERT(LB_ERR != lResult);
        }

        pCurrent = pCurrent->next;
    }
    
    //
    //  Now that we have refreshed the list, we need to update the button and selection status.
    //  If the source list is empty, then we cannot do any Adds.  On the other
    //  hand if the dest list is empty, then we cannot do any deletes.
    //

    HWND hAddControl = GetDlgItem(hDlg, uAddCtrlId);
    HWND hRemoveControl = GetDlgItem(hDlg, uRemoveCtrlId);
    HWND hCurrentFocus = GetFocus();

    lResult = SendDlgItemMessage(hDlg, uSourceListControlId, LB_GETCOUNT, 0, (LPARAM)0);

    BOOL bListNotEmpty = ((LB_ERR != lResult) && (0 != lResult));

    EnableWindow(hAddControl, bListNotEmpty);

    if (bListNotEmpty)
    {
        MYVERIFY(LB_ERR != SendDlgItemMessage(hDlg, uSourceListControlId, LB_SETCURSEL, 0, (LPARAM)0));
    }

    //
    //  Now check the destination list and the Remove button
    //
    lResult = SendDlgItemMessage(hDlg, uDestListControlId, LB_GETCOUNT, 0, (LPARAM)0);

    bListNotEmpty = ((LB_ERR != lResult) && (0 != lResult));

    EnableWindow(hRemoveControl, bListNotEmpty);

    if (bListNotEmpty)
    {
        MYVERIFY(LB_ERR != SendDlgItemMessage(hDlg, uDestListControlId, LB_SETCURSEL, 0, (LPARAM)0));
    }

    //
    //  Figure out if we need to shift the focus because we just disabled the control that had it.
    //
    if (FALSE == IsWindowEnabled(hCurrentFocus))
    {
        if ((hAddControl == hCurrentFocus) && IsWindowEnabled(hRemoveControl))
        {
            SendMessage(hDlg, DM_SETDEFID, uRemoveCtrlId, (LPARAM)0L); //lint !e534 DM_SETDEFID doesn't return error info
            SetFocus(hRemoveControl);
        }
        else if ((hRemoveControl == hCurrentFocus) && IsWindowEnabled(hAddControl))
        {
            SendMessage(hDlg, DM_SETDEFID, uAddCtrlId, (LPARAM)0L); //lint !e534 DM_SETDEFID doesn't return error info
            SetFocus(hAddControl);        
        }
        else
        {
            SetFocus(GetDlgItem(hDlg, uSourceListControlId));
        }    
    }

    return TRUE;
}

void OnProcessMergedProfilesAdd(HWND hDlg)
{
    TCHAR szTemp[MAX_PATH+1];
    LRESULT lResult;

    //
    //  Get the current selection from the listbox containing the items
    //  to merge.
    //
    lResult = SendDlgItemMessage(hDlg, IDC_LIST1, LB_GETCURSEL, 0, (LPARAM)0);

    if (lResult != LB_ERR)
    {
        lResult = SendDlgItemMessage(hDlg, IDC_LIST1, LB_GETTEXT, 
                                     (WPARAM)lResult, (LPARAM)szTemp);

        if (lResult != LB_ERR)
        {
            MYVERIFY(FALSE != createListBxRecord(&g_pHeadMerge, &g_pTailMerge, NULL, 0, szTemp));

            MYVERIFY(RefreshDualingListBoxes(hDlg, IDC_LIST1, IDC_LIST2, g_pHeadProfile, 
                                             g_pHeadMerge, g_szShortServiceName, IDC_BUTTON1, IDC_BUTTON2));
        }
    }
}

void OnProcessMergedProfilesRemove(HWND hDlg)
{
    TCHAR szTemp[MAX_PATH+1];
    LRESULT lResult;
    //
    //  Get the listbox selection from the already merged in list
    //
    lResult = SendDlgItemMessage(hDlg, IDC_LIST2, LB_GETCURSEL, 0, (LPARAM)0);
    
    if (LB_ERR == lResult)
    {
        MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NOSELECTION, MB_OK));
    }
    else
    {
        //
        //  Get the name of the profile to remove from the merge list
        //
        lResult = SendDlgItemMessage(hDlg, IDC_LIST2, LB_GETTEXT, (WPARAM)lResult, (LPARAM)szTemp);
    
        if (LB_ERR != lResult)
        {
            //
            //  Check to see if this is an item in the Profile list.  If not, the user
            //  will not be able to add it back.
            //
            int iReturnValue = IDYES;

            if (FALSE == FindListItemByName(szTemp, g_pHeadProfile, NULL)) // NULL because we don't need a pointer to the list item returned
            {
                LPTSTR pszMsg = CmFmtMsg(g_hInstance, IDS_NOTINPROFILELIST, szTemp, szTemp, szTemp);

                if (pszMsg)
                {
                    iReturnValue = MessageBox(hDlg, pszMsg, g_szAppTitle, MB_YESNO);
                    CmFree(pszMsg);
                }
            }

            if (IDYES == iReturnValue)
            {
                //
                //  Delete it from the merged profile linked list
                //
                DeleteListBxRecord(&g_pHeadMerge, &g_pTailMerge, szTemp);
    
                //
                //  Remove it from the UI
                //
                MYVERIFY(RefreshDualingListBoxes(hDlg, IDC_LIST1, IDC_LIST2, g_pHeadProfile, 
                                                 g_pHeadMerge, g_szShortServiceName, IDC_BUTTON1, IDC_BUTTON2));
            }
        }
    }
}
//+----------------------------------------------------------------------------
//
// Function:  ProcessMergedProfiles
//
// Synopsis:  Merge Profiles
//
// History:   quintinb  Created Header and renamed from ProcessPage6B   8/6/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessMergedProfiles(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    NMHDR* pnmHeader = (NMHDR*)lParam;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_MERGE)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_LIST1);
    SetDefaultGUIFont(hDlg,message,IDC_LIST2);

    switch (message)
    {
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_BUTTON1: //add
                    OnProcessMergedProfilesAdd(hDlg);
                    return TRUE;

                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case IDC_BUTTON2: //remove
                    OnProcessMergedProfilesRemove(hDlg);
                    return TRUE;
                    
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed
                case IDC_LIST1:
                    if (LBN_DBLCLK == HIWORD(wParam))
                    {
                        OnProcessMergedProfilesAdd(hDlg);
                        return TRUE;                    
                    }

                    break;

                case IDC_LIST2:
                    if (LBN_DBLCLK == HIWORD(wParam))
                    {
                        OnProcessMergedProfilesRemove(hDlg);
                        return TRUE;                    
                    }
                    
                    break;
                    
                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));

                    //
                    //  First lets setup the list of profiles that are actually merged into the
                    //  profile.  First step is to read in the merged profile list from the profile.
                    //

                    ReadMergeList();

                    //
                    //  Now delete the merged profile list and any filter/cms references from the profile.
                    //
                    RemoveReferencesFromCMS();

                    //
                    //  Refresh the two list boxes
                    //
                    MYVERIFY(RefreshDualingListBoxes(hDlg, IDC_LIST1, IDC_LIST2, g_pHeadProfile, 
                                                     g_pHeadMerge, g_szShortServiceName, IDC_BUTTON1, IDC_BUTTON2));

                    break;

                case PSN_WIZBACK:
                case PSN_WIZNEXT:
                    WriteMergeList();
                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

BOOL CreateMergedProfile()
{
    ListBxList * LoopPtr;
    TCHAR szReferences[MAX_PATH+1];
    LPTSTR pszName;
    TCHAR szEntry[MAX_PATH+1];
    TCHAR szFile[MAX_PATH+1];
    TCHAR szKey[MAX_PATH+1];
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szDest[MAX_PATH+1];

    szReferences[0] = TEXT('\0');

    if (g_pHeadMerge == NULL)
    {
        return TRUE;
    }
    LoopPtr = g_pHeadMerge;

    while( LoopPtr != NULL)
    {
        pszName = LoopPtr->szName;

        _tcscat(szReferences, pszName);
        _tcscat(szReferences, TEXT(" "));
        MYDBGASSERT(_tcslen(szReferences) <= CELEMS(szReferences));

        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s%s\\%s.cms"), g_szOsdir, pszName, pszName));

        MYVERIFY(CELEMS(szDest) > (UINT)wsprintf(szDest, TEXT("%s\\%s.cms"), g_szOutdir, pszName));

        // COPY CMS FILE
        
        //
        //  First check to see if the profile exists in profile directory
        //

        if (!FileExists(szTemp)) 
        {
            //
            //  Couldn't open it in the profile dir, lets try in the temp dir
            //
            
            if (!FileExists(szDest))
            {
                FileAccessErr(NULL, szDest);
                return FALSE;
            }
        }
        else
        {
            if (!CopyFileWrapper(szTemp, szDest, FALSE))
            {
                return FALSE;
            }
        }
        
        MYVERIFY(0 != SetFileAttributes(szDest,FILE_ATTRIBUTE_NORMAL));

        MYVERIFY(FALSE != MoveCmsFile(szDest, g_szShortServiceName));
        
        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s.cms"), pszName));
        MYVERIFY(FALSE != createListBxRecord(&g_pHeadRefs,&g_pTailRefs,(void *)NULL,0,szTemp));

        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s.cms"), g_szShortServiceName, pszName));
        MYVERIFY(CELEMS(szKey) > (UINT)wsprintf(szKey, TEXT("%s%s"), c_pszCmEntryIspCmsFile, pszName));

        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionIsp,szKey,szTemp,g_szCmsFile));

        MYVERIFY(CELEMS(szKey) > (UINT)wsprintf(szKey, TEXT("%s%s"), c_pszCmEntryIspFilterA, 
            pszName));

        // only write if it doesn't exist

        //
        //  The following call to GetPrivateProfileString could return a blank string, thus we don't
        //  use the MYVERIFY macro on it.
        //

        ZeroMemory(szTemp, sizeof(szTemp));
        GetPrivateProfileString(c_pszCmSectionIsp, szKey, TEXT(""), szTemp, CELEMS(szTemp),
            g_szCmsFile); //lint !e534
        
        if (TEXT('\0') == szTemp[0])
        {
            MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionIsp, szKey, TEXT("NosurchargeSignon"),
                g_szCmsFile));
        }

        MYVERIFY(CELEMS(szKey) > (UINT)wsprintf(szKey, TEXT("%s%s"), c_pszCmEntryIspFilterB, 
            pszName));

        //
        //  The following call to GetPrivateProfileString could return a blank string, thus we shouldn't
        //  check its return code with MYVERIFY.
        //

        GetPrivateProfileString(c_pszCmSectionIsp, szKey, TEXT(""), szTemp, CELEMS(szTemp),
            g_szCmsFile); //lint !e534
        
        if (TEXT('\0') == szTemp[0])
        {
            MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionIsp, szKey, TEXT("SurchargeSignon"), 
                g_szCmsFile));
        }

        MYVERIFY(0 != SetCurrentDirectory(g_szOsdir));

        // COPY PHONEBOOK

        GetPrivateProfileString(c_pszCmSectionIsp, c_pszCmEntryIspPbFile, TEXT(""), szEntry, 
            CELEMS(szEntry), szDest);    //lint !e534 could return EMPTY string

        GetFileName(szEntry,szFile);
        
        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s"), g_szOutdir, szFile));
        
        if (CopyFile(szEntry,szTemp,FALSE))
        {
            MYVERIFY(FALSE != createListBxRecord(&g_pHeadRefs, &g_pTailRefs, (void *)NULL, 0, szFile));
            MYVERIFY(0 != SetFileAttributes(szTemp, FILE_ATTRIBUTE_NORMAL));
        }
        
        //
        // DO NOT REPORT AN ERROR IF COULDN'T FIND PHONEBOOK, IT IS OPTIONAL
        //
        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s"), g_szShortServiceName, szFile));

        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionIsp, c_pszCmEntryIspPbFile, szTemp, 
            szDest));

        // COPY REGIONS

        GetPrivateProfileString(c_pszCmSectionIsp, c_pszCmEntryIspRegionFile, TEXT(""), szEntry, 
            CELEMS(szEntry), szDest);  //lint !e534

        GetFileName(szEntry,szFile);
        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s"), g_szOutdir, szFile));
        if (CopyFile(szEntry,szTemp,FALSE))
        {
            MYVERIFY(FALSE != createListBxRecord(&g_pHeadRefs,&g_pTailRefs,(void *)NULL,0,szFile));
            MYVERIFY(0 != SetFileAttributes(szTemp,FILE_ATTRIBUTE_NORMAL));
        }

        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s"), g_szShortServiceName, szFile));
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionIsp, c_pszCmEntryIspRegionFile, szTemp, szDest));
        LoopPtr = LoopPtr->next;
    }

    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionIsp, c_pszCmEntryIspReferences, szReferences, g_szCmsFile));
    return TRUE;

}

//+----------------------------------------------------------------------------
//
// Function:  ProcessCustomHelp
//
// Synopsis:  Set up windows help
//
//
// History:   quintinb Created Header and renamed from ProcessPage7    8/6/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessCustomHelp(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    static TCHAR szDisplay[MAX_PATH+1]; // keeps unselected custom entry
    NMHDR* pnmHeader = (NMHDR*)lParam;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_CMHELP)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_EDITHELP);

    switch (message)
    {

        case WM_INITDIALOG:
            SetFocus(GetDlgItem(hDlg, IDC_EDITHELP));

            break;
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_RADIO1:
                    EnableWindow(GetDlgItem(hDlg,IDC_EDITHELP),FALSE);
                    _tcscpy(szDisplay,g_szHelp);
                    break;

                case IDC_RADIO2:
                    EnableWindow(GetDlgItem(hDlg,IDC_EDITHELP),TRUE);
                    
                    if (!(*g_szHelp) && (*szDisplay))
                    {
                        _tcscpy(g_szHelp,szDisplay);
                    }

                    break;

                case IDC_BROWSE1:
                    {
                        EnableWindow(GetDlgItem(hDlg,IDC_EDITHELP),TRUE);
                        MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO1,IDC_RADIO2,IDC_RADIO2));

                        UINT uFilter = IDS_HLPFILTER;
                        TCHAR* szMask = TEXT("*.hlp");

                        MYVERIFY(0 != DoBrowse(hDlg, &uFilter, &szMask, 1,
                            IDC_EDITHELP, TEXT("hlp"), g_szHelp));
                    }

                    break;

                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));
                    
                    //
                    //  The following call to GetPrivateProfileString could return an empty string
                    //  thus we shouldn't check the return code with MYVERIFY.
                    //

                    ZeroMemory(g_szHelp, sizeof(g_szHelp));
                    GetPrivateProfileString(c_pszCmSection, c_pszCmEntryHelpFile, TEXT(""), 
                        g_szHelp, CELEMS(g_szHelp), g_szCmsFile);   //lint !e534
                    
                    if (TEXT('\0') == g_szHelp[0])
                    {
                        MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO1,IDC_RADIO2,IDC_RADIO1));
                        EnableWindow(GetDlgItem(hDlg,IDC_EDITHELP),FALSE);
                        MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDITHELP), WM_SETTEXT, 0, (LPARAM)GetName(szDisplay)));
                    }
                    else
                    {
                        MYVERIFY(0 != CheckRadioButton(hDlg,IDC_RADIO1,IDC_RADIO2,IDC_RADIO2));
                        EnableWindow(GetDlgItem(hDlg,IDC_EDITHELP),TRUE);
                        MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDITHELP), WM_SETTEXT, 0, (LPARAM)GetName(g_szHelp)));
                        MYVERIFY(FALSE != VerifyFile(hDlg,IDC_EDITHELP,g_szHelp,FALSE));
                    }
                    break;

                case PSN_WIZBACK:

                case PSN_WIZNEXT:
                    // the Next button was pressed
                    if (IsDlgButtonChecked(hDlg, IDC_RADIO2)==BST_CHECKED)
                    {
                        if (-1 == GetTextFromControl(hDlg, IDC_EDITHELP, szTemp, MAX_PATH, TRUE)) // bDisplayError == TRUE
                        {
                            SetFocus(GetDlgItem(hDlg, IDC_EDITHELP));
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }
                        
                        if (!VerifyFile(hDlg,IDC_EDITHELP,g_szHelp,TRUE))
                        {
                            if (g_szHelp[0] != TEXT('\0'))
                            {
                                return 1;
                            }
                        }

                        if (g_szHelp[0] == TEXT('\0'))
                        {
                            MYVERIFY(IDOK == ShowMessage(hDlg,IDS_NOHELP,MB_OK));
                            SetFocus(GetDlgItem(hDlg, IDC_EDITHELP));
                            
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }
                    }
                    else
                    {
                        g_szHelp[0] = TEXT('\0');
                    }

                    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryHelpFile, g_szHelp, g_szCmsFile));

                    //
                    //  By calling WritePrivateProfileString with all NULL's we flush the file cache 
                    //  (win95 only).  This call will return 0.
                    //

                    WritePrivateProfileString(NULL, NULL, NULL, g_szCmsFile); //lint !e534 this call will always return 0
                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessLicense
//
// Synopsis:  Add a license agreement
//
//
// History:   quintinb  Created Header and renamed from ProcessPage7A    8/6/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessLicense(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    NMHDR* pnmHeader = (NMHDR*)lParam;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_LICENSE)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_EDIT1);

    switch (message)
    {

        case WM_INITDIALOG:
            SetFocus(GetDlgItem(hDlg, IDC_EDIT1));

            break;
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_BROWSE1:
                    {
                        UINT uFilter = IDS_TXTFILTER;
                        TCHAR* szMask = TEXT("*.txt");

                        MYVERIFY(0 != DoBrowse(hDlg, &uFilter, &szMask, 1, IDC_EDIT1, TEXT("txt"), 
                            g_szLicense));
                    
                    }
                    break;

                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));

                    // 
                    //  The following call to GetPrivateProfileString could return an empty string,
                    //  thus we shouldn't use MYVERIFY on it.
                    //
                    ZeroMemory(g_szLicense, sizeof(g_szLicense));
                    GetPrivateProfileString(c_pszCmakStatus, c_pszLicenseFile, TEXT(""), g_szLicense, 
                        CELEMS(g_szLicense), g_szInfFile);   //lint !e534
                    
                    MYVERIFY(TRUE == SendMessage(GetDlgItem(hDlg, IDC_EDIT1), WM_SETTEXT, 0, (LPARAM)GetName(g_szLicense)));
                    MYVERIFY(FALSE != VerifyFile(hDlg,IDC_EDIT1,g_szLicense,FALSE));
                    break;

                case PSN_WIZBACK:

                case PSN_WIZNEXT:
                    // the Next button was pressed
                    
                    if (-1 == GetTextFromControl(hDlg, IDC_EDIT1, szTemp, MAX_PATH, TRUE)) // bDisplayError == TRUE
                    {
                        SetFocus(GetDlgItem(hDlg, IDC_EDIT1));
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                        return 1;
                    }

                    if (!VerifyFile(hDlg,IDC_EDIT1,g_szLicense,TRUE))
                    {
                        if (g_szLicense[0] != TEXT('\0'))
                        {
                            return 1;
                        }
                    }
    
                    MYVERIFY(0 != WritePrivateProfileString(c_pszCmakStatus,c_pszLicenseFile,g_szLicense,g_szInfFile));

#ifdef _WIN64
                    //
                    //  If we are going back, skip the Include CM binaries page if this is IA64
                    //
                    if (pnmHeader && (PSN_WIZBACK == pnmHeader->code)) 
                    {                        
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, IDD_SUPPORT_INFO));
                    }
#endif
                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

//+----------------------------------------------------------------------------
//
// Function:  MultiSelectOpenFileName
//
// Synopsis:  This function is called to allow the user to select multiple items
//            to add to cmak.  It is currently only used in the Additional Files
//            dialog of CMAK.  Note that *pszStringBuffer should be NULL when passed
//            in.  The caller is responsible for calling CmFree on pszStringBuffer
//            when finished.
//
// Arguments: HWND hDlg - HWND of the current dialog
//            TCHAR** pszStringBuffer - pointer to the buffer to hold the results
//
// Returns:   BOOL - Returns True if successful, -1 on cancel and 0 on error.
//
// History:   quintinb Created    9/16/98
//
//+----------------------------------------------------------------------------
BOOL MultiSelectOpenFileName(HWND hDlg, TCHAR** pszStringBuffer)
{
    OPENFILENAME filedef;
    TCHAR szTitle[MAX_PATH+1];
    TCHAR szFile[MAX_PATH+1];
    TCHAR szFilter[MAX_PATH+1];
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szFileTitle[MAX_PATH+1];
    LPTSTR lpfilename;
    int iReturnValue;

    //
    //  Check Inputs
    //

    MYDBGASSERT(pszStringBuffer);

    if (NULL == pszStringBuffer)
    {
        return FALSE;
    }

    ZeroMemory(&filedef, sizeof(OPENFILENAME));
    ZeroMemory(szFilter, sizeof(szFilter));


    szFile[0] = TEXT('\0');

    MYVERIFY(0 != LoadString(g_hInstance, IDS_BROWSETITLE, szTitle, MAX_PATH));
    MYVERIFY(0 != LoadString(g_hInstance, IDS_ALLFILTER, szFilter, MAX_PATH));
    TCHAR * pszTemp = &(szFilter[_tcslen(szFilter) + 1]);
    MYVERIFY(0!= wsprintf(pszTemp, c_pszWildCard));

    //
    //  Allocate memory for the multiple file selection return
    //

    DWORD dwSize = 10*1024;
    *pszStringBuffer = (TCHAR*)CmMalloc(dwSize*sizeof(TCHAR));
    if (NULL == *pszStringBuffer)
    {
        return FALSE;
    }
    ZeroMemory(*pszStringBuffer, dwSize*sizeof(TCHAR));

    //
    // Initialize the OPENFILENAME data structure
    //

    filedef.lStructSize = sizeof(OPENFILENAME); 
    filedef.hwndOwner = hDlg;    
    filedef.lpstrFilter = szFilter;
    filedef.lpstrFile = *pszStringBuffer;
    filedef.nMaxFile = dwSize;
    filedef.lpstrTitle = szTitle;
    filedef.Flags = OFN_FILEMUSTEXIST | OFN_LONGNAMES | OFN_PATHMUSTEXIST 
        | OFN_ALLOWMULTISELECT | OFN_EXPLORER; 
    
    //
    // pop up the open dialog
    //

    BOOL bExit;

    do
    {
        bExit = TRUE;

        BOOL bRet = GetOpenFileName((OPENFILENAME*)&filedef);
        
        if (bRet)
        {
            iReturnValue = 1;
        }
        else
        {
            //
            //  If we are in this state than the user could have hit cancel or there could have
            //  been an error.  If the CommDlgExtendedError function returns 0 then we know it was
            //  just a cancel, otherwise we have an error.
            //
            DWORD dwError = CommDlgExtendedError();

            if (0 == dwError)
            {
                //
                //  The user hit cancel
                //
                iReturnValue = -1;
            }
            else if (FNERR_BUFFERTOOSMALL == dwError)
            {
                //
                //  Not enough memory in the buffer.  The user is picking a whole bunch
                //  of files.  Lets warn them.
                //
                MYVERIFY(IDOK == ShowMessage(hDlg, IDS_SELECTION_TOO_LARGE, MB_OK | MB_ICONWARNING));

                bExit = FALSE;        
            }
            else
            {
                //
                //  An actual error occured, fail.
                //
                iReturnValue = 0;
            }
        }

    } while(!bExit);

    return iReturnValue;

}



//+----------------------------------------------------------------------------
//
// Function:  ParseAdditionalFiles
//
// Synopsis:  This function is used to parse the output from MultiSelectOpenFileName.
//            It takes a Null seperated list generated by OpenFileName (either one
//            full file path, or a directory path, NULL, and then NULL seperated 
//            filenames.)  From this list of filenames it adds them to the passed in
//            list of Extra file structures.
//
// Arguments: ListBxList **g_pHeadExtra - pointer to the head of the Extra struct list
//            ListBxList **g_pTailExtra - pointer to the tail of the Extra struct list
//            TCHAR* pszStringBuffer - string buffer of filenames to process
//
// Returns:   BOOL - TRUE on Success
//
// History:   quintinb Created      9/16/98
//
//+----------------------------------------------------------------------------
BOOL ParseAdditionalFiles(ListBxList **g_pHeadExtra, ListBxList **g_pTailExtra, TCHAR* pszStringBuffer)
{
    UINT uCurrentCharInBuffer=0;
    UINT uTempChars;
    TCHAR szPath[MAX_PATH+1];
    ExtraData DlgExtraEdit;

    MYDBGASSERT(NULL != g_pHeadExtra);
    MYDBGASSERT(NULL != g_pTailExtra);
    MYDBGASSERT(NULL != pszStringBuffer);
    MYDBGASSERT(TEXT('\0') != pszStringBuffer[0]);

    TCHAR* pStr = pszStringBuffer;

    _tcscpy (szPath, pszStringBuffer);
    pStr = pStr + (_tcslen(pStr) + 1);
    
    if (TEXT('\0') == *pStr)
    {
        //
        //  If the user only selected one file, then we just need to copy it to a buffer
        //
        _tcscpy(DlgExtraEdit.szPathname, szPath);
        GetFileName(DlgExtraEdit.szPathname, DlgExtraEdit.szName);

        MYVERIFY(FALSE != createListBxRecord(g_pHeadExtra, g_pTailExtra,(void *)&DlgExtraEdit, 
            sizeof(DlgExtraEdit), DlgExtraEdit.szName));
        return TRUE;
    }
    else
    {
        while (TEXT('\0') != *pStr)
        {
            //
            //  Fill the DlgExtra Struct with data
            //
            TCHAR szTemp[MAX_PATH+1];
            MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s"), szPath, pStr));
            _tcscpy(DlgExtraEdit.szPathname, szTemp);
            _tcscpy(DlgExtraEdit.szName, pStr);

            //
            //  Create the List box entry
            //
            MYVERIFY(FALSE != createListBxRecord(g_pHeadExtra, g_pTailExtra,(void *)&DlgExtraEdit, 
                                                 sizeof(DlgExtraEdit), DlgExtraEdit.szName));
            //
            //  Increment
            //
            pStr = pStr + (_tcslen(pStr) + 1);
        }

        return TRUE;
    }

    return FALSE;
}

void EnableDisableDeleteButton(HWND hDlg)
{
    //
    //  Enable the delete button if we have move than one item
    //
    LRESULT lResult = SendDlgItemMessage(hDlg, IDC_LIST1, LB_GETCOUNT, 0, 0);

    HWND hDeleteButton = GetDlgItem(hDlg, IDC_BUTTON2);
    HWND hCurrentFocus = GetFocus();
    HWND hControl;

    if (hDeleteButton)
    {
        EnableWindow(hDeleteButton, (1 <= lResult));
    }

    if (1 <= lResult)
    {
        SendDlgItemMessage(hDlg, IDC_LIST1, LB_SETCURSEL, 0, 0);    
    }

    if (FALSE == IsWindowEnabled(hCurrentFocus))
    {
        if (hDeleteButton == hCurrentFocus)
        {
            //
            //  If delete is disabled and contained the focus, shift it to the Add button
            //
            hControl = GetDlgItem(hDlg, IDC_BUTTON1);
            SendMessage(hDlg, DM_SETDEFID, IDC_BUTTON1, (LPARAM)0L); //lint !e534 DM_SETDEFID doesn't return error info
            SetFocus(hControl);
        }
        else
        {
            //
            //  If all else fails set the focus to the list control
            //
            hControl = GetDlgItem(hDlg, IDC_LIST1);
            SetFocus(hControl);
        }    
    }


}

//+----------------------------------------------------------------------------
//
// Function:  ProcessAdditionalFiles
//
// Synopsis:  Add additional files to the profile
//
//
// History:   quintinb Created Header and renamed from ProcessPage7B   8/6/98
//            quintinb Added Multi-Select capability and removed intermediate dialog 9/16/98
//                      (NTRAID 210849)
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessAdditionalFiles(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    INT_PTR nResult;
    TCHAR* pszStringBuffer = NULL;
    BOOL bRet;
    NMHDR* pnmHeader = (NMHDR*)lParam;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_ADDITION)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_LIST1);

    switch (message)
    {
        case WM_INITDIALOG:
            SetFocus(GetDlgItem(hDlg, IDC_BUTTON1));
            break;

        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_BUTTON1: //add
                    bRet = MultiSelectOpenFileName(hDlg, &pszStringBuffer);
                    if ((-1 != bRet) && (0 != bRet))
                    {
                        ParseAdditionalFiles(&g_pHeadExtra, &g_pTailExtra, pszStringBuffer);

                        RefreshList(hDlg, IDC_LIST1, g_pHeadExtra);
                        WriteExtraList();
                        SetFocus(GetDlgItem(hDlg, IDC_BUTTON1));
                        
                        EnableDisableDeleteButton(hDlg);
                    }
                    CmFree(pszStringBuffer);
                    return (TRUE);
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case IDC_BUTTON2: //delete
                    nResult = SendDlgItemMessage(hDlg, IDC_LIST1, LB_GETCURSEL, 0, (LPARAM)0);
                    if (nResult == LB_ERR)
                    {
                        MYVERIFY(IDOK == ShowMessage(hDlg, IDS_NOSELECTION, MB_OK));
                        return TRUE;
                    }

                    MYVERIFY(LB_ERR != SendDlgItemMessage(hDlg, IDC_LIST1, LB_GETTEXT, (WPARAM)nResult, 
                        (LPARAM)szTemp));
                    
                    DeleteListBxRecord(&g_pHeadExtra, &g_pTailExtra, szTemp);
                    RefreshList(hDlg, IDC_LIST1, g_pHeadExtra);
                    EnableDisableDeleteButton(hDlg);
                    WriteExtraList();
                    return (TRUE);
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_NEXT | PSWIZB_BACK));
                    
                    if (g_pHeadExtra == NULL)
                    {
                        ReadExtraList();
                    }

                    RefreshList(hDlg, IDC_LIST1, g_pHeadExtra);

                    EnableDisableDeleteButton(hDlg);

                   break;

                case PSN_WIZBACK:

                case PSN_WIZNEXT:
                    
                    //
                    //  Before allowing the user to finish we need to check the extra files
                    //  list and make sure that each file on it has a filename that is convertable
                    //  to ANSI.  If not then we need to make sure that we tell them so that they
                    //  can delete the file or rename it.  Checking this in ParseAdditional files
                    //  seemed odd because they may have selected a bunch of files where only
                    //  one of them was wrong.  Thus we would be failing their browse and there was
                    //  nothing they could do about it.  Doing it here allows them to keep all of the
                    //  good files that pass the roundtrip test and allows them to delete offending files
                    //  at a spot where they can actually do so.
                    //
                    
                    ExtraData * pExtraData;
                    ListBxList * LoopPtr;
                    if (NULL != g_pHeadExtra)
                    {
                        LoopPtr = g_pHeadExtra;

                        while( LoopPtr != NULL)
                        {
                            pExtraData = (ExtraData *)LoopPtr->ListBxData;
                            {
                                GetFileName(pExtraData->szPathname, szTemp);
                                if (!TextIsRoundTripable(szTemp, TRUE)) // TRUE == bDisplayError
                                {
                                    //
                                    //  Set the Cursor on the offending item in the list
                                    //
                                    nResult = SendDlgItemMessage(hDlg, IDC_LIST1, LB_FINDSTRINGEXACT, 
                                                                (WPARAM)-1, (LPARAM)szTemp);                      
                                    if (LB_ERR != nResult)
                                    {
                                        MYVERIFY(LB_ERR != SendDlgItemMessage(hDlg, IDC_LIST1, LB_SETCURSEL, (WPARAM)nResult, (LPARAM)0));
                                    }

                                    //
                                    //  Set focus on the delete button
                                    //
                                    SetFocus(GetDlgItem(hDlg, IDC_BUTTON2));
                                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                                    return 1;
                                }
                            }

                            LoopPtr = LoopPtr->next;
                        }
                    }

                    WriteExtraList();
                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}

BOOL WriteInf(HANDLE hInf, LPCTSTR str)
{
    DWORD written;

#ifdef UNICODE
    BOOL bReturn = FALSE;
    LPSTR pszAnsiString = WzToSzWithAlloc(str);
    
    if (pszAnsiString)
    {
        bReturn = WriteFile(hInf, pszAnsiString, (lstrlenA(pszAnsiString))*sizeof(CHAR), &written, NULL);
        CmFree(pszAnsiString);
    }

    return bReturn;
#else
    return (WriteFile(hInf, str, (lstrlen(str))*sizeof(TCHAR), &written, NULL));
#endif
}


//+----------------------------------------------------------------------------
//
// Function:  WriteCopy
//
// Synopsis:  This function writes an INF entry and copies the file to the temp
//            directory.  Note that the function expects a fully qualified path
//            in lpFile or <shortservicename>\filename.ext.
//
// Arguments: HANDLE hInf - handle to the open inf file to write to
//            LPTSTR lpFile - fully qualified path and filename of file to copy
//            BOOL bWriteShortName -- should the filename be converted to the shortname
//
// Returns:   BOOL - TRUE if the INF entry is written properly and the file is
//            copied properly.
//
//  NOTE:   This code is written such that filenames passed in should reference the
//          copy of the file in the temp directory (thus the user is editing the profile
//          and hasn't changed it) or the file is a new file and the path is to its original
//          location.  Unfortunately, we usually pass in the path to the file in the Profile
//          directory instead of in the temp dir.  This works fine, but makes an additional copy
//          operation necessary (since we copy all files to the temp dir in the beginning when 
//          editting anyway).
//
// History:   quintinb  Created Header    1/30/98
//
//+----------------------------------------------------------------------------
BOOL WriteCopy(HANDLE hInf, LPTSTR lpFile, BOOL bWriteShortName)
{
    TCHAR szDest[MAX_PATH+1];
    TCHAR szSrc[MAX_PATH+1];

    if (NULL != lpFile && lpFile[0] != TEXT('\0'))
    {
        //
        //  Prepare the destination in szDest
        //
        GetFileName(lpFile, szSrc);
        
        MYVERIFY(CELEMS(szDest) > (UINT)wsprintf(szDest, TEXT("%s\\%s"), g_szOutdir, szSrc));

        //
        //  Prepare the source in szSrc.  If we have <shortservicename>\filename.ext, then
        //  we need to prepend the path to the profiles dir, otherwise use as is.
        //
        wsprintf(szSrc, TEXT("%s\\"), g_szShortServiceName);
        CmStrTrim(lpFile);

        if (lpFile == CmStrStr(lpFile, szSrc))
        {
           MYVERIFY(CELEMS(szSrc) > (UINT)wsprintf(szSrc, TEXT("%s%s\\%s"), g_szCmakdir, c_pszProfiles, lpFile));        
        }
        else
        {
            lstrcpy(szSrc, lpFile);
        }

        //
        //  Copy the file
        //
        if (_tcsicmp(szSrc, szDest) != 0)
        {
            if (!CopyFileWrapper(szSrc, szDest, FALSE))
            {
                return FALSE;
            }
        }

        MYVERIFY(0 != SetFileAttributes(szDest, FILE_ATTRIBUTE_NORMAL));

        //
        //  If WriteShortName is set, then we want to write the short name of the file
        //  in the inf section.  Otherwise we want to write the long name.
        //
        if (bWriteShortName)
        {
            if (!GetShortFileName(szDest, szSrc))
            {
                return FALSE;
            }
        }
        else
        {
            GetFileName(szDest, szSrc);
        }

        MYVERIFY(CELEMS(szDest) > (UINT)wsprintf(szDest, TEXT("%s\r\n"), szSrc));

        return WriteInf(hInf, szDest);
    }
    return TRUE;
}


BOOL WriteInfLine(HANDLE hInf,LPTSTR lpFile)
{
    TCHAR szTemp[MAX_PATH+1];

    if (lpFile[0] != TEXT('\0'))
    {
        GetFileName(lpFile,szTemp);
        _tcscat(szTemp,TEXT("\r\n"));
        return WriteInf(hInf,szTemp);
    }
    else
    {
        //
        //  If blank then nothing to write
        //
        return TRUE;
    }
}

BOOL WriteSrcInfLine(HANDLE hInf,LPTSTR lpFile)
{
    TCHAR szShort[MAX_PATH+1];
    TCHAR szLong[MAX_PATH+1];
    RenameData TmpRenameData;

    if (lpFile[0] != TEXT('\0'))
    {
        if (!GetShortFileName(lpFile,szShort))
        {
            return FALSE;
        }

        GetFileName(lpFile,szLong);
        
        if (_tcsicmp(szShort,szLong) != 0)
        {
            _tcscpy(TmpRenameData.szShortName,szShort);
            _tcscpy(TmpRenameData.szLongName,szLong);
            MYVERIFY(FALSE != createListBxRecord(&g_pHeadRename,&g_pTailRename,(void *)&TmpRenameData,sizeof(TmpRenameData),TmpRenameData.szShortName));
        }
        _tcscat(szLong,TEXT("= 55\r\n"));
        return WriteInf(hInf,szLong);
    }
    else
    {
        //
        //  Nothing to write
        //
        return TRUE;
    }
}

BOOL WriteFileSections(HWND hDlg)
{
    HANDLE hInf;
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szTempName[MAX_PATH+1];
    TCHAR ch;
    int i;
    DWORD dwRead;
    BOOL bWriteShortName;

    hInf = CreateFile(g_szInfFile,GENERIC_WRITE|GENERIC_READ,0,NULL,OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,NULL);
    if (hInf == INVALID_HANDLE_VALUE)
    {
        _tcscpy(szTemp,g_szInfFile);
        FileAccessErr(hDlg,szTemp);
        goto error;
    }

    // MOVE TO END OF FILE TO BEGIN WRITING CUSTOM SECTIONS
    // SKIP ANY BLANK SPACE AT THE END OF THE FILE
    i = GetFileSize(hInf,NULL);
    do
    {
        --i;
        MYVERIFY(INVALID_SET_FILE_POINTER != SetFilePointer(hInf,i,NULL,FILE_BEGIN));
        MYVERIFY(0 != ReadFile(hInf,&ch,1,&dwRead,NULL));
    }
    while ((ch == TEXT('\r'))||(ch == TEXT('\n'))||(ch == TEXT(' ')));

    MYVERIFY(FALSE != WriteInf(hInf,TEXT("\r\n")));
    MYVERIFY(FALSE != WriteInf(hInf,TEXT("\r\n")));
    // USE ICON IN CM AS ICON FOR DESKTOP IF NOT LARGE ICON SPECIFIED
    MYVERIFY(FALSE != WriteInf(hInf,TEXT("[Xnstall.AddReg.Icon]\r\n")));
    if (g_szLargeIco[0]==TEXT('\0'))
    {
        WriteInf(hInf,TEXT("HKCR,\"CLSID\\%DesktopGUID%\\DefaultIcon\",,,\"%11%\\CMMGR32.EXE,0\"\r\n"));//lint !e534 compile doesn't like the MYVERIFY macro and big strings
    }
    else
    {
        WriteInf(hInf,TEXT("HKCR,\"CLSID\\%DesktopGUID%\\DefaultIcon\",,,\"%49000%\\%ShortSvcName%\\%DesktopIcon%\"\r\n"));//lint !e534 compile doesn't like the MYVERIFY macro and big strings
    }

    MYVERIFY(FALSE != WriteInf(hInf,TEXT("\r\n")));
    // WRITE OUT FILES INTO PROFILE DIRECTORY

    //
    //  We need to write a CopyFiles section with Long File Names (for NT5 Single User installs) 
    //  and one with Short Files Names (for win9x and All user NT).  This is to help fix
    //  NTRAID 323721 -- CM: User level accounts cannot install profiles on W2K Server
    //  The problem is that single users on NT5 do not have permission to write the
    //  Rename key (HKLM\Software\Microsoft\Windows\CurrentVersion\RenameFiles) and
    //  NT doesn't really need it anyway since the NT setup api's deal with long file
    //  names better than those of win95.
    //  

    for (bWriteShortName = 0; bWriteShortName < 2; bWriteShortName++)
    {
        if (!bWriteShortName)
        {
            //
            //  Write out the Single User Version of Xnstall.CopyFiles -- Set bWriteShortName == FALSE
            //
            MYVERIFY(FALSE != WriteInf(hInf, TEXT("[Xnstall.CopyFiles.SingleUser]\r\n")));
        }
        else
        {
            //
            //  Write out the All User Version of Xnstall.CopyFiles -- set bWriteShortName == TRUE
            //
            MYVERIFY(FALSE != WriteInf(hInf,TEXT("[Xnstall.CopyFiles]\r\n")));
        }

        if (!WriteCopy(hInf, g_szPhonebk, bWriteShortName)) {_tcscpy(szTemp,g_szPhonebk);goto error;}
        if (!WriteCopy(hInf, g_szRegion, bWriteShortName)) {_tcscpy(szTemp,g_szRegion);goto error;}
        if (!WriteCopy(hInf, g_szBrandBmp, bWriteShortName)) {_tcscpy(szTemp,g_szBrandBmp);goto error;}
        if (!WriteCopy(hInf, g_szPhoneBmp, bWriteShortName)) {_tcscpy(szTemp,g_szPhoneBmp);goto error;}
        if (!WriteCopy(hInf, g_szLargeIco, bWriteShortName)) {_tcscpy(szTemp,g_szLargeIco);goto error;}
        if (!WriteCopy(hInf, g_szSmallIco, bWriteShortName)) {_tcscpy(szTemp,g_szSmallIco);goto error;}
        if (!WriteCopy(hInf, g_szTrayIco, bWriteShortName)) {_tcscpy(szTemp,g_szTrayIco);goto error;}
        if (!WriteCopy(hInf, g_szHelp, bWriteShortName)) {_tcscpy(szTemp,g_szHelp);goto error;}
        if (!WriteCopy(hInf, g_szLicense, bWriteShortName)) {_tcscpy(szTemp,g_szLicense);goto error;}
        if (!WriteCopy(hInf, g_szCmProxyFile, bWriteShortName)) {_tcscpy(szTemp,g_szCmProxyFile);goto error;}
        if (!WriteCopy(hInf, g_szCmRouteFile, bWriteShortName)) {_tcscpy(szTemp,g_szCmRouteFile);goto error;}
        if (!WriteCopy(hInf, g_szVpnFile, bWriteShortName)) {_tcscpy(szTemp,g_szCmRouteFile);goto error;}

        if (g_bIncludeCmCode)
        {
            MYVERIFY(0 != LoadString(g_hInstance, IDS_READMETXT, szTemp, MAX_PATH));
            _tcscat(szTemp,TEXT("\r\n"));
            if (!WriteInf(hInf, szTemp)) {goto error;}
        }

        //
        // Write out tray icon command files
        //

        if (!WriteCopyMenuItemFiles(hInf, szTemp, bWriteShortName)) {goto error;}

        // Write out connect action command files
        if (!WriteCopyConActFiles(hInf,szTemp, bWriteShortName)) {goto error;}
        if (!WriteCopyExtraFiles(hInf,szTemp, bWriteShortName)) {goto error;}
        if (!WriteCopyDnsFiles(hInf,szTemp, bWriteShortName)) {goto error;}

        if (bWriteShortName)
        {
            MYVERIFY(FALSE != WriteShortRefsFiles(hInf, FALSE));
        }
        else
        {
            MYVERIFY(FALSE != WriteLongRefsFiles (hInf));
        }

        _tcscpy(szTemp,g_szShortServiceName);

        _tcscat(szTemp,TEXT(".cms,,,4\r\n")); // the 4 makes sure there is no version checking on the cms
        MYVERIFY(FALSE != WriteInf(hInf,szTemp));

        _tcscpy(szTemp,g_szShortServiceName);
        _tcscat(szTemp,TEXT(".inf\r\n"));
        MYVERIFY(FALSE != WriteInf(hInf,szTemp));

        MYVERIFY(FALSE != WriteInf(hInf,TEXT("\r\n")));
    }

    //
    //  End of quintinb fix for 323721
    //

    //WRITE OUT FILES TO COPY TO ICM DIRECTORY
    MYVERIFY(FALSE != WriteInf(hInf,TEXT("[Xnstall.CopyFiles.ICM]\r\n")));
    _tcscpy(szTemp,g_szShortServiceName);
    _tcscat(szTemp,TEXT(".cmp\r\n"));
    MYVERIFY(FALSE != WriteInf(hInf,szTemp));
    MYVERIFY(FALSE != WriteRefsFiles(hInf,TRUE));// doesn't do anything because no cmp files in HeadRef list, call just writes the CMP file under [Xnstall.CopyFiles.ICM]
    MYVERIFY(FALSE != WriteInf(hInf,TEXT("\r\n")));

    // WRITE OUT FILES TO DELETE FROM ROOT ICM DIRECTORY
    MYVERIFY(FALSE != WriteInf(hInf,TEXT("[Remove.DelFiles.ICM]\r\n")));
    _tcscpy(szTemp,g_szShortServiceName);
    _tcscat(szTemp,TEXT(".cmp\r\n"));
    MYVERIFY(FALSE != WriteInf(hInf,szTemp));
    MYVERIFY(FALSE != WriteRefsFiles(hInf,TRUE));// doesn't anything because no cmp files in HeadRef list, call just writes the CMP file under [Remove.DelFiles.ICM]


    // WRITE LIST OF ALL FILES IN PRODUCT
    MYVERIFY(FALSE != WriteInf(hInf,TEXT("\r\n")));
    MYVERIFY(FALSE != WriteInf(hInf,TEXT("[SourceDisksFiles]\r\n")));
    _tcscpy(szTemp,TEXT("%ShortSvcname%"));
    MYVERIFY(FALSE != WriteSrcInfLine(hInf,g_szPhonebk));
    MYVERIFY(FALSE != WriteSrcInfLine(hInf,g_szRegion));
    MYVERIFY(FALSE != WriteSrcInfLine(hInf,g_szBrandBmp));
    MYVERIFY(FALSE != WriteSrcInfLine(hInf,g_szPhoneBmp));
    MYVERIFY(FALSE != WriteSrcInfLine(hInf,g_szLargeIco));
    MYVERIFY(FALSE != WriteSrcInfLine(hInf,g_szSmallIco));
    MYVERIFY(FALSE != WriteSrcInfLine(hInf,g_szTrayIco));
    MYVERIFY(FALSE != WriteSrcInfLine(hInf,g_szHelp));
    MYVERIFY(FALSE != WriteSrcInfLine(hInf,g_szLicense));
    MYVERIFY(FALSE != WriteSrcInfLine(hInf,g_szCmProxyFile));
    MYVERIFY(FALSE != WriteSrcInfLine(hInf,g_szCmRouteFile));
    MYVERIFY(FALSE != WriteSrcInfLine(hInf,g_szVpnFile));    

    _tcscpy(szTemp,g_szShortServiceName);
    _tcscat(szTemp,TEXT(".inf = 55\r\n"));
    MYVERIFY(FALSE != WriteInf(hInf,szTemp));

    _tcscpy(szTemp,g_szShortServiceName);
    _tcscat(szTemp,TEXT(".cmp = 55\r\n"));
    MYVERIFY(FALSE != WriteInf(hInf,szTemp));
    
    _tcscpy(szTemp,g_szShortServiceName);
    _tcscat(szTemp,TEXT(".cms = 55\r\n"));
    MYVERIFY(FALSE != WriteInf(hInf,szTemp));

    WriteSrcMenuItemFiles(hInf);
    WriteSrcConActFiles(hInf);
    WriteSrcExtraFiles(hInf);
    MYVERIFY(FALSE != WriteSrcRefsFiles(hInf)); // This call writes out the refs files to [Remove.DelFiles]
    WriteSrcDnsFiles(hInf);
    WriteRenameSection(hInf);

    MYVERIFY(FALSE != WriteInf(hInf,TEXT("\r\n")));
    MYVERIFY(FALSE != WriteInf(hInf,TEXT("[Remove.DelFiles]\r\n")));
    
    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s.cms\r\n"), g_szShortServiceName));
    MYVERIFY(FALSE != WriteInf(hInf,szTemp));

    if (g_bIncludeCmCode)
    {
        MYVERIFY(0 != LoadString(g_hInstance, IDS_READMETXT, szTemp, MAX_PATH));
        _tcscat(szTemp,TEXT("\r\n"));
        MYVERIFY(0 != WriteInf(hInf,szTemp));
    }

    MYVERIFY(FALSE != WriteInfLine(hInf,g_szPhonebk));
    MYVERIFY(FALSE != WriteInfLine(hInf,g_szRegion));
    MYVERIFY(FALSE != WriteInfLine(hInf,g_szBrandBmp));
    MYVERIFY(FALSE != WriteInfLine(hInf,g_szPhoneBmp));
    MYVERIFY(FALSE != WriteInfLine(hInf,g_szLargeIco));
    MYVERIFY(FALSE != WriteInfLine(hInf,g_szSmallIco));
    MYVERIFY(FALSE != WriteInfLine(hInf,g_szTrayIco));
    MYVERIFY(FALSE != WriteInfLine(hInf,g_szHelp));
    MYVERIFY(FALSE != WriteInfLine(hInf,g_szLicense));
    MYVERIFY(FALSE != WriteInfLine(hInf,g_szCmProxyFile));
    MYVERIFY(FALSE != WriteInfLine(hInf,g_szCmRouteFile));
    MYVERIFY(FALSE != WriteInfLine(hInf,g_szVpnFile));    

    WriteDelMenuItemFiles(hInf);
    WriteDelConActFiles(hInf);
    WriteDelExtraFiles(hInf);
    MYVERIFY(FALSE != WriteRefsFiles(hInf,FALSE));
    WriteDelDnsFiles(hInf);
    WriteEraseLongName(hInf);
    MYVERIFY(FALSE != WriteInf(hInf,TEXT("\r\n")));

    MYVERIFY(0 != CloseHandle(hInf));
    
    MYVERIFY(0 != SetCurrentDirectory(g_szCmakdir));

    return (TRUE);
error:
    {
        //FileAccessErr(hDlg,szTemp);
        MYVERIFY(0 != CloseHandle(hInf));
        return (FALSE); 
    }
}

void EraseSEDFiles(LPCTSTR szSed)
{
    int i = 0;

    TCHAR szTemp[MAX_PATH+1];
    TCHAR szFileNum[MAX_PATH+1];
    TCHAR szSourceFilesSection[MAX_PATH+1];

    _tcscpy(szSourceFilesSection, TEXT("SourceFiles0"));

    do 
    {
        MYVERIFY(CELEMS(szFileNum) > (UINT)wsprintf(szFileNum, TEXT("FILE%d"), i));

        //
        //  The following call to GetPrivateProfileString could return an empty string, thus don't
        //  use the MYVERIFY macro on it.
        //

        GetPrivateProfileString(c_pszInfSectionStrings, szFileNum, TEXT(""), szTemp, 
            MAX_PATH, szSed);   //lint !e534
        
        if (*szTemp)
        {
            MYVERIFY(0 != WritePrivateProfileString(c_pszInfSectionStrings, szFileNum, NULL, szSed));
            MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%%%s%%"), szFileNum));
            MYVERIFY(0 != WritePrivateProfileString(szSourceFilesSection, szTemp, NULL, szSed));
        }
        else
        {
            break;
        }

        ++i;    // increment the file number
    }
    while(*szTemp);

    //
    //  Erase the finish message key from the Sed.  This will avoid double finish messages
    //  (since cmstp is now supposed to take care of finish message but older profiles had
    //  the message from here).
    //

    MYVERIFY(0 != WritePrivateProfileString(c_pszOptions, TEXT("FinishMessage"), TEXT(""), szSed));

    //
    //  Write out the word <None> into the post install command so that showicon isn't a problem
    //  on an upgrade.
    //
    MYVERIFY(0 != WritePrivateProfileString(c_pszInfSectionStrings, TEXT("PostInstallCmd"), TEXT("<None>"), szSed));

    //
    //  By calling WritePrivateProfileString with all NULL's we flush the file cache 
    //  (win95 only).  This call will return 0.
    //

    WritePrivateProfileString(NULL, NULL, NULL, szSed); //lint !e534 this call will always return 0

}

//+----------------------------------------------------------------------------
//
// Function:  WriteSED
//
// Synopsis:  This function takes a fullpath to a file and the current file
//            number entry to write it to and writes the file entry in the SED
//            passed in.  Before writing the entry, the functions enumerates all
//            other files in the sed to check for duplicates.  If it finds a
//            file with the sme filename, it will not write the entry because
//            since we are using a flat directory structure two files of the same
//            name will overwrite each other anyway.  Note that if the file is
//            written, *pFileNum is incremented.
//
// Arguments: HWND hDlg - Window handle for FileAccessErr Messages
//            LPTSTR szFullFilePath - Full path of the file to write
//            LPINT pFileNum - Current File entry number
//            LPCTSTR szSed - Full path to the sed file to write the entry to
//
// Returns:   Nothing
//
// History:   quintinb  Created Header, Removed UseLangDir, Changed to take a full path,
//                      and generally cleaned up.    8/7/98
//
//+----------------------------------------------------------------------------
BOOL WriteSED(HWND hDlg, LPTSTR szFullFilePath, LPINT pFileNum, LPCTSTR szSed)
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szFileName[MAX_PATH+1];
    TCHAR szFileNumber[MAX_PATH+1];

    if (TEXT('\0') != szFullFilePath[0])
    {

        //
        //  First Check to see if the file exists.  If we write a file in the SED that
        //  IExpress can't find, then it will throw an error.  We should definitely try
        //  to throw an error earlier and try to give the user a chance to fix it.
        //
        if (!FileExists(szFullFilePath))
        {
            CFileNameParts FileParts(szFullFilePath);
            if ((TEXT('\0') == FileParts.m_Drive[0]) && 
                (TEXT('\0') == FileParts.m_Dir[0]) &&
                (TEXT('\0') != FileParts.m_FileName[0]) &&
                (TEXT('\0') != FileParts.m_Extension[0]))
            {
                //
                //  The user only passed in the filename and extension.  Lets look in
                //  the profile directory.  If it isn't here then throw an error.
                //
                MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s%s\\%s%s"), 
                    g_szOsdir, g_szShortServiceName, FileParts.m_FileName, FileParts.m_Extension));
                if (!FileExists(szTemp))
                {
                    FileAccessErr(hDlg, szFullFilePath);
                    return FALSE;
                }
                else
                {
                    MYVERIFY(CELEMS(szFullFilePath) > (UINT)wsprintf(szFullFilePath, szTemp));
                }
            }
            else
            {
                FileAccessErr(hDlg, szFullFilePath);
                return FALSE;
            }
        }

        //
        //  Get just the file name from the full path.  We use this
        //  later to determine if the file already exists in the SED
        //  file.
        //
        GetFileName(szFullFilePath, szFileName);

        //
        //  Construct the next FileNumber Entry
        //
        MYVERIFY(CELEMS(szFileNumber) > (UINT)wsprintf(szFileNumber, TEXT("FILE%d"), *pFileNum));

        //
        //  Check to make sure that we already don't have the file in the cab.  If
        //  so then just ignore the entry.
        //
        for (int i=0; i<*pFileNum; ++i)
        {
            //
            //  Write the FILEX entry into a string to read in the file name for the
            //  current i.
            //
            MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("FILE%d"), i));
            
            TCHAR szTempFileName[MAX_PATH+1];

            GetPrivateProfileString(c_pszInfSectionStrings, szTemp, 
                TEXT(""), szTempFileName, CELEMS(szTempFileName), szSed);   //lint !e534

            if (TEXT('\0') != szTempFileName[0])
            {
                //
                //  Get the filenames of both files since we are using a flat directory space.
                //  Two files of the same name will collide anyway.
                //
                GetFileName(szTempFileName, szTemp);
                if (0 == _tcsicmp(szTemp, szFileName))
                {
                    //
                    //  don't add it because it already exists
                    //
                    CMASSERTMSG(0 == _tcsicmp(szFullFilePath, szTempFileName), TEXT("WriteSed -- We have two files that have the same FileName but different paths."));
                    return TRUE;
                }
            }
        }

        MYVERIFY(0 != WritePrivateProfileString(c_pszInfSectionStrings, 
            szFileNumber, szFullFilePath, szSed));

        *pFileNum = (*pFileNum) + 1;

        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%%%s%%"), szFileNumber));

        MYVERIFY(0 != WritePrivateProfileString(TEXT("SourceFiles0"), szTemp, TEXT(""), szSed));
    }

    return TRUE;
}

//+----------------------------------------------------------------------------
//
// Function:  WriteCMPFile
//
// Synopsis:  This function is a wrapper file to write out the version to the CMP.
//
// Arguments: None
//
// History:   nickball      Created Header    07/22/98
//
//+----------------------------------------------------------------------------
void WriteCMPFile()
{
    TCHAR szTemp[MAX_PATH+1];
    
    //
    //  Ensure that the version number is up to date in the .CMP
    //

    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%d"), PROFILEVERSION));
    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionProfileFormat, c_pszVersion, szTemp, g_szCmpFile));

    //
    //  Write the CMS entry to the CMP File
    //

    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s.cms"), g_szShortServiceName, g_szShortServiceName));

    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryCmsFile, szTemp, g_szCmpFile));
}

//+----------------------------------------------------------------------------
//
// Function:  WriteOutRelativeFilePathOrNull
//
// Synopsis:  This helper routine was written to shorten WriteCMSFile().  It tests
//            to see if the inputted pszFile parameter is an empty string.  If it
//            is then it writes an empty string to the File entry specified by
//            pszSection, pszEntryName, and pszFileToWriteTo.  Otherwise it concats
//            just the file name from pszFile with the parameter specified in
//            pszShortName, seperating them with a '\' character.  This is useful
//            for CMS parameters that are either empty or a relative path from the
//            cmp file location.
//
// Arguments: LPCTSTR pszFile - file entry to write
//            LPCTSTR pszShortName - shortname of the profile
//            LPCTSTR pszSection - string name of the section string
//            LPCTSTR pszEntryName - string name of the entry name string
//            LPCTSTR pszFileToWriteTo - full path of the file to write the entry to
//
// Returns:   Nothing
//
// History:   quintinb Created    8/8/98
//
//+----------------------------------------------------------------------------
void WriteOutRelativeFilePathOrNull(LPCTSTR pszFile, LPCTSTR pszShortName, LPCTSTR pszSection, LPCTSTR pszEntryName, LPCTSTR pszFileToWriteTo)
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szName[MAX_PATH+1];

    //
    //  Check Inputs
    //
    if ((NULL == pszFile) ||
        (NULL == pszShortName) || (TEXT('\0') == pszShortName[0]) ||
        (NULL == pszFileToWriteTo) || (TEXT('\0') == pszFileToWriteTo[0]) ||
        (NULL == pszSection) || (TEXT('\0') == pszSection[0]) ||
        (NULL == pszEntryName) || (TEXT('\0') == pszEntryName[0]))
    {
        CMASSERTMSG(FALSE, TEXT("WriteoutRelativeFilePathOrNull -- Bad Parameter"));
        return;
    }

    if (TEXT('\0') != pszFile[0])
    {
        GetFileName(pszFile, szName);
        
        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s"), 
            pszShortName, szName));
    }
    else
    {
        szTemp[0] = TEXT('\0');        
    }

    MYVERIFY(0 != WritePrivateProfileString(pszSection, pszEntryName, szTemp, pszFileToWriteTo));
}


//+----------------------------------------------------------------------------
//
// Function:  WriteCMSFile
//
// Synopsis:  This function is a wrapper file to write out the CMS file.  Note
//            that the cms is modified throughout CMAK, but this should be the
//            last place where it is modified.
//
// Arguments: None
//
// History:   quintinb Created Header    12/4/97
//
//+----------------------------------------------------------------------------
BOOL WriteCMSFile()
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szName[MAX_PATH+1];

    //
    //  Ensure that the Profile Format version number is up to date
    //

    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%d"), PROFILEVERSION));
    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionProfileFormat, c_pszVersion, szTemp, g_szCmsFile));

    //
    // erase name of phone book to be loaded if not doing download.
    //
    if (!g_bUpdatePhonebook)
    {
        g_szPhoneName[0] = TEXT('\0');
    }

    //
    //  Write out the Phonebook Name
    //

    if (TEXT('\0') != g_szPhonebk[0])
    {
        GetFileName(g_szPhonebk, szName);
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszVersion, c_pszOne, 
            g_szCmsFile));
    }
    else
    {   
        //
        // if no phone number, then set version to zero
        //
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszVersion, c_pszZero,
            g_szCmsFile));
        
        if (TEXT('\0') != g_szPhoneName[0])
        {
            MYVERIFY(CELEMS(szName) > (UINT)wsprintf(szName, TEXT("%s.pbk"), g_szPhoneName));
        }
        else
        {
            //
            // no phone book entered or set for download
            //
            szName[0] = TEXT('\0');
        }
    }

    WriteOutRelativeFilePathOrNull(szName, g_szShortServiceName, c_pszCmSectionIsp, 
        c_pszCmEntryIspPbFile, g_szCmsFile);

    //
    //  Write out the Phonebook Name
    //

    if (TEXT('\0') != g_szRegion[0])
    {
        GetFileName(g_szRegion, szName);
    }
    else
    {
        if (TEXT('\0') != g_szPhoneName[0])
        {
            MYVERIFY(CELEMS(szName) > (UINT)wsprintf(szName, TEXT("%s.pbr"), g_szPhoneName));
        }
        else
        {
            szName[0] = TEXT('\0');
        }
    }

    WriteOutRelativeFilePathOrNull(szName, g_szShortServiceName, c_pszCmSectionIsp, 
        c_pszCmEntryIspRegionFile, g_szCmsFile);

    //
    //  Write out the Large Icon
    //
    WriteOutRelativeFilePathOrNull(g_szLargeIco, g_szShortServiceName, c_pszCmSection, 
        c_pszCmEntryBigIcon, g_szCmsFile);

    //
    //  Write out the Small Icon
    //
    WriteOutRelativeFilePathOrNull(g_szSmallIco, g_szShortServiceName, c_pszCmSection, 
        c_pszCmEntrySmallIcon, g_szCmsFile);

    //
    //  Write out the Tray Icon
    //
    WriteOutRelativeFilePathOrNull(g_szTrayIco, g_szShortServiceName, c_pszCmSection, 
        c_pszCmEntryTrayIcon, g_szCmsFile);
    
    //
    //  Write out the custom help file
    //
    WriteOutRelativeFilePathOrNull(g_szHelp, g_szShortServiceName, c_pszCmSection, 
        c_pszCmEntryHelpFile, g_szCmsFile);

    //
    //  Write out the License File to the INF, thus we can easily redisplay
    //  it if they edit the profile again.  (basically stash the license file
    //  name in the CMAK Status section of the inf)
    //
    WriteOutRelativeFilePathOrNull(g_szLicense, g_szShortServiceName, c_pszCmakStatus, 
        c_pszLicenseFile, g_szInfFile);

    //
    //  Write out the Main Screen Bitmap
    //
    WriteOutRelativeFilePathOrNull(g_szBrandBmp, g_szShortServiceName, c_pszCmSection, 
        c_pszCmEntryLogo, g_szCmsFile);
    
    //
    //  Write out the Phone Bitmap
    //
    WriteOutRelativeFilePathOrNull(g_szPhoneBmp, g_szShortServiceName, c_pszCmSection, 
        c_pszCmEntryPbLogo, g_szCmsFile);

    //
    //  Write the HideDomain flag
    //

    GetPrivateProfileString(c_pszCmSection, c_pszCmEntryHideDomain, TEXT(""), 
        szTemp, MAX_PATH, g_szCmsFile);   //lint !e534
    
    //
    //  If using tunneling and the HideDomain entry doesn't previously exist, then write
    //  zero for the entry.  Otherwise nothing should be written for this entry.
    //
    if (!(_tcscmp(TEXT(""), szTemp) ) && g_bUseTunneling)
    {
        //
        //  Don't want to overwrite a 1 if it exists.
        //
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryHideDomain, 
            c_pszZero, g_szCmsFile));
    }

    //
    //  If we aren't tunneling, make sure to delete the tunnel settings
    //
    if (FALSE == g_bUseTunneling)
    {
        //
        //  First delete all of the Tunnel DUN Settings
        //
        ListBxList * pCurrent = g_pHeadVpnEntry;

        while (NULL != pCurrent)
        {
            EraseNetworkingSections(pCurrent->szName, g_szCmsFile);
            pCurrent = pCurrent->next;
        }

        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryTunnelDun, NULL, g_szCmsFile));
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryTunnelAddress, NULL, g_szCmsFile));
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryTunnelFile, NULL, g_szCmsFile));
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryUseSameUserName, NULL, g_szCmsFile));
    }
    
    //
    //  Write out the rest of the CMS entries (service name, support message, etc.)
    //
    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryServiceName, 
        g_szLongServiceName,g_szCmsFile));
    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryServiceMessage, 
        g_szSvcMsg, g_szCmsFile));
    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryUserPrefix, 
        g_szPrefix, g_szCmsFile));
    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryUserSuffix, 
        g_szSuffix, g_szCmsFile));

    //
    //  Set the name of the default Dun setting
    //
    MYVERIFY(0 != GetDefaultDunSettingName(g_szCmsFile, g_szLongServiceName, szTemp, CELEMS(szTemp)));

    MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryDun, szTemp, g_szCmsFile));

    //
    //  Write out the custom actions, make sure to set the bUseTunneling flag with the actual
    //  value to erase the PreTunnel section and set all of the flag values to zero if necessary
    //  (if for instance the user editted a tunneling profile and decided to make it non-Tunneling).
    //
    MYDBGASSERT(g_pCustomActionList);
    if (g_pCustomActionList)
    {
        HRESULT hr = g_pCustomActionList->WriteCustomActionsToCms(g_szCmsFile, g_szShortServiceName, g_bUseTunneling);
        CMASSERTMSG(SUCCEEDED(hr), TEXT("ProcessCustomActions -- Failed to write out connect actions"));
    }

    //
    //  Delete mbslgn32.dll special handling in the INF, it is no longer supported.
    //
    MYVERIFY(0 != WritePrivateProfileString(c_pszCmakStatus, c_pszUsePwdCache, NULL, g_szInfFile));

    if (g_bUpdatePhonebook)
    {
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmakStatus, c_pszUpdatePhonebook, c_pszOne, g_szInfFile));
    }
    else
    {
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmakStatus, c_pszUpdatePhonebook, c_pszZero, g_szInfFile));
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmakStatus, c_pszPhoneName, TEXT(""), g_szInfFile));
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSectionIsp, c_pszCmEntryIspUrl, TEXT(""), g_szCmsFile));
    }

    //
    //  By calling WritePrivateProfileString with all NULL's we flush the file cache 
    //  (win95 only).  This call will return 0.
    //

    WritePrivateProfileString(NULL, NULL, NULL, g_szCmpFile); //lint !e534 this call will always return 0

    return TRUE;
}


//+----------------------------------------------------------------------------
//
// Function:  IncludeOptionalCode
//
// Synopsis:  This function writes the flags to CMAK to tell the profile installer
//            whether or not CM bits and Support dll's should be installed.
//
// Arguments: None
//
// Returns:   Nothing
//
// History:   quintinb Created Header and rewrote    5/23/98
//            quintinb NTRAID 162321, CM bits should not be installed on NT5 - 5/23/98
//            quintinb NTRAID 192500, Support Dll's now always included with CM bits - 9-2-98
//            quintinb we no longer ship the support dlls, removed support for them 4-19-2001
//
//+----------------------------------------------------------------------------
void IncludeOptionalCode()
{
    if (g_bIncludeCmCode)
    {
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmakStatus, c_pszIncludeCmCode, c_pszOne, g_szInfFile));
    }
    else
    {
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmakStatus, c_pszIncludeCmCode, c_pszZero, g_szInfFile));
    }

    //
    //  We no longer ship the support files, erase the entry from the inf  
    //
    MYVERIFY(0 != WritePrivateProfileString(c_pszCmakStatus, c_pszIncludeSupportDll, NULL, g_szInfFile));
}





//+----------------------------------------------------------------------------
//
// Function:  HandleWindowMessagesWhileCompressing
//
// Synopsis:  This function pumps messages while iexpress is running.
//
// Arguments: None
//
// Returns:   Nothing
//
// History:   quintinb Created      7/29/98
//
//+----------------------------------------------------------------------------
void HandleWindowMessagesWhileCompressing()
{
    MSG msg;

    while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);//lint !e534 ignore dispatchmessage return values
    }
}

//+----------------------------------------------------------------------------
//
// Function:  DisableWizardButtons
//
// Synopsis:  This function disables the four wizard buttons at the bottom
//            of the wizard page.  Since these buttons aren't really ours we
//            need to get the window handle of the parent dialog and then get
//            the window handle of the individual button controls that we want to
//            disable (Help, Cancel, Back, and Finish/Next).  When we have the
//            window handle of each button we call EnableWindow on the button
//            to disable it.  This function also disables the geek pane controls
//            and the advanced checkbox on the build profile page if they exist.
//
// Arguments: HWND hDlg - Wizard page window handle (handle to our template page)
//
// Returns:   Nothing
//
// History:   quintinb Created     7/29/98
//
//+----------------------------------------------------------------------------
void DisableWizardButtons(HWND hDlg)
{
    #define IDBACK 12323
    #define IDNEXT 12324
    #define IDFINISH 12325

    HWND hCurrentPage = GetParent(hDlg);
    if (hCurrentPage)
    {   
        const int c_NumButtons = 5;
        int iArrayOfButtonsToDisable[c_NumButtons] = {IDCANCEL, IDHELP, IDBACK, IDNEXT, IDFINISH};
        //
        //  Disable the Cancel Button
        //
        for (int i = 0; i < c_NumButtons; i++)
        {
            HWND hButton = GetDlgItem(hCurrentPage, iArrayOfButtonsToDisable[i]);

            if (hButton)
            {
                EnableWindow(hButton, FALSE);
            }
        }
    }

    //
    //  Disable the advanced button and the geek pane controls if they exist.
    //
    int iArrayOfItemsToDisable[] = {IDC_ADVANCED, IDC_COMBO1, IDC_COMBO2, IDC_COMBO3, IDC_EDIT1, IDC_BUTTON1};
    const int c_NumItems = CELEMS(iArrayOfItemsToDisable);

    for (int i = 0; i < c_NumItems; i++)
    {
        HWND hControl = GetDlgItem(hDlg, iArrayOfItemsToDisable[i]);

        if (hControl)
        {
            EnableWindow(hControl, FALSE);
        }
    }
}

//+----------------------------------------------------------------------------
//
// Function:  WriteInfBeginAndEndPrompts
//
// Synopsis:  This function writes the Begin and End Prompt strings to the
//            inf file.  These are written dynamically because they need to
//            contain the Service Name.
//
// Arguments: HINSTANCE hInstance - Instance Handle to get string resources with
//            LPTSTR szInf - Inf file to write the prompts too
//            LPTSTR szServiceName - Long Service name of the profile
//
// Returns:   Nothing
//
// History:   Created Header    7/31/98
//
//+----------------------------------------------------------------------------
void WriteInfBeginAndEndPrompts(HINSTANCE hInstance, LPCTSTR szInf, LPCTSTR szServiceName)
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szPrompt[MAX_PATH+1];

    MYVERIFY(0 != LoadString(hInstance, IDS_BeginPromptText, szTemp, MAX_PATH));
    MYDBGASSERT(TEXT('\0') != szTemp[0]);

    MYVERIFY(CELEMS(szPrompt) > (UINT)wsprintf(szPrompt, szTemp, szServiceName));
    QS_WritePrivateProfileString(c_pszInfSectionStrings, c_pszInfBeginPrompt, szPrompt, szInf);
    

    MYVERIFY(0 != LoadString(hInstance, IDS_EndPromptText, szTemp, MAX_PATH));
    MYDBGASSERT(TEXT('\0') != szTemp[0]);

    MYVERIFY(CELEMS(szPrompt) > (UINT)wsprintf(szPrompt, szTemp, szServiceName));
    QS_WritePrivateProfileString(c_pszInfSectionStrings, c_pszInfEndPrompt, szPrompt, szInf);
}



//+----------------------------------------------------------------------------
//
// Function:  WriteInfFile
//
// Synopsis:  This function encapsulates all the code needed to write an inf file.
//
// Arguments: HINSTANCE hInstance - Instance handle to get string resources from
//            LPCTSTR szInf - Name of the Inf to write to
//            LPCTSTR szLongServiceName - Long Service Name of the Profile
//
// Returns:   BOOL - returns TRUE if succeeded
//
// History:   quintinb  created   8/10/98
//
//+----------------------------------------------------------------------------
BOOL WriteInfFile(HINSTANCE hInstance, HWND hDlg, LPCTSTR szInf, LPCTSTR szLongServiceName)
{
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szMsg[MAX_PATH+1];

    GUID vGUID;

    //
    //  Write out the version number of cmdial32.dll to the INF.  This tells the installer
    //  what version of cmdial32.dll that this profile was built to use.  We do this
    //  because if CM bits aren't bundled then we don't have cmdial32.dll to directly compare
    //  with.  Note that we now get the version of cmdial32.dll from the cm binaries cab, not
    //  the version in system32.
    //
#ifdef _WIN64
    CmVersion CmdialVersion;
#else
    wsprintf(szTemp, TEXT("%s\\cmdial32.dll"), g_szCmBinsTempDir);

    if (!FileExists(szTemp))
    {
        if (FAILED(ExtractCmBinsFromExe(g_szSupportDir, g_szCmBinsTempDir)))
        {
            CMASSERTMSG(FALSE, TEXT("WriteInfFile -- ExtractCmBinsFromExe Failed."));
            return FALSE;
        }
    }

    CVersion CmdialVersion(szTemp);
#endif

    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%d"), CmdialVersion.GetVersionNumber()));
    MYVERIFY(0 != WritePrivateProfileString(c_pszSectionCmDial32, c_pszVersion, szTemp, szInf));

    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%d"), CmdialVersion.GetBuildAndQfeNumber()));
    MYVERIFY(0 != WritePrivateProfileString(c_pszSectionCmDial32, c_pszVerBuild, szTemp, szInf));

    //
    //  Create a Desktop GUID if one doesn't already exist (a new profile instead of
    //  an editted one).
    //

    ZeroMemory(szTemp, sizeof(szTemp));
    GetPrivateProfileString(c_pszInfSectionStrings, c_pszDesktopGuid, 
        TEXT(""), szTemp, CELEMS(szTemp), szInf);   //lint !e534
    
    if (TEXT('\0') == szTemp[0])
    {
        MYVERIFY(S_OK == CoCreateGuid(&vGUID));
        MYVERIFY(0 != StringFromGUID2(vGUID, szTemp, MAX_PATH));

        QS_WritePrivateProfileString(c_pszInfSectionStrings, c_pszDesktopGuid, 
            szTemp, szInf);
    }

    //
    //  Write out the Display LCID of the profile
    //
    wsprintf(szTemp, TEXT("%d"), GetSystemDefaultLCID());
    MYVERIFY(0 != WritePrivateProfileString(c_pszInfSectionStrings, c_pszDisplayLCID, szTemp, szInf));

    //
    // Erase the existing File sections
    //
    MYVERIFY(0 != WritePrivateProfileString(TEXT("Xnstall.CopyFiles"), NULL, NULL, szInf));
    MYVERIFY(0 != WritePrivateProfileString(TEXT("Xnstall.CopyFiles.SingleUser"), NULL, NULL, szInf));
    MYVERIFY(0 != WritePrivateProfileString(TEXT("Xnstall.CopyFiles.ICM"),NULL, NULL, szInf));
    MYVERIFY(0 != WritePrivateProfileString(TEXT("Remove.DelFiles"),NULL, NULL, szInf));
    MYVERIFY(0 != WritePrivateProfileString(TEXT("Remove.DelFiles.ICM"),NULL, NULL, szInf));
    MYVERIFY(0 != WritePrivateProfileString(TEXT("SourceDisksFiles"),NULL, NULL, szInf));
    MYVERIFY(0 != WritePrivateProfileString(TEXT("Xnstall.AddReg.Icon"),NULL, NULL, szInf));
    MYVERIFY(0 != WritePrivateProfileString(TEXT("RegisterOCXSection"),NULL, NULL, szInf));
    MYVERIFY(0 != WritePrivateProfileString(TEXT("Xnstall.RenameReg"),NULL, NULL, szInf));

    if (!CreateMergedProfile())
    {
        return FALSE;
    }

    IncludeOptionalCode();

    //
    //  By calling WritePrivateProfileString with all NULL's we flush the file cache 
    //  (win95 only).  This call will return 0.
    //

    WritePrivateProfileString(NULL, NULL, NULL, szInf); //lint !e534 this call will always return 0

    //
    // Add the dynamic file sections to the install
    //
    if (WriteFileSections(hDlg) == FALSE)
    {
        return FALSE;
    }

    //
    //  Write the Begin and End Prompts
    //
    WriteInfBeginAndEndPrompts(hInstance, szInf, szLongServiceName);

    return TRUE;
}



//+----------------------------------------------------------------------------
//
// Function:  ConCatPathAndWriteToSed
//
// Synopsis:  This function is a wrapper for WriteSed that concats two paths
//            together before calling WriteSed.  This allows the caller to
//            store a common path (such as the system directory) and call
//            WriteSed with a bunch of different files all in the same directory
//            without having to individually concatenate the common path and the
//            filenames.
//
// Arguments: HWND hDlg - windows handle of the current dialog, needed for error messages
//            LPCTSTR pszFileName - Name of the file
//            LPCTSTR pszPath - Name of the path to prepend to the filename
//            int* pFileNum - the number of the file in the SED file
//            LPCTSTR szSed - the SED file to write to
//
// Returns:   BOOL - Returns TRUE if succeeded
//
// History:   quintinb Created    8/10/98
//
//+----------------------------------------------------------------------------
BOOL ConCatPathAndWriteToSed(HWND hDlg, LPCTSTR pszFileName, LPCTSTR pszPath, 
                             int* pFileNum, LPCTSTR szSed)
{
    TCHAR szTemp[MAX_PATH+1];

    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s\\%s"), pszPath, pszFileName));
    return WriteSED(hDlg, szTemp, pFileNum, szSed);
}




//+----------------------------------------------------------------------------
//
// Function:  ConstructSedFile
//
// Synopsis:  This function encapsulates all the work of creating an SED file.
//
// Arguments: HWND hDlg - window handle of the current dialog for error messages
//            LPCTSTR szSed - filename of the sed file to write
//            LPCTSTR szExe - executable filename for the SED to compress to
//
// Returns:   BOOL - Returns TRUE if successful
//
// History:   quintinb  Created     8/10/98
//
//+----------------------------------------------------------------------------
BOOL ConstructSedFile(HWND hDlg, LPCTSTR szSed, LPCTSTR szExe)
{
    int iFileNum=0;
    TCHAR szTemp[MAX_PATH+1];
    BOOL bReturn = TRUE;
    CPlatform cmplat;

    // 
    // Clear the SED and begin writing new settings
    // 

    EraseSEDFiles(szSed);

    //
    //  Write the Installer Package Exe Name
    //
    MYVERIFY(0 != WritePrivateProfileString(c_pszInfSectionStrings, 
        c_pszTargetName, szExe, szSed));


    //
    //  Write the Long Service Name as the FriendlyName
    //
    if (!WritePrivateProfileString(c_pszInfSectionStrings, c_pszFriendlyName, 
        g_szLongServiceName, szSed))
    {
        FileAccessErr(hDlg, szSed);
        return FALSE;
    }
    

    //
    // Load up IDS_INSTALL_PROMPT from the resources
    // Format the string using the g_szLongServiceName
    //
    LPTSTR pszInstallPromptTmp = CmFmtMsg(g_hInstance, IDS_INSTALL_PROMPT, g_szLongServiceName);

    if (pszInstallPromptTmp)
    {
        //
        // Write the Install Prompt string
        //
        if (!WritePrivateProfileString(c_pszInfSectionStrings, c_pszInstallPrompt, 
            pszInstallPromptTmp, szSed))
        {
            FileAccessErr(hDlg, szSed);
            return FALSE;
        }
   
        CmFree(pszInstallPromptTmp);
        pszInstallPromptTmp = NULL;
    }
    else
    {
        CMASSERTMSG(FALSE, TEXT("ConstructSedFile -- CmFmtMsg returned NULL."));
        FileAccessErr(hDlg, szSed);
        return FALSE;
    }



    //
    //  Clear the Target File Version Key
    //
    MYVERIFY(0 != WritePrivateProfileString(c_pszOptions, c_pszTargetFileVersion, 
        TEXT(""), szSed));
    
    //
    //  Set the Reboot Mode
    //
    MYVERIFY(0 != WritePrivateProfileString(c_pszOptions, TEXT("RebootMode"), TEXT("N"), 
        g_szSedFile));


    //
    //  Write the License text file into the SED.  Otherwise make sure to clear it.
    //
    
    if (TEXT('\0') != g_szLicense[0])
    {
        //
        //  We write the license text file into the SED in two places.  Once as a regular
        //  file and again using the c_pszDisplayLicense entry.  Thus we copy it to the 
        //  users profile dir and display it at install time.  We want to make sure that
        //  we use the full file name in the SED files section, but the short file name
        //  in the part of the SED that actually lauches the license at install time 
        /// (aka the strings section).
        //

        TCHAR szTempName[MAX_PATH+1];
        MYVERIFY (FALSE != GetShortFileName(g_szLicense, szTempName));

        MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s%s\\%s"), g_szOsdir, 
            g_szShortServiceName, szTempName));

        bReturn &= WriteSED(hDlg, g_szLicense, &iFileNum, szSed);
    }
    else
    {
        szTemp[0] = TEXT('\0');
    }

    MYVERIFY(0 != WritePrivateProfileString(c_pszInfSectionStrings, c_pszDisplayLicense, 
        szTemp, szSed));


    //
    //  Add the install command to the SED file
    //
    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT(".\\cmstp.exe %s.inf"), g_szShortServiceName));
    MYVERIFY(0 != WritePrivateProfileString(c_pszInfSectionStrings, c_pszAppLaunched, 
        szTemp, szSed));


    //
    //  Get the System Directory path to concat to IEXPRESS and CM Files
    //
    TCHAR szSystemDir[MAX_PATH+1];
    MYVERIFY(0 != GetSystemDirectory(szSystemDir, MAX_PATH));

    //
    //  Begin Adding Files to the SED File.  Note that all 32-bit profiles
    //  must include IExpress file(s)
    //
    
    bReturn &= ConCatPathAndWriteToSed(hDlg, TEXT("advpack.dll"), szSystemDir, &iFileNum, szSed);

#ifndef _WIN64
    bReturn &= ConCatPathAndWriteToSed(hDlg, TEXT("w95inf16.dll"), g_szSupportDir, &iFileNum, szSed);
    bReturn &= ConCatPathAndWriteToSed(hDlg, TEXT("w95inf32.dll"), g_szSupportDir, &iFileNum, szSed);

    //
    //  Always include cmstp.exe.  Note that on x86 it comes from the binaries CAB.
    //
    bReturn &= ConCatPathAndWriteToSed(hDlg, TEXT("cmstp.exe"), g_szCmBinsTempDir, &iFileNum, szSed);
#else

    //
    //  Always include cmstp.exe.  Note that on IA64 we get it from the system directory.
    //
    bReturn &= ConCatPathAndWriteToSed(hDlg, TEXT("cmstp.exe"), szSystemDir, &iFileNum, szSed);
#endif
    
    if (g_bIncludeCmCode)
    {
        //
        //  Readme.txt is a special case since it is a localizable filename.
        //
        MYVERIFY(0 != LoadString(g_hInstance, IDS_READMETXT, szTemp, MAX_PATH));
        bReturn &= ConCatPathAndWriteToSed(hDlg, szTemp, g_szSupportDir, &iFileNum, szSed);    
        bReturn &= ConCatPathAndWriteToSed(hDlg, TEXT("instcm.inf"), g_szSupportDir, &iFileNum, szSed);    
        bReturn &= ConCatPathAndWriteToSed(hDlg, TEXT("cmbins.exe"), g_szSupportDir, &iFileNum, szSed);    

#ifndef _WIN64

        if (!(IsAlpha()))
        {
            //
            //  Add the win95 config files
            //
            bReturn &= ConCatPathAndWriteToSed(hDlg, TEXT("ccfg95.dll"), g_szSupportDir, &iFileNum, szSed);    
            bReturn &= ConCatPathAndWriteToSed(hDlg, TEXT("cnet16.dll"), g_szSupportDir, &iFileNum, szSed);

            //
            //  Add the Unicode to Ansi Conversion layer 
            //
            bReturn &= ConCatPathAndWriteToSed(hDlg, TEXT("cmutoa.dll"), g_szSupportDir, &iFileNum, szSed);
        }
#endif
    }

    //
    // Write entry for Inf in SED
    //
    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s%s\\%s.inf"), g_szOsdir, g_szShortServiceName, g_szShortServiceName));
    bReturn &= WriteSED(hDlg, szTemp, &iFileNum, szSed);

    //
    //  Write the Cmp to the Sed
    //
    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s%s\\%s.cmp"), g_szOsdir, g_szShortServiceName, g_szShortServiceName));
    bReturn &= WriteSED(hDlg, szTemp, &iFileNum, szSed);

    //
    //  Write the Cms to the Sed
    //
    MYVERIFY(CELEMS(szTemp) > (UINT)wsprintf(szTemp, TEXT("%s%s\\%s.cms"), g_szOsdir, g_szShortServiceName, g_szShortServiceName));
    bReturn &= WriteSED(hDlg, szTemp, &iFileNum, szSed);

    //
    //  Now include the Custom Added Files
    //

    bReturn &= WriteSED(hDlg, g_szPhonebk, &iFileNum, szSed);
    bReturn &= WriteSED(hDlg, g_szRegion, &iFileNum, szSed);
    bReturn &= WriteSED(hDlg, g_szBrandBmp, &iFileNum, szSed);
    bReturn &= WriteSED(hDlg, g_szPhoneBmp, &iFileNum, szSed);
    bReturn &= WriteSED(hDlg, g_szLargeIco, &iFileNum, szSed);
    bReturn &= WriteSED(hDlg, g_szSmallIco, &iFileNum, szSed);
    bReturn &= WriteSED(hDlg, g_szTrayIco, &iFileNum, szSed);
    bReturn &= WriteSED(hDlg, g_szHelp, &iFileNum, szSed);
    bReturn &= WriteSED(hDlg, g_szCmProxyFile, &iFileNum, szSed);
    bReturn &= WriteSED(hDlg, g_szCmRouteFile, &iFileNum, szSed);
    bReturn &= WriteSED(hDlg, g_szVpnFile, &iFileNum, szSed);

    bReturn &=WriteSEDMenuItemFiles(hDlg, &iFileNum, szSed);
    bReturn &=WriteSEDConActFiles(hDlg, &iFileNum, szSed);
    bReturn &=WriteSEDExtraFiles(hDlg, &iFileNum, szSed);
    bReturn &=WriteSEDRefsFiles(hDlg, &iFileNum, szSed);
    bReturn &=WriteSEDDnsFiles(hDlg, &iFileNum, szSed);

    //
    //  By calling WritePrivateProfileString with all NULL's we flush the file cache 
    //  (win95 only).  This call will return 0.
    //

    WritePrivateProfileString(NULL, NULL, NULL, g_szSedFile); //lint !e534 this call will always return 0

    return bReturn;
}

void AddAllSectionsInCurrentFileToCombo(HWND hDlg, UINT uComboId, LPCTSTR pszFile)
{
    if ((NULL == hDlg) || (0 == uComboId) || (NULL == pszFile))
    {
        CMASSERTMSG(FALSE, TEXT("AddAllKeysInCurrentSectionToCombo -- Invalid Parameter passed."));
        return;
    }

    //
    //  Reset the combobox contents
    //
    SendDlgItemMessage(hDlg, uComboId, CB_RESETCONTENT, 0, 0); //lint !e534 CB_RESETCONTENT doesn't return anything useful

    //
    //  First lets get all of the sections from the existing cmp
    //
    LPTSTR pszAllSections = GetPrivateProfileStringWithAlloc(NULL, NULL, TEXT(""), pszFile);

    //
    //  Okay, now we have all of the sections in a buffer, lets add them to the combo
    //
    
    LPTSTR pszCurrentSection = pszAllSections;

    while (pszCurrentSection && TEXT('\0') != pszCurrentSection[0])
    {
        //
        //  Okay, lets add all of the sections that we found
        //

        MYVERIFY(CB_ERR!= SendDlgItemMessage(hDlg, uComboId, CB_ADDSTRING, 0, (LPARAM)pszCurrentSection));

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

    CmFree(pszAllSections);
}

void AddFilesToCombo(HWND hDlg, UINT uComboId)
{
    //
    //  Reset the combobox contents
    //
    SendDlgItemMessage(hDlg, uComboId, CB_RESETCONTENT, 0, 0); //lint !e534 CB_RESETCONTENT doesn't return anything useful

    //
    //  Add the profile cmp
    //
    LRESULT lResult = SendDlgItemMessage(hDlg, uComboId, CB_ADDSTRING, (WPARAM)0, (LPARAM)GetName(g_szCmpFile));
    if (CB_ERR != lResult)
    {
        SendDlgItemMessage(hDlg, uComboId, CB_SETITEMDATA, (WPARAM)lResult, (LPARAM)g_szCmpFile);
    }
    else
    {
        CMASSERTMSG(FALSE, TEXT("AddFilesToCombo -- unable to set item data"));
    }

    //
    //  Add the profile cms
    //
    lResult = SendDlgItemMessage(hDlg, uComboId, CB_ADDSTRING, (WPARAM)0, (LPARAM)GetName(g_szCmsFile));
    if (CB_ERR != lResult)
    {
        SendDlgItemMessage(hDlg, uComboId, CB_SETITEMDATA, (WPARAM)lResult, (LPARAM)g_szCmsFile);
    }
    else
    {
        CMASSERTMSG(FALSE, TEXT("AddFilesToCombo -- unable to set item data"));
    }
}

BOOL GetCurrentComboSelectionAlloc(HWND hDlg, UINT uComboId, LPTSTR* ppszText)
{
    if ((NULL == hDlg) || (0 == uComboId) || (NULL == ppszText))
    {
        CMASSERTMSG(FALSE, TEXT("GetCurrentComboSelectionAlloc -- invalid parameter"));
        return FALSE;
    }

    *ppszText = NULL;
    LRESULT lTextLen;
    BOOL bReturn = FALSE;
    LRESULT lResult = SendDlgItemMessage(hDlg, uComboId, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);

    if (CB_ERR != lResult)
    {
        lTextLen = SendDlgItemMessage(hDlg, uComboId, CB_GETLBTEXTLEN, (WPARAM)lResult, (LPARAM)0);

        if (0 != lTextLen)
        {
            lTextLen++; // NULL char
            *ppszText = (LPTSTR)CmMalloc(sizeof(TCHAR)*lTextLen);

            if (*ppszText)
            {
                lResult = SendDlgItemMessage(hDlg, uComboId, CB_GETLBTEXT, (WPARAM)lResult, (LPARAM)(*ppszText));

                if (0 == lResult)
                {
                    goto exit;
                }
                else
                {
                    bReturn = TRUE;
                }
            }
            else
            {
                goto exit;
            }
        }
        else
        {
            goto exit;
        }
    }
    else
    {
        goto exit;
    }
    
exit:
    if (FALSE == bReturn)
    {
        CmFree(*ppszText);
    }

    return bReturn;

}

//+----------------------------------------------------------------------------
//
// Function:  GetCurrentEditControlTextAlloc
//
// Synopsis:  Figures out the length of the text in the edit control specified
//            by the given window handle, allocates a buffer large enough to
//            hold the text and then retrieves the text and stores it in the
//            allocated buffer.  The buffer is the caller's responsibility to
//            free.  Note that we ensure the data is roundtripable.
//
// Arguments: HWND hEditText - window handle of the edit control to get the text from
//            LPTSTR* ppszText - pointer to a string pointer to recieve the output buffer
//
// Returns:   int - Returns the number of characters copied to *ppszText
//                  0 could be an error value but often means the control is empty
//                  -1 means that the text failed MBCS conversion and should not be used
//
// History:   quintinb  Created     04/07/00
//
//+----------------------------------------------------------------------------
int GetCurrentEditControlTextAlloc(HWND hEditText, LPTSTR* ppszText)
{
    if ((NULL == hEditText) || (NULL == ppszText))
    {
        CMASSERTMSG(FALSE, TEXT("GetCurrentEditControlTextAlloc -- invalid parameter"));
        return 0;
    }

    *ppszText = NULL;
    int iReturn = 0;
    LRESULT lResult;
    LRESULT lTextLen = SendMessage(hEditText, WM_GETTEXTLENGTH, (WPARAM)0, (LPARAM)0);

    if (0 != lTextLen)
    {
        lTextLen++; // NULL char
        *ppszText = (LPTSTR)CmMalloc(sizeof(TCHAR)*lTextLen);

        if (*ppszText)
        {
            lResult = SendMessage(hEditText, WM_GETTEXT, (WPARAM)lTextLen, (LPARAM)(*ppszText));

            if (0 == lResult)
            {
                goto exit;
            }
            else
            {
#ifdef UNICODE
                //
                //  We want to make sure that we can convert the strings to MBCS.  If we cannot then we are not
                //  going to be able to store the string in the our ANSI data files (.cms, .cmp, .inf, etc.).
                //  Thus we need to convert the string to MBCS and then back to UNICODE.  We will then compare the original
                //  string to the resultant string and see if they match.
                //
        
                if (!TextIsRoundTripable(*ppszText, TRUE))
                {
                    //
                    //  Set the return code to an error value.
                    //
                    iReturn = -1;
                    goto exit;
                }
#endif
                iReturn = (int)lResult;
            }
        }
        else
        {
            goto exit;
        }
    }
    else
    {
        goto exit;
    }

exit:
    if ((0 == iReturn) || (-1 == iReturn))
    {
        CmFree(*ppszText);
        *ppszText = NULL;
    }

    return iReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  RemoveBracketsFromSectionString
//
// Synopsis:  Removes brackets from section string. If a string is
//            invalid, this function returns a newly allocated
//            valid string without brackets and deleted the old invalid one.
//            If there are no valid characters in the string this function
//            return NULL in ppszSection. It is the caller's responibility to 
//            free the string. 
//            This function was created to fix Bug 189379 for Whistler.
//
// Arguments: LPTSTR *ppszSection - pointer to the address of the string
//
// History:   tomkel    Created     11/15/2000
//
//+----------------------------------------------------------------------------
BOOL RemoveBracketsFromSectionString(LPTSTR *ppszSection)
{
    BOOL bReturn = FALSE;
    LPTSTR pszSection = NULL;
    const TCHAR* const c_szBadSectionChars = TEXT("[]");
    const TCHAR* const c_szLeftBracket = TEXT("[");
    const TCHAR* const c_szRightBracket = TEXT("]");
    
    if (NULL == ppszSection)
    {
        return bReturn;
    }

    pszSection = *ppszSection;

    if (NULL != pszSection)
    {
        LPTSTR pszValidSection = NULL;
        LPTSTR pszToken = NULL;
        //
        // We have a string so try to find an occurence of a bracket []. 
        //
        if (CmStrStr(pszSection, c_szLeftBracket) || CmStrStr(pszSection, c_szRightBracket))
        {
            //
            // The pszSection string contains brackets.
            // This treats brackets [] as delimiters. The loop concatenates the newly
            // valid string.
            //
            pszToken = CmStrtok(pszSection, c_szBadSectionChars);
            
            if (NULL != pszToken)
            {
                // 
                // Found at least one valid token
                //
                while (NULL != pszToken)
                {
                    if (NULL == pszValidSection)
                    {
                        pszValidSection = CmStrCpyAlloc(pszToken);
                    }
                    else
                    {
                        pszValidSection = CmStrCatAlloc(&pszValidSection, pszToken);
                    }

                    //
                    // Find the next valid token
                    //
                    pszToken = CmStrtok(NULL, c_szBadSectionChars);
                }

                if ( pszValidSection )
                {
                    // 
                    // We encountered brackets []. Lets copy the valid string back to 
                    // pszSection string so that the code below this section doesn't 
                    // need to be modified.
                    //
                    CmFree(pszSection);
                    pszSection = CmStrCpyAlloc(pszValidSection);
                    CmFree(pszValidSection);
                    pszValidSection = NULL;
                }
            }
            else
            {
                //
                // There are no valid tokens. Delete the string and set it to NULL.
                //
                CmFree(pszSection);
                pszSection = NULL;
                
            }

            *ppszSection = pszSection;
            bReturn = TRUE;
        }
        else
        {
            //
            // Nothing to parse, which is ok.
            //
            bReturn = TRUE;
        }
    }
    else
    {
        //
        // Nothing to parse, which is ok.
        //
        bReturn = TRUE;
    }

    return bReturn;
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessGeekPane
//
// Synopsis:  Processes windows messages for the dialog which allows user to
//            edit the cms/cmp files directly for features not exposed in CMAK
//            directly.
//
// Arguments: WND hDlg - dialog window handle
//            UINT message - message identifier
//            WPARAM wParam - wParam Value 
//            LPARAM lParam - lParam Value
//
//
// History:   quintinb  Created     03/26/00
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessGeekPane(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    SetDefaultGUIFont(hDlg, message, IDC_EDIT1);
    SetDefaultGUIFont(hDlg, message, IDC_COMBO1);
    SetDefaultGUIFont(hDlg, message, IDC_COMBO2);
    SetDefaultGUIFont(hDlg, message, IDC_COMBO3);

    LRESULT lResult;
    static LPTSTR pszFile = NULL;
    static LPTSTR pszSection = NULL;
    static LPTSTR pszKey = NULL;
    LPTSTR pszValue = NULL;
    HWND hControl;
    static HWND hwndSectionEditControl = NULL;
    static HWND hwndKeyEditControl = NULL;
    COMBOBOXINFO cbInfo;
    NMHDR* pnmHeader = (NMHDR*)lParam;
    DWORD dwFinishPage;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_ADVANCED)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam))
    {
        if (0 == GetWindowLongPtr(hDlg, DWLP_MSGRESULT))
        {
            //
            //  If the user accepted the cancel then the DWLP_MSGRESULT value will be FALSE.  If
            //  they chose to deny the cancel it will be TRUE.  Thus if we need to, let's free
            //  up any allocated resources.  If you change the free code, make sure to change
            //  it below in the kill active state too.
            //
            CmFree(pszSection);
            pszSection = NULL;
            CmFree(pszKey);
            pszKey = NULL;
        }
        return TRUE;
    }

    switch (message)
    {

        case WM_INITDIALOG:
            //
            //  Fill in the files combo
            //
            AddFilesToCombo(hDlg, IDC_COMBO1);

            //
            //  Choose the Cms File because it is the one they are most likely to edit
            //
            lResult = SendDlgItemMessage(hDlg, IDC_COMBO1, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)GetName(g_szCmsFile));
            if (CB_ERR != lResult)
            {
                MYVERIFY(CB_ERR != SendDlgItemMessage(hDlg, IDC_COMBO1, CB_SETCURSEL, (WPARAM)lResult, (LPARAM)0));
            }

            pszFile = g_szCmsFile;
            AddAllSectionsInCurrentFileToCombo(hDlg, IDC_COMBO2, (LPCTSTR)pszFile);    

            //
            //  Choose the first section in the list, don't assert because there may not be any
            //
            SendDlgItemMessage(hDlg, IDC_COMBO2, CB_SETCURSEL, (WPARAM)0, (LPARAM)0);

            if (GetCurrentComboSelectionAlloc(hDlg, IDC_COMBO2, &pszSection))
            {
                AddAllKeysInCurrentSectionToCombo(hDlg, IDC_COMBO3, pszSection, pszFile);

                //
                //  Choose the first key in the list, don't assert because there may not be any
                //
                SendDlgItemMessage(hDlg, IDC_COMBO3, CB_SETCURSEL, (WPARAM)0, (LPARAM)0);

                GetCurrentComboSelectionAlloc(hDlg, IDC_COMBO3, &pszKey);

                //
                //  Finally fill in the edit control
                //
                pszValue = GetPrivateProfileStringWithAlloc(pszSection, pszKey, TEXT(""), pszFile);

                if (pszValue)
                {
                    SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)0, (LPARAM)pszValue);
                    CmFree(pszValue);
                }
                else
                {
                    SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)0, (LPARAM)TEXT(""));
                }
            }

            //
            //  Now lets get the window handles to the edit control portion of the section and key combobox controls
            //
            ZeroMemory(&cbInfo, sizeof(cbInfo));
            cbInfo.cbSize = sizeof(cbInfo);
            hControl = GetDlgItem(hDlg, IDC_COMBO2);
            if (hControl)
            {
                if (GetComboBoxInfo (hControl, &cbInfo))
                {
                    hwndSectionEditControl = cbInfo.hwndItem;
                }
            }

            ZeroMemory(&cbInfo, sizeof(cbInfo));
            cbInfo.cbSize = sizeof(cbInfo);
            hControl = GetDlgItem(hDlg, IDC_COMBO3);
            if (hControl)
            {
                if (GetComboBoxInfo (hControl, &cbInfo))
                {
                    hwndKeyEditControl = cbInfo.hwndItem;
                }
            }

            break;
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_COMBO1:
                    if (HIWORD(wParam) == CBN_SELCHANGE)
                    {
                        lResult = SendDlgItemMessage(hDlg, IDC_COMBO1, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);

                        if (CB_ERR != lResult)
                        {
                            pszFile = (LPTSTR)SendDlgItemMessage(hDlg, IDC_COMBO1, CB_GETITEMDATA, (WPARAM)lResult, (LPARAM)0);

                            if (NULL != pszFile)
                            {
                                AddAllSectionsInCurrentFileToCombo(hDlg, IDC_COMBO2, (LPCTSTR)pszFile);    

                                //
                                //  Choose the first section in the list, don't assert because there may not be any
                                //
                                SendDlgItemMessage(hDlg, IDC_COMBO2, CB_SETCURSEL, (WPARAM)0, (LPARAM)0);
                            }
                        }

                        //
                        //  Note that we don't break here, we fail through to pick up changes for the
                        //  section and keys combo boxes
                        //
                    }
                    else
                    {
                        break;
                    }

                case IDC_COMBO2:
                    if (HIWORD(wParam) == CBN_SELCHANGE)
                    {
                        CmFree(pszSection);
                        GetCurrentComboSelectionAlloc(hDlg, IDC_COMBO2, &pszSection);

                        AddAllKeysInCurrentSectionToCombo(hDlg, IDC_COMBO3, pszSection, pszFile);

                        //
                        //  Choose the first key in the list, don't assert because there may not be any
                        //
                        SendDlgItemMessage(hDlg, IDC_COMBO3, CB_SETCURSEL, (WPARAM)0, (LPARAM)0);

                    }
                    else if (HIWORD(wParam) == CBN_EDITCHANGE)
                    {
                        CmFree(pszSection);
                        if (-1 != GetCurrentEditControlTextAlloc(hwndSectionEditControl, &pszSection))
                        {
                            AddAllKeysInCurrentSectionToCombo(hDlg, IDC_COMBO3, pszSection, pszFile);

                            //
                            //  Choose the first key in the list, don't assert because there may not be any
                            //
                            SendDlgItemMessage(hDlg, IDC_COMBO3, CB_SETCURSEL, (WPARAM)0, (LPARAM)0);
                        }
                        else
                        {
                            break;
                        }
                    }
                    else
                    {
                        //
                        //  Note we don't break if the message is CBN_SELCHANGE or CBN_EDITCHANGE because
                        //  we want to execute the code for the key combo changing
                        //
                        break;
                    }

                case IDC_COMBO3:
                    if (HIWORD(wParam) == CBN_SELCHANGE)
                    {
                        CmFree(pszKey);
                        GetCurrentComboSelectionAlloc(hDlg, IDC_COMBO3, &pszKey);

                        //
                        //  Fill in the edit control
                        //
                        if (pszKey)
                        {
                            pszValue = GetPrivateProfileStringWithAlloc(pszSection, pszKey, TEXT(""), pszFile);

                            if (pszValue)
                            {
                                SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)0, (LPARAM)pszValue);
                                CmFree(pszValue);
                            }
                            else
                            {
                                SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)0, (LPARAM)TEXT(""));
                            }
                        }
                        else
                        {
                            SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)0, (LPARAM)TEXT(""));
                        }
                    }
                    else if (HIWORD(wParam) == CBN_EDITCHANGE)
                    {
                        CmFree(pszKey);
                        if (-1 != GetCurrentEditControlTextAlloc(hwndKeyEditControl, &pszKey))
                        {
                            //
                            //  Fill in the edit control
                            //
                            if (pszKey)
                            {
                                pszValue = GetPrivateProfileStringWithAlloc(pszSection, pszKey, TEXT(""), pszFile);

                                if (pszValue)
                                {
                                    SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)0, (LPARAM)pszValue);
                                    CmFree(pszValue);
                                }
                                else
                                {
                                    SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)0, (LPARAM)TEXT(""));
                                }
                            }
                            else
                            {
                                SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)0, (LPARAM)TEXT(""));
                            }
                        }
                        else
                        {
                            break;
                        }
                    }

                    break;

                case IDC_BUTTON1: // Update Value                    
                    
                    if (RemoveBracketsFromSectionString(&pszSection))
                    {
                        //
                        // Successfully removed brackets. Check if the valid string is empty. If so clear
                        // the fields
                        //
                        if (NULL == pszSection)
                        {
                            //
                            // The section string contained all invalid characters, so clear the combobox
                            //
                            lResult = SendDlgItemMessage(hDlg, IDC_COMBO2, WM_SETTEXT, (WPARAM)0, (LPARAM)TEXT(""));

                            //
                            // Clear the other edit boxes by sending a CBN_EDITCHANGE notification 
                            //
                            lResult= SendMessage(hDlg, WM_COMMAND, (WPARAM)MAKEWPARAM((WORD)IDC_COMBO2,(WORD)CBN_EDITCHANGE), (LPARAM)GetDlgItem(hDlg,IDC_COMBO2));
                        }
                    }
                    else
                    {
                        CMASSERTMSG(FALSE, TEXT("ProcessGeekPane -- Trying to remove brackets from invalid section string."));
                        return 1;
                    }

                    hControl = GetDlgItem(hDlg, IDC_EDIT1);

                    if (hControl)
                    {
                        int iReturn = GetCurrentEditControlTextAlloc(hControl, &pszValue);

                        if (0 == iReturn)
                        {
                            pszValue = NULL; // delete the value
                        }
                        else if (-1 == iReturn)
                        {
                            return 1;
                        }
                    }
                    else
                    {
                        CMASSERTMSG(FALSE, TEXT("ProcessGeekPane -- Unable to get the window handle for the text control."));
                        return 1;
                    }

                    if (NULL == pszSection)
                    {
                        ShowMessage(hDlg, IDS_NEED_SECTION, MB_OK);
                        return 1;
                    }
                    else if (NULL == pszKey)
                    {
                        int iReturn = IDNO;
                        LPTSTR pszMsg = CmFmtMsg(g_hInstance, IDS_DELETE_SECTION, pszSection);
                        
                        if (pszMsg)
                        {
                            iReturn = MessageBox(hDlg, pszMsg, g_szAppTitle, MB_YESNO);

                            CmFree(pszMsg);
                        }

                        if (IDNO == iReturn)
                        {
                            return 1;
                        }

                        //
                        // Need to clear the value in case the section is NULL and the value isn't
                        // even though the WritePrivateProfileString handles it correctly
                        //
                        CmFree(pszValue);
                        pszValue = NULL;
                    }
                    else if (NULL == pszValue)
                    {
                        //
                        // This else if needs to be the last one
                        // The following message should only be displayed 
                        // if NULL != pszKey && NULL != pszSection && NULL == pszValue
                        // Prompt user to ask to delete this key.
                        //
                        int iReturn = IDNO;
                        LPTSTR pszMsg = CmFmtMsg(g_hInstance, IDS_DELETE_KEY, pszKey);
                        
                        if (pszMsg)
                        {
                            iReturn = MessageBox(hDlg, pszMsg, g_szAppTitle, MB_YESNO);

                            CmFree(pszMsg);
                        }

                        if (IDNO == iReturn)
                        {
                            return 1;
                        }
                    }


                    MYVERIFY(0 != WritePrivateProfileString(pszSection, pszKey, pszValue, pszFile));
                    CmFree(pszValue);

                    //
                    //  Make sure to reselect the section and key the user had before (especially important
                    //  if the user just added a new section or file).  First add all of the sections
                    //
                    AddAllSectionsInCurrentFileToCombo(hDlg, IDC_COMBO2, (LPCTSTR)pszFile);    

                    //
                    //  Select the correct section
                    //
                    lResult = SendDlgItemMessage(hDlg, IDC_COMBO2, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)pszSection);

                    if (CB_ERR == lResult)
                    {
                        //
                        //  Then the user deleted the value, lets select the first in the list
                        //
                        CmFree(pszSection);
                        SendDlgItemMessage(hDlg, IDC_COMBO2, CB_SETCURSEL, (WPARAM)0, (LPARAM)0);
                        GetCurrentComboSelectionAlloc(hDlg, IDC_COMBO2, &pszSection);
                    }
                    else
                    {
                        SendDlgItemMessage(hDlg, IDC_COMBO2, CB_SETCURSEL, (WPARAM)lResult, (LPARAM)0);
                    }

                    //
                    //  Now add all of the keys in that section
                    //
                    AddAllKeysInCurrentSectionToCombo(hDlg, IDC_COMBO3, pszSection, pszFile);

                    //
                    //  Select the correct key
                    //
                    lResult = SendDlgItemMessage(hDlg, IDC_COMBO3, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)pszKey);

                    if (CB_ERR == lResult)
                    {
                        //
                        //  Then the user deleted the value, lets select the first in the list
                        //
                        CmFree(pszKey);
                        SendDlgItemMessage(hDlg, IDC_COMBO3, CB_SETCURSEL, (WPARAM)0, (LPARAM)0);
                        GetCurrentComboSelectionAlloc(hDlg, IDC_COMBO3, &pszKey);

                        lResult = 0;
                    }
                    else
                    {
                        SendDlgItemMessage(hDlg, IDC_COMBO3, CB_SETCURSEL, (WPARAM)lResult, (LPARAM)0);
                    }

                    //
                    //  Fill in the edit control, since the user may have deleted the last selection
                    //
                    pszValue = GetPrivateProfileStringWithAlloc(pszSection, pszKey, TEXT(""), pszFile);

                    if (pszValue)
                    {
                        SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)0, (LPARAM)pszValue);
                        CmFree(pszValue);
                    }
                    else
                    {
                        SendDlgItemMessage(hDlg, IDC_EDIT1, WM_SETTEXT, (WPARAM)0, (LPARAM)TEXT(""));
                    }

                    break;

                default:
                    break;
            }
            break;

        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    //
                    //  Free up any allocated values.  If you add new values to free here, also
                    //  make sure to add them in the cancel case.
                    //
                    CmFree(pszSection);
                    pszSection = NULL;
                    CmFree(pszKey);
                    pszKey = NULL;

                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_NEXT);
                    break;

                case PSN_WIZBACK:
                    CMASSERTMSG(FALSE, TEXT("There shouldn't be a back button on the Geek Pane, why are we getting PSN_WIZBACK?"));
                    break;

                case PSN_WIZNEXT:

                    if (BuildProfileExecutable(hDlg))
                    {
                        dwFinishPage = g_bIEAKBuild ? IDD_IEAK_FINISH_GOOD_BUILD : IDD_FINISH_GOOD_BUILD;
                    }
                    else
                    {
                        dwFinishPage = IDD_FINISH_BAD_BUILD;
                    }

                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, dwFinishPage));                        
                    return 1;

                    break;
            }

            break;

        default:
            return FALSE;
    }
    return FALSE;   
}

//+----------------------------------------------------------------------------
//
// Function:  BuildProfileExecutable
//
// Synopsis:  This function takes care of all of the details of turning the 
//            CMAK files in the temp dir into a profile executable.
//
// Arguments: HWND hDlg - window handle of the calling dialog
//
// Returns:   BOOL - TRUE if the profile built successfully, FALSE otherwise
//
// History:   quintinb  Created     05/17/00
//
//+----------------------------------------------------------------------------
BOOL BuildProfileExecutable(HWND hDlg)
{
    DWORD dwExitCode = 0;
    DWORD dwWaitCode = 0;
    BOOL bExitLoop = FALSE;
    BOOL bEnoughSpaceToCompress;
    SHELLEXECUTEINFO seiInfo;
    static HANDLE hProcess = NULL;
    TCHAR szTemp[MAX_PATH+1];
    TCHAR szMsg[MAX_PATH+1];
    TCHAR pszArgs[MAX_PATH+1];
    BOOL bRes;

    //
    //  The user may have unchecked UsePresharedKey for all VPN settings, in
    //  which case we need to remove the pre-shared key.
    //
    g_bPresharedKeyNeeded = DoesSomeVPNsettingUsePresharedKey();
    if (FALSE == g_bPresharedKeyNeeded)
    {
        // remove the Pre-shared key values from the CMP
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryPresharedKey, NULL, g_szCmpFile));
        MYVERIFY(0 != WritePrivateProfileString(c_pszCmSection, c_pszCmEntryKeyIsEncrypted, NULL, g_szCmpFile));
    }

    if (!CopyFromTempDir(g_szShortServiceName))
    {
        return FALSE;
    }

    //
    //  Write the SED File.
    //  Note that the SED file has been moved from the temp dir to
    //  the profile dir.  We now want to write the SED file entries
    //  in place before compressing them.  This way we can verify the
    //  files exist right before compressing them.
    //

    MYVERIFY(CELEMS(g_szSedFile) > (UINT)wsprintf(g_szSedFile, TEXT("%s%s\\%s.sed"), 
        g_szOsdir, g_szShortServiceName, g_szShortServiceName));
    if (!ConstructSedFile(hDlg, g_szSedFile, g_szOutExe))
    {
        return FALSE;                    
    }

    _tcscpy(g_szOutdir, g_szOsdir);
    _tcscat(g_szOutdir, g_szShortServiceName);

    //
    // Setup IExpress to build in the output directory. 
    //
    
    MYVERIFY(0 != SetCurrentDirectory(g_szOutdir));

    //
    //  Check to make sure there is enough disk space
    //

    do
    {
        bEnoughSpaceToCompress = CheckDiskSpaceForCompression(g_szSedFile);
        if (!bEnoughSpaceToCompress)
        {

            MYVERIFY(0 != LoadString(g_hInstance, IDS_DISKFULL, szTemp, MAX_PATH));
            MYVERIFY(CELEMS(szMsg) > (UINT)wsprintf(szMsg, szTemp, g_szOutdir));

            int iMessageReturn = MessageBox(hDlg, szMsg, g_szAppTitle, MB_RETRYCANCEL | MB_ICONERROR 
                | MB_APPLMODAL );

            if (iMessageReturn == IDCANCEL)
            {
                return FALSE;
            }
        }
    
    } while(!bEnoughSpaceToCompress);
    
    MYVERIFY(CELEMS(pszArgs) > (UINT)wsprintf(pszArgs, TEXT("/N %s.sed"), 
        g_szShortServiceName));

    _tcscpy(szTemp, TEXT("iexpress.exe"));

    ZeroMemory(&seiInfo,sizeof(seiInfo));
    seiInfo.cbSize = sizeof(seiInfo);
    seiInfo.fMask |= SEE_MASK_FLAG_NO_UI | SEE_MASK_NOCLOSEPROCESS;
    seiInfo.lpFile = szTemp;
    seiInfo.lpDirectory = g_szOutdir;
    seiInfo.lpParameters = pszArgs;
    seiInfo.nShow = SW_HIDE;

    //
    //  Okay, we are finally ready to execute IExpress, lets disable all the
    //  wizard buttons.
    //
    DisableWizardButtons(hDlg);

    //
    // Execute IExpress
    //

    bRes = ShellExecuteEx(&seiInfo);

    //
    //  Wait for the shellexecute to finish.  Thus our cleanup code doesn't
    //  execute till IEpress is done.
    //
    
    if (bRes)
    {
        //
        //  hProcess contains the handle to the process
        //
        hProcess = seiInfo.hProcess;

        do
        {
            dwWaitCode = MsgWaitForMultipleObjects(1, &hProcess, FALSE, INFINITE, QS_ALLINPUT);
            
            //
            //  Check to see if we returned because of a message, process termination,
            //  or an error.
            //
            switch(dwWaitCode)
            {

            case 0:

                //
                //  Normal termination case, we were signaled that the process ended
                //
                
                bExitLoop = TRUE;
                break;

            case 1:

                HandleWindowMessagesWhileCompressing();
                                             
                break;

            case -1:

                //
                //  MsgWait returned an error
                //

                MYVERIFY(0 != GetExitCodeProcess(seiInfo.hProcess, &dwExitCode));

                if (dwExitCode == STILL_ACTIVE)
                {
                    continue;
                }
                else
                {
                    bExitLoop = TRUE;
                }

                break;

            default:
                //
                //  Do nothing
                //
                break;
            }

        } while (!bExitLoop);
    }

    //
    //  now need to send the user to the finish page.  If their profile
    //  build successfully then we send them to the success page, otherwise
    //  we send them to the bad build page.
    //

    MYVERIFY(0 != GetExitCodeProcess(seiInfo.hProcess, &dwExitCode));

    if (dwExitCode)
    {
        g_iCMAKReturnVal = CMAK_RETURN_ERROR;

        //
        //  We encountered an error, clear the out exe val
        //  so that we write nothing to the output key.
        //
        ZeroMemory(g_szOutExe, sizeof(g_szOutExe));
    }
    else
    {
        g_iCMAKReturnVal = CMAK_RETURN_SUCCESS;
    }

    CloseHandle(seiInfo.hProcess);

    //
    // Create a registry entry for IEAK to retrieve 
    // the path of the output profile.
    //

    MYVERIFY(FALSE != WriteRegStringValue(HKEY_LOCAL_MACHINE, c_pszRegCmak, c_pszRegOutput, g_szOutExe));

    //
    //  CMAK_RETURN_ERROR is -1, so return TRUE if g_iCMAKReturnVal is a positive integer
    //
    return (g_iCMAKReturnVal > 0);
}

//+----------------------------------------------------------------------------
//
// Function:  ProcessBuildProfile
//
// Synopsis:  Processes windows messages for the page in CMAK that allows the
//            user to build their profile or advance to the Advanced Customization
//            page to make final edits before building the profile.
//
//  WM_INITDIALOG - intializes the page
//  WM_NOTIFY - processes the notifications sent to the page
//
//  Specify the installation package location
//
// Arguments: WND hDlg - 
//            UINT message - 
//            WPARAM wParam - 
//            LPARAM lParam - 
//
// Returns:   INT_PTR APIENTRY - 
//
// History:   a-anasj restructured the function and Created Header    1/7/98
//          note: the function does not allow the user to choose a location for 
//          their profile anylonger. It only informs them of where it will be
//          created.
//            quintinb      Renamed from the feared ProcessPage8   8-6-98
//            quintinb      restructured for Whistler 108269       05/17/00
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessBuildProfile(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    TCHAR szTemp[MAX_PATH+1];
    int iMessageReturn;
    NMHDR* pnmHeader = (NMHDR*)lParam;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_CREATE)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;

    switch (message)
    {
        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_KILLACTIVE:
                    
                    MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, FALSE));
                    return 1;
                    break;  //lint !e527 this line isn't reachable but 
                            //  keep it in case the return is removed

                case PSN_SETACTIVE:
                    //
                    // Build default path of final executable 
                    //
                    MYVERIFY(CELEMS(g_szOutExe) > (UINT)wsprintf(g_szOutExe, TEXT("%s%s\\%s.exe"), 
                        g_szOsdir, g_szShortServiceName, g_szShortServiceName));

                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_BACK | PSWIZB_NEXT));
                    break;

                case PSN_WIZBACK:
                    break;

                case PSN_WIZNEXT:

                    //
                    // Ensure that profile directory exists
                    //
                    _tcscpy(szTemp,g_szOsdir);
                    _tcscat(szTemp,g_szShortServiceName);
                    
                    if (0 == SetCurrentDirectory(szTemp))
                    {
                        MYVERIFY(0 != CreateDirectory(szTemp,NULL));
                    }
                    
                    //
                    //  Prompt the user to overwrite the existing Executable
                    //
                    if (FileExists(g_szOutExe))
                    {
                        iMessageReturn = ShowMessage(hDlg, IDS_OVERWRITE, MB_YESNO);

                        if (iMessageReturn == IDNO)
                        {   
                            MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                            return 1;
                        }
                    }

                    //
                    //  Write out the Inf File
                    //
                    if (!WriteInfFile(g_hInstance, hDlg, g_szInfFile, g_szLongServiceName))
                    {
                        CMASSERTMSG(FALSE, TEXT("ProcessBuildProfile -- WriteInfFile Failed."));
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                        return 1;
                    }
                    
                    //
                    // Update version in CMP and party on the CMS 
                    //

                    WriteCMPFile();

                    if (!WriteCMSFile())
                    {
                        FileAccessErr(hDlg, g_szCmsFile);
                        
                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, -1));
                        return 1;
                    }

                    //
                    //  If the user wants to do advanced customization, delay building the profile executable
                    //  until after they have done their final edits.  Otherwise, it is time to build the profile!
                    //
                    if (BST_UNCHECKED == IsDlgButtonChecked(hDlg, IDC_ADVANCED))
                    {
                        //
                        //  The user is finished now, lets build the profile and skip over the advanced customization
                        //  page to either the bad build page or the successful build page.
                        //
                        DWORD dwFinishPage;

                        if (BuildProfileExecutable(hDlg))
                        {
                            dwFinishPage = g_bIEAKBuild ? IDD_IEAK_FINISH_GOOD_BUILD : IDD_FINISH_GOOD_BUILD;
                        }
                        else
                        {
                            dwFinishPage = IDD_FINISH_BAD_BUILD;
                        }

                        MYVERIFY(FALSE != SetWindowLongWrapper(hDlg, DWLP_MSGRESULT, dwFinishPage));
                        return 1;
                    }

                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}





//+----------------------------------------------------------------------------
//
// Function:  ProcessFinishPage
//
// Synopsis:  Handles the finish page
//
// Arguments: WND hDlg - 
//            UINT message - 
//            WPARAM wParam - 
//            LPARAM lParam - 
//
// Returns:   INT_PTR APIENTRY - 
//
// History:   quintinb created    6/25/98
//
//+----------------------------------------------------------------------------
INT_PTR APIENTRY ProcessFinishPage(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{   
    HWND hDirEditControl;
    HWND hCurrentPage;
    NMHDR* pnmHeader = (NMHDR*)lParam;

    ProcessBold(hDlg,message);
    if (ProcessHelp(hDlg, message, wParam, lParam, IDH_FINISH)) return TRUE;
    if (ProcessCancel(hDlg,message,lParam)) return TRUE;
    SetDefaultGUIFont(hDlg,message,IDC_EDITDIR);
    
    switch (message)
    {
        case WM_NOTIFY:

            if (NULL == pnmHeader)
            {
                return FALSE;
            }

            switch (pnmHeader->code)
            {

                case PSN_SETACTIVE:
                    PropSheet_SetWizButtons(GetParent(hDlg), (PSWIZB_FINISH));
                    
                    //
                    //  Disable the cancel button since it doesn't make a whole lot of
                    //  sense on the last dialog.
                    //
                    
                    hCurrentPage = GetParent(hDlg);
                    if (hCurrentPage)
                    {
                        HWND hCancelButton = GetDlgItem(hCurrentPage, IDCANCEL);
                    
                        if (hCancelButton)
                        {
                            EnableWindow(hCancelButton, FALSE);
                        }
                    }
                    
                    //
                    //  Fill in the path edit control.  Note that this control doesn't exist if
                    //  this is an IEAK build.
                    //
                    if (hDirEditControl = GetDlgItem(hDlg, IDC_EDITDIR))
                    {
                        MYVERIFY(TRUE == SendMessage(hDirEditControl, WM_SETTEXT, 0, 
                            (LPARAM)g_szOutExe));                    
                    }

                    break;

                case PSN_WIZFINISH:
            
                    //
                    // Now that we know we aren't returning, we can release 
                    // the temp dir and cleanup our files lists
                    //
                        ClearCmakGlobals();
                        FreeList(&g_pHeadProfile, &g_pTailProfile);
            
                    break;

                default:
                    return FALSE;

            }
            break;

        default:
            return FALSE;
    }
    return TRUE;   
}


//
//
//  FUNCTION: FillInPropertyPage(PROPSHEETPAGE *, int, LPTSTR, LPFN) 
//
//  PURPOSE: Fills in the given PROPSHEETPAGE structure 
//
//  COMMENTS:
//
//      This function fills in a PROPSHEETPAGE structure with the
//      information the system needs to create the page.
// 
void FillInPropertyPage( PROPSHEETPAGE* psp, int idDlg, DLGPROC pfnDlgProc)
{
    psp->dwSize = sizeof(PROPSHEETPAGE);
    psp->dwFlags = PSP_HASHELP;
    psp->hInstance = g_hInstance;
    psp->pszTemplate = MAKEINTRESOURCE(idDlg);
    psp->pszIcon = NULL;
    psp->pfnDlgProc = pfnDlgProc;
    psp->pszTitle = TEXT("");
    psp->lParam = 0;

}

//+----------------------------------------------------------------------------
//
// Function:  CreateWizard
//
// Synopsis:  This function creates the wizard pages that make up CMAK.
//
// Arguments: HWND hwndOwner - window handle of the owner of this wizard
//
// Returns:   int - A positive value if successful, -1 otherwise
//
// History:   quintinb Created Header    1/5/98
//            quintinb removed hInst from prototype, not used 1/5/98
//
//+----------------------------------------------------------------------------
INT_PTR CreateWizard(HWND hwndOwner)
{
    PROPSHEETPAGE psp[28]; 
    PROPSHEETHEADER psh;

    FillInPropertyPage( &psp[0], IDD_WELCOME, ProcessWelcome);
    FillInPropertyPage( &psp[1], IDD_ADD_EDIT_PROFILE, ProcessAddEditProfile);
    FillInPropertyPage( &psp[2], IDD_SERVICENAME, ProcessServiceName);
    FillInPropertyPage( &psp[3], IDD_REALM_INFO, ProcessRealmInfo);
    FillInPropertyPage( &psp[4], IDD_MERGEDPROFILES, ProcessMergedProfiles);
    FillInPropertyPage( &psp[5], IDD_TUNNELING, ProcessTunneling);
    FillInPropertyPage( &psp[6], IDD_VPN_ENTRIES, ProcessVpnEntries);
    FillInPropertyPage( &psp[7], IDD_PRESHARED_KEY, ProcessPresharedKey);
    FillInPropertyPage( &psp[8], IDD_PHONEBOOK, ProcessPhoneBook);        // Phonebook Setup
    FillInPropertyPage( &psp[9], IDD_PBK_UPDATE, ProcessPhoneBookUpdate);  // Phonebook Updates
    FillInPropertyPage( &psp[10], IDD_DUN_ENTRIES, ProcessDunEntries);
    FillInPropertyPage( &psp[11], IDD_ROUTE_PLUMBING, ProcessRoutePlumbing);
    FillInPropertyPage( &psp[12], IDD_CMPROXY, ProcessCmProxy);
    FillInPropertyPage( &psp[13], IDD_CUSTOM_ACTIONS , ProcessCustomActions);    // Setup Connect Actions
    FillInPropertyPage( &psp[14], IDD_SIGNIN_BITMAP, ProcessSigninBitmap);        // Sign-in Bitmap
    FillInPropertyPage( &psp[15], IDD_PBK_BITMAP, ProcessPhoneBookBitmap);        // Phonebook Bitmap
    FillInPropertyPage( &psp[16], IDD_ICONS, ProcessIcons);        // Icons  
    FillInPropertyPage( &psp[17], IDD_STATUS_MENU, ProcessStatusMenuIcons);    // Status area menu items   
    FillInPropertyPage( &psp[18], IDD_CUSTOM_HELP, ProcessCustomHelp);        // Help
    FillInPropertyPage( &psp[19], IDD_SUPPORT_INFO, ProcessSupportInfo);    
    FillInPropertyPage( &psp[20], IDD_INCLUDE_CM, ProcessIncludeCm);  // Include CM, note this doesn't show on IA64
    FillInPropertyPage( &psp[21], IDD_LICENSE, ProcessLicense);  // License agreement
    FillInPropertyPage( &psp[22], IDD_ADDITIONAL, ProcessAdditionalFiles);  // Additional files
    FillInPropertyPage( &psp[23], IDD_BUILDPROFILE, ProcessBuildProfile);        // Build the profile
    FillInPropertyPage( &psp[24], IDD_GEEK_PANE, ProcessGeekPane);        // Advance customization
    FillInPropertyPage( &psp[25], IDD_FINISH_GOOD_BUILD, ProcessFinishPage);        // Finish Page -- Good Build
    FillInPropertyPage( &psp[26], IDD_IEAK_FINISH_GOOD_BUILD, ProcessFinishPage);        // Finish Page -- Good Build
    FillInPropertyPage( &psp[27], IDD_FINISH_BAD_BUILD, ProcessFinishPage);        // Finish Page -- Bad Build

    psh.dwSize = sizeof(PROPSHEETHEADER);
    psh.dwFlags = PSH_PROPSHEETPAGE | PSH_WIZARD | PSH_NOAPPLYNOW;
    psh.hwndParent = hwndOwner;
    psh.pszCaption = (LPTSTR) TEXT("");
    psh.nPages = sizeof(psp) / sizeof(PROPSHEETPAGE);
    psh.nStartPage = 0;
    psh.ppsp = (LPCPROPSHEETPAGE) &psp; //lint !e545  Disables line error 545 for this line only

    return (PropertySheet(&psh));
}