//+----------------------------------------------------------------------------
//
// File:     userinfo.cpp     
//
// Module:   CMDIAL32.DLL
//
// Synopsis: This module contains the code that handles getting/saving user info.
//
// Copyright (c) 1996-1999 Microsoft Corporation
//
// Author:   henryt     created         02/??/98
//           quintinb   created Header  08/16/99
//
//+----------------------------------------------------------------------------

#include "cmmaster.h"
#include "cmuufns.h"

#include "pwd_str.h"
#include "userinfo_str.h"
#include "conact_str.h"

///////////////////////////////////////////////////////////////////////////////////
// define's
///////////////////////////////////////////////////////////////////////////////////

//
// CM_MAX_PWD - Maximum possible size of password dataencrypted or otherwise.
//              Includes inbound buffer size + room for encryption expansion.
//

const DWORD CM_MAX_PWD = PWLEN * 3; // 2.73 would be enough

//
// Define this if you want to test userinfo upgrade! You should also delete the key
// HKEY_CURRENT_USER\Software\Microsoft\Connection Manager\UserInfo\<Service Name>
//
//#define TEST_USERINFO_UPGRADE 1

#define CACHE_KEY_LEN 80 // Don't change unless you've read every comment regarding it

//
// Suffix for CacheEntry name used on Legacy and W9x. Note: the space is not a typo

const TCHAR* const c_pszCacheEntryNameSuffix = TEXT(" (Connection Manager)"); 

///////////////////////////////////////////////////////////////////////////////////
// typedef's
///////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////
// func prototypes
///////////////////////////////////////////////////////////////////////////////////

////////////////



BOOL WriteDataToReg(
    LPCTSTR pszKey, 
    UINT uiDataID, 
    DWORD dwType, 
    CONST BYTE *lpData, 
    DWORD cbData,
    BOOL fAllUser);


BOOL ReadDataFromReg(
    LPCTSTR pszKey, 
    UINT uiDataID, 
    LPDWORD lpdwType, 
    BYTE *lpData, 
    LPDWORD lpcbData,
    BOOL fAllUser);

LPBYTE GetDataFromReg(
    LPCTSTR pszKey, 
    UINT uiDataID, 
    DWORD dwType, 
    DWORD dwSize,
    BOOL fAllUser);

BOOL DeleteDataFromReg(
    LPCTSTR pszKey, 
    UINT uiDataID,
    BOOL fAllUser);

BOOL DeleteUserInfoFromReg(
    ArgsStruct  *pArgs,
    UINT        uiEntry);

BOOL ReadPasswordFromCmp(
    ArgsStruct  *pArgs,
    UINT        uiEntry,
    LPTSTR      *ppszPassword);

LPCTSTR TranslateUserDataID(
    UINT uiDataID);

BOOL ReadUserInfoFromCmp(
    ArgsStruct  *pArgs,
    UINT        uiEntry,
    PVOID       *ppvData);

BOOL DeleteUserInfoFromCmp(
    ArgsStruct  *pArgs,
    UINT        uiEntry);

DWORD RasSetCredsWrapper(
    ArgsStruct *pArgs, 
    LPCTSTR pszPhoneBook, 
    DWORD dwMask, 
    LPCTSTR pszData);

int WriteUserInfoToRas(
    ArgsStruct  *pArgs,
    UINT        uiDataID,
    PVOID       pvData);

int DeleteUserInfoFromRas(
    ArgsStruct  *pArgs,
    UINT        uiEntry);

DWORD RasGetCredsWrapper(
    ArgsStruct *pArgs,
    LPCTSTR pszPhoneBook,
    DWORD dwMask,
    PVOID *ppvData);

BOOL ReadUserInfoFromRas(
    ArgsStruct  *pArgs,
    UINT        uiEntry,
    PVOID       *ppvData);

///////////////

BOOL ReadStringFromCache(
    ArgsStruct  *pArgs,
    LPTSTR      pszEntryName,
    LPTSTR      *ppszStr
);

BOOL DeleteStringFromCache(
    ArgsStruct  *pArgs,
    LPTSTR      pszEntryName
);

LPTSTR GetLegacyKeyName(ArgsStruct *pArgs);

LPTSTR EncryptPassword(
    ArgsStruct *pArgs, 
    LPCTSTR pszPassword, 
    LPDWORD lpdwBufSize, 
    LPDWORD lpdwCryptType,
    BOOL fReg,
    LPSTR pszSubKey);

LPBYTE DecryptPassword(
    ArgsStruct *pArgs, 
    LPBYTE pszEncryptedData, 
    DWORD dwEncryptionType,
    DWORD dwEncryptedBytes,
    BOOL /*fReg*/,
    LPSTR pszSubKey);

LPTSTR BuildUserInfoSubKey(
    LPCTSTR pszServiceKey, 
    BOOL fAllUser);

///////////////////////////////////////////////////////////////////////////////////
// Implementation
///////////////////////////////////////////////////////////////////////////////////

#ifdef TEST_USERINFO_UPGRADE

//+---------------------------------------------------------------------------
//
//  Function:   WriteStringToCache
//
//  Synopsis:   Write a null terminated password string to cache.
//
//  Arguments:  pArgs           ptr to ArgsStruct
//              pszEntryName    name to identify the cache entry
//              pszStr          the string
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
BOOL WriteStringToCache(
    ArgsStruct  *pArgs,
    LPTSTR      pszEntryName,
    LPTSTR      pszStr)
{
    MYDBGASSERT(pArgs);
    MYDBGASSERT(pszEntryName && *pszEntryName);
    MYDBGASSERT(pszStr && *pszStr);
    
    DWORD dwRes = ERROR_SUCCESS;

    //
    // In the legacy case, we use mpr.dll for caching user data on W9x.
    // On NT we use the Local Security Authority (LSA)
    //

    if (OS_NT)
    {    
        if (InitLsa(pArgs)) 
        {
            if (!(*ppszStr = (LPTSTR)CmMalloc(dwBufSize)))
            {
                return FALSE;
            }
           
            dwRes = LSA_WriteString(pArgs, pszEntryName, pszStr);
            DeInitLsa(pArgs);
        }
        else
        {
            dwRes = GetLastError();
        }
    }
    else
    {
        //
        // for Windows95
        //
        HINSTANCE hInst = NULL;
        WORD (WINAPI *pfnFunc)(LPSTR,WORD,LPSTR,WORD,BYTE,UINT) = NULL;
    
        //
        // Load MPR for system password cache support 
        //

        MYVERIFY(hInst = LoadLibraryExA("mpr.dll", NULL, 0));
        
        if (hInst) 
        {
            //
            // Get function ptr for WNetCachePassword API and cache the password
            //

            MYVERIFY(pfnFunc = (WORD (WINAPI *)(LPSTR,WORD,LPSTR,WORD,BYTE,UINT)) 
                GetProcAddress(hInst, "WNetCachePassword"));
            
            if (pfnFunc) 
            {
                //
                //  Convert the EntryName and Password Strings to Ansi
                //

                LPSTR pszAnsiEntryName = WzToSzWithAlloc(pszEntryName);
                LPSTR pszAnsiStr = WzToSzWithAlloc(pszStr);

                if (pszAnsiStr && pszAnsiEntryName)
                {
                    //
                    // Store the password
                    //

                    dwRes = pfnFunc(pszAnsiEntryName,
                                    (WORD)lstrlenA(pszAnsiEntryName),
                                    pszAnsiStr,
                                    (WORD)lstrlenA(pszAnsiStr),
                                    CACHE_KEY_LEN,
                                    0);                
                }
                else
                {
                    dwRes = ERROR_NOT_ENOUGH_MEMORY;
                }

                CmFree(pszAnsiStr);
                CmFree(pszAnsiEntryName);
            }
            else
            {
                dwRes = GetLastError();
            }

            FreeLibrary(hInst);
        }
        else
        {
            dwRes = GetLastError();
        }
    }

#ifdef DEBUG
    if (dwRes)
    {
        CMTRACE1(TEXT("WriteStringToCache() failed, err=%u."), dwRes);
    }
#endif

    return (ERROR_SUCCESS == dwRes);
}

#endif //TEST_USERINFO_UPGRADE



//+----------------------------------------------------------------------------
//
// Function:  BuildUserInfoSubKey
//
// Synopsis:  Constructs the appropriate subkey for UserInfo based on the service
//            name key and the user mode of the profile.
//
// Arguments: LPCTSTR pszServiceKey - The service name key
//            BOOL fAllUser         - Flag indicating that profile is All-User
//
// Returns:   LPTSTR - Ptr to allocated buffer containing subkey or NULL on failure.
//
// History:   nickball    Created    8/14/98
//
//+----------------------------------------------------------------------------
LPTSTR BuildUserInfoSubKey(LPCTSTR pszServiceKey, BOOL fAllUser)
{
    MYDBGASSERT(pszServiceKey);

    if (NULL == pszServiceKey)
    {
        return NULL;
    }

    //
    // Use the appropriate base key
    // 
    
    LPTSTR pszSubKey = NULL;

    if (fAllUser)
    {
        pszSubKey = CmStrCpyAlloc(c_pszRegCmUserInfo);       
    }
    else
    {
        pszSubKey = CmStrCpyAlloc(c_pszRegCmSingleUserInfo);          
    }

    MYDBGASSERT(pszSubKey);

    //
    // Append profile service name
    //

    if (pszSubKey && *pszSubKey)
    {
        pszSubKey = CmStrCatAlloc(&pszSubKey, pszServiceKey);  
        MYDBGASSERT(pszSubKey);

        return pszSubKey;
    }

    CmFree(pszSubKey);

    return NULL;
}

//+----------------------------------------------------------------------------
//
// Function:  BuildICSDataInfoSubKey
//
// Synopsis:  Constructs the appropriate subkey for ICS UserInfo based on the service
//            name key.
//
// Arguments: LPCTSTR pszServiceKey - The service name key
//
// Returns:   LPTSTR - Ptr to allocated buffer containing subkey or NULL on failure.
//
// History:   03/30/2001    tomkel      Created
//
//+----------------------------------------------------------------------------
LPTSTR BuildICSDataInfoSubKey(LPCTSTR pszServiceKey)
{
    MYDBGASSERT(pszServiceKey);

    if (NULL == pszServiceKey)
    {
        return NULL;
    }

    //
    // Use the appropriate base key
    // 
    
    LPTSTR pszSubKey = NULL;

    pszSubKey = CmStrCpyAlloc(c_pszRegCmRoot);       

    MYDBGASSERT(pszSubKey);

    //
    // Append profile service name
    //

    if (pszSubKey && *pszSubKey)
    {
        pszSubKey = CmStrCatAlloc(&pszSubKey, pszServiceKey);  
       
        MYDBGASSERT(pszSubKey);

        if (pszSubKey)
        {
            CmStrCatAlloc(&pszSubKey, TEXT("\\"));
            if (pszSubKey)
            {
                CmStrCatAlloc(&pszSubKey, c_pszCmRegKeyICSDataKey);
            }
        }

        return pszSubKey;
    }

    CmFree(pszSubKey);

    return NULL;
}



//+----------------------------------------------------------------------------
//
// Function:  dwGetWNetCachedPassword
//
// Synopsis:  Wrapper to encapsulate linking to MPR.DLL and calling GetWNetCac
//            hedPassword.
//
// Arguments: LPSTR pszEntryName - The names of the key used to identify the password.
//            LPSTR* ppszStr - The buffer to receive the retrieved password.
//            WORD* pwSizeOfStr - The size of the input buffer. Also receives 
//                                of the # of chars retrieved.
//
// Returns:   DWORD - Windows error code.
//
// History:   nickball    Created Header    6/17/99
//
//+----------------------------------------------------------------------------

DWORD dwGetWNetCachedPassword(LPSTR pszEntryName, LPSTR* ppszStr, WORD* pwSizeOfStr)
{
    MYDBGASSERT(OS_W9X);

    DWORD dwRes = ERROR_SUCCESS;
    WORD (WINAPI *pfnFunc)(LPSTR,WORD,LPSTR,LPWORD,BYTE) = NULL;
    HINSTANCE hInst = NULL;

    //
    // Load MPR for system password cache support 
    //

    MYVERIFY(hInst = LoadLibraryExA("mpr.dll", NULL, 0));
    
    if (hInst) 
    {
        //
        // Get function ptr for WNetGetCachedPassword API and retrieve the string
        //

        MYVERIFY(pfnFunc = (WORD (WINAPI *)(LPSTR,WORD,LPSTR,LPWORD,BYTE)) 
            GetProcAddress(hInst, "WNetGetCachedPassword"));

        //
        // Read the cache data
        //

        if (pfnFunc) 
        {
            //
            // NOTE: Final param must be CACHE_KEY_LEN (80), no docs to indicate 
            // exact usage of API but retrieval is tied to the value used when
            // storing the pwd. Thus we hard code to CACHE_KEY_LEN because this 
            // is the value that was used by the original version that stored 
            // the password in the 9X cache. The receiving buffer size is 
            // retained at 256 to minimize delta from latest shipping version. 
            //
            // NT# 355459 - nickball - 6/17/99
            //            
            
            dwRes = pfnFunc(pszEntryName, (WORD)lstrlenA(pszEntryName),
                            *ppszStr, pwSizeOfStr, CACHE_KEY_LEN);
        }
        else
        {
            dwRes = GetLastError();
        }
    }
    else
    {
        dwRes = GetLastError();
    }

    if (NULL != hInst)                      
    {
        FreeLibrary(hInst);    
    }

    return (dwRes);
}

//+---------------------------------------------------------------------------
//
//  Function:   ReadStringFromCache
//
//  Synopsis:   Read a null terminated string from cache.
//
//  Arguments:  pArgs           ptr to ArgsStruct
//              pszEntryName    name to identify the cache entry
//              ppszStr         ptr to the ptr of the buffer.
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
BOOL ReadStringFromCache(
    ArgsStruct  *pArgs,
    LPTSTR      pszEntryName,
    LPTSTR      *ppszStr
)
{
    DWORD   dwRes = ERROR_SUCCESS;
    
    //
    // Alloc buffer - the buffer is uuencoded.  See UserInfoToString().
    //
    
    WORD wBufSize = 256; // arbitrary, we used to use 80 on W95 

    //
    // On NT, we use the Local Security Authority (LSA) services for reading
    // the string in the legacy case. On Win9x, we uses mpr.dll. 
    // Note: wBufSize is used as an in\out param, can be modified below.
    //

    if (OS_NT) 
    {
        if (InitLsa(pArgs))
        {
            if (!(*ppszStr = (LPTSTR)CmMalloc(wBufSize)))
            {
                return FALSE;
            }

            dwRes = LSA_ReadString(pArgs, pszEntryName, *ppszStr, wBufSize);
            DeInitLsa(pArgs);
        }
        else
        {
            dwRes = GetLastError();
        }
    }
    else
    {
        //
        // for Windows95
        //

        LPSTR pszAnsiStr = (LPSTR)CmMalloc(wBufSize);
        LPSTR pszAnsiEntryName = WzToSzWithAlloc(pszEntryName);
        
        if (pszAnsiStr && pszAnsiEntryName)
        {
            dwRes = dwGetWNetCachedPassword(pszAnsiEntryName, &pszAnsiStr, &wBufSize);

            if (ERROR_SUCCESS == dwRes)
            {
                *ppszStr = SzToWzWithAlloc(pszAnsiStr);
                if (NULL == *ppszStr)
                {
                    dwRes = ERROR_NOT_ENOUGH_MEMORY;
                }
            }
        }

        CmFree (pszAnsiStr);
        CmFree (pszAnsiEntryName);
    }

    if (dwRes)
    {
        CmFree(*ppszStr);
        *ppszStr = NULL;
        CMTRACE1(TEXT("ReadStringFromCache() failed, err=%u."), dwRes);
    }

    return (ERROR_SUCCESS == dwRes);
}

//+---------------------------------------------------------------------------
//
//  Function:   DeleteStringFromCache
//
//  Synopsis:   Delete the string from cache.
//
//  Arguments:  pArgs           ptr to ArgsStruct
//              pszEntryName    name to identify the cache entry
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
BOOL DeleteStringFromCache(
    ArgsStruct  *pArgs,
    LPTSTR      pszEntryName
)
{
    DWORD   dwRes;

    //
    // on NT, we use the Local Security Authority (LSA) services for storing
    // the string.  On Win95, we use mpr.dll.
    //
    if (OS_NT) 
    {
        if (InitLsa(pArgs)) 
        {
            dwRes = LSA_WriteString(pArgs, pszEntryName, NULL);
            DeInitLsa(pArgs);
        }
        else
        {
            dwRes = GetLastError();
        }
    }
    else
    {
        //
        // for Windows95
        //
        HINSTANCE   hInst = NULL;
        WORD (WINAPI *pfnFunc)(LPSTR,WORD,BYTE) = NULL;

        // Load MPR for system password cache support 
        
        MYVERIFY(hInst = LoadLibraryExA("mpr.dll", NULL, 0));
        
        // Get function ptr for WNetRemoveCachedPassword API and remove the string
        
        if (!hInst) 
        {
            return FALSE;
        }

        MYVERIFY(pfnFunc = (WORD (WINAPI *)(LPSTR,WORD,BYTE)) 
            GetProcAddress(hInst, "WNetRemoveCachedPassword"));

        if (!pfnFunc) 
        {
            FreeLibrary(hInst);
            return FALSE;
        }
       
        LPSTR pszAnsiEntryName = WzToSzWithAlloc(pszEntryName);
        
        if (pszAnsiEntryName)
        {
            dwRes = pfnFunc(pszAnsiEntryName, (WORD)lstrlenA(pszAnsiEntryName), CACHE_KEY_LEN);
        }
        else
        {
            dwRes = ERROR_NOT_ENOUGH_MEMORY;
        }

        CmFree (pszAnsiEntryName);

        FreeLibrary(hInst);
    }

#ifdef DEBUG
    if (dwRes)
    {
        CMTRACE1(TEXT("DeleteStringFromCache() LSA_WriteString/WNetRemoveCachedPassword() failed, err=%u."), dwRes);
    }
#endif

    return (ERROR_SUCCESS == dwRes);
}

//+---------------------------------------------------------------------------
//
//  Function:   RasSetCredsWrapper
//
//  Synopsis:   Wrapper to call RasSetCredential.  This function stores the
//              given string in the appropriate field of a RASCREDENTIALS struct
//              (based on the value in dwMask) and calls RasSetCredentials.
//               
//
//  Arguments:  pArgs           ptr to ArgsStruct
//              pszPhoneBook    Full path to the phonebook file, or NULL for 
//                              the default all user pbk
//              dwMask          dwMask value to set in the RASCREDENTIALS
//                              struct.  Currently must be one of RASCM_UserName, 
//                              RASCM_Domain, or RASCM_Password.
//              pszData         string data to set
//
//  Returns:    DWORD   ERROR_SUCCESS if successful, a windows error code otherwise
//
//----------------------------------------------------------------------------
DWORD RasSetCredsWrapper(
    ArgsStruct *pArgs,
    LPCTSTR pszPhoneBook,
    DWORD dwMask,
    LPCTSTR pszData
)
{
    DWORD dwRet = ERROR_INVALID_PARAMETER;
    BOOL fSavePassword = TRUE;

    MYDBGASSERT(pArgs && pArgs->rlsRasLink.pfnSetCredentials);
    MYDBGASSERT(pszData);
    MYDBGASSERT((RASCM_UserName == dwMask) || (RASCM_Domain == dwMask) || (RASCM_Password == dwMask));

    if (pArgs && pszData && pArgs->rlsRasLink.pfnSetCredentials)
    {
        LPTSTR pszConnectoid = GetRasConnectoidName(pArgs, pArgs->piniService, FALSE);

        if (pszConnectoid)
        {
            RASCREDENTIALS RasCredentials = {0};
            RasCredentials.dwSize = sizeof(RasCredentials);
            
            if (CM_CREDS_GLOBAL == pArgs->dwCurrentCredentialType)
            {
                RasCredentials.dwMask = dwMask | RASCM_DefaultCreds; 
            }
            else
            {
                RasCredentials.dwMask = dwMask; 
            }
            
            BOOL bClearPassword = FALSE;

            if (RASCM_UserName == dwMask)
            {
                lstrcpyU(RasCredentials.szUserName, pszData);
            }
            else if (RASCM_Domain == dwMask)
            {
                lstrcpyU(RasCredentials.szDomain, pszData);
            }
            else if (RASCM_Password == dwMask)
            {
                if (0 == lstrcmpU(c_pszSavedPasswordToken, pszData))
                {
                    //
                    // We have 16 *'s. This password is from the RAS cred store, 
                    // so we don't want to save the 16 *'s 
                    //
                    fSavePassword = FALSE;
                    dwRet = ERROR_SUCCESS;
                }
                else
                {
                    lstrcpyU(RasCredentials.szPassword, pszData);
                    bClearPassword = (TEXT('\0') == pszData[0]);
                }
            }
            else
            {
                CmFree(pszConnectoid);
                return ERROR_INVALID_PARAMETER;
            }

            if (fSavePassword)
            {
                dwRet = pArgs->rlsRasLink.pfnSetCredentials(pszPhoneBook, pszConnectoid, &RasCredentials, bClearPassword);

                if (ERROR_CANNOT_FIND_PHONEBOOK_ENTRY == dwRet)
                {
                    //
                    //  Then the phonebook entry doesn't exist yet, lets create it.
                    //
                    LPRASENTRY pRasEntry = (LPRASENTRY)CmMalloc(sizeof(RASENTRY));

                    if (pRasEntry && pArgs->rlsRasLink.pfnSetEntryProperties)
                    {
                        pRasEntry->dwSize = sizeof(RASENTRY);
                        dwRet = pArgs->rlsRasLink.pfnSetEntryProperties(pszPhoneBook, pszConnectoid, pRasEntry, pRasEntry->dwSize, NULL, 0);

                        //
                        //  Lets try to set the credentials one more time ...
                        //
                        if (ERROR_SUCCESS == dwRet)
                        {
                            dwRet = pArgs->rlsRasLink.pfnSetCredentials(pszPhoneBook, pszConnectoid, &RasCredentials, bClearPassword);
                        }

                        CmFree(pRasEntry);
                    }
                }
            }
            CmWipePassword(RasCredentials.szPassword);
            CmFree(pszConnectoid);
        }
    }

    return dwRet;
}


//+---------------------------------------------------------------------------
//
//  Function:   WriteUserInfoToRas
//
//  Synopsis:   Write a userinfo data to ras credential storage
//
//  Arguments:  pArgs           ptr to ArgsStruct
//              uiDataID        the resource ID associated with the data
//              pvData          userinfo data
//
//  Returns:    int    TRUE = success, FALSE = failure, returns -1 if RAS
//                     doesn't cache this piece of data and it should be put
//                     in the registry instead.
//
//----------------------------------------------------------------------------
int WriteUserInfoToRas(
    ArgsStruct  *pArgs,
    UINT        uiDataID,
    PVOID       pvData)
{
    int iReturn = -1;

    if (OS_NT5 && pArgs && pArgs->bUseRasCredStore)
    {
        DWORD dwMask;
        LPTSTR pszPhoneBook = NULL;

        switch (uiDataID)
        {
            case UD_ID_USERNAME:
                dwMask = RASCM_UserName;
                iReturn = (ERROR_SUCCESS == RasSetCredsWrapper(pArgs, pArgs->pszRasPbk, dwMask, (LPCTSTR)pvData));
                break;

            case UD_ID_PASSWORD:
                dwMask = RASCM_Password;
                iReturn = (ERROR_SUCCESS == RasSetCredsWrapper(pArgs, pArgs->pszRasPbk, dwMask, (LPCTSTR)pvData));
                MYDBGASSERT(iReturn);

                //
                //  Note that if we are using the same username then we want to write the password to both the
                //  password and the InetPassword storage.  This is because we don't actually have a password, just
                //  16 *'s.  This tells RAS to look in its internal store for the password.  The trouble is that if
                //  we don't cache the real password when we hand RAS the 16 *'s, it looks and finds a NULL password.
                //  Thus we keep both passwords the same and this avoids that problem.
                //
                if (pArgs->piniService->GPPB(c_pszCmSection, c_pszCmEntryUseSameUserName))
                {
                    pszPhoneBook = CreateRasPrivatePbk(pArgs);

                    if (pszPhoneBook)
                    {
                        iReturn = (ERROR_SUCCESS == RasSetCredsWrapper(pArgs, pszPhoneBook, dwMask, (LPCTSTR)pvData));
                        CmFree(pszPhoneBook);
                    }                
                }

                break;

            case UD_ID_DOMAIN:
                dwMask = RASCM_Domain;
                iReturn = (ERROR_SUCCESS == RasSetCredsWrapper(pArgs, pArgs->pszRasPbk, dwMask, (LPCTSTR)pvData));
                break;

            case UD_ID_INET_PASSWORD:
                dwMask = RASCM_Password;
                pszPhoneBook = CreateRasPrivatePbk(pArgs);

                if (pszPhoneBook)
                {
                    iReturn = (ERROR_SUCCESS == RasSetCredsWrapper(pArgs, pszPhoneBook, dwMask, (LPCTSTR)pvData));
                    CmFree(pszPhoneBook);
                }
                break;

            case UD_ID_INET_USERNAME:
                dwMask = RASCM_UserName;
                pszPhoneBook = CreateRasPrivatePbk(pArgs);

                if (pszPhoneBook)
                {
                    iReturn = (ERROR_SUCCESS == RasSetCredsWrapper(pArgs, pszPhoneBook, dwMask, (LPCTSTR)pvData));
                    CmFree(pszPhoneBook);
                }
                break;

            default:
                break;
        }
    }

    if ((0 != iReturn) && (-1 != iReturn))
    {
        if (CM_CREDS_GLOBAL == pArgs->dwCurrentCredentialType)
        {
            CMTRACE1(TEXT("WriteUserInfoToRas() - %s saved to the Global RAS Credential store"), TranslateUserDataID(uiDataID));
        }
        else
        {
            CMTRACE1(TEXT("WriteUserInfoToRas() - %s saved to the User RAS Credential store"), TranslateUserDataID(uiDataID));
        }
    }

    return iReturn;
}


//+---------------------------------------------------------------------------
//
//  Function:   WriteUserInfoToReg
//
//  Synopsis:   Write a userinfo data to the registry.
//
//  Arguments:  pArgs           ptr to ArgsStruct
//              uiDataID        the resource ID associated with the data
//              pvData          userinfo data
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
BOOL WriteUserInfoToReg(
    ArgsStruct  *pArgs,
    UINT        uiDataID,
    PVOID       pvData)
{
    MYDBGASSERT(pArgs);    
    MYDBGASSERT(pvData);    

    BOOL fRet = FALSE;
    UINT uiID = uiDataID; // can be changed in switch
    BYTE *lpData;

    if (NULL == pArgs || NULL == pvData)
    {
        return FALSE;
    }

    //
    // Determine Reg params based upon uiDataID
    //

    switch (uiID)
    {
        case UD_ID_USERNAME:
        case UD_ID_INET_USERNAME:
        case UD_ID_DOMAIN:
        case UD_ID_CURRENTACCESSPOINT:
        {    
            //
            // Store as strings
            //
                      
            DWORD dwSize = (lstrlenU((LPTSTR)pvData) + 1) * sizeof(TCHAR);            
            
            MYDBGASSERT(dwSize <= (UNLEN + sizeof(TCHAR))); // Make sure size is reasonable

            lpData = (BYTE *) pvData;

            fRet = WriteDataToReg(pArgs->szServiceName, uiID, REG_SZ, lpData, dwSize, pArgs->fAllUser);                
            break;
        }

        case UD_ID_PASSWORD:
        case UD_ID_INET_PASSWORD:
        {
            DWORD dwBufLen = 0;
            DWORD dwCrypt = 0;
            LPTSTR pszSubKey = BuildUserInfoSubKey(pArgs->szServiceName, pArgs->fAllUser);
            
            LPSTR pszAnsiSubKey = WzToSzWithAlloc(pszSubKey);
            
            if (UD_ID_INET_PASSWORD == uiID)
            {
                dwCrypt |= CMSECURE_ET_USE_SECOND_RND_KEY;
            }

            //
            // Encrypt
            //
            
            LPTSTR pszEncryptedData = EncryptPassword(pArgs, (LPTSTR) pvData, &dwBufLen, &dwCrypt, TRUE, pszAnsiSubKey);
            
            //
            // Free in case we return if the function failed
            //
            CmFree(pszSubKey);
            CmFree(pszAnsiSubKey);

            if (!pszEncryptedData)
            {
                return FALSE;
            }

            MYDBGASSERT(dwBufLen <= CM_MAX_PWD); // Can't read it out otherwise
            
            //
            // Write the password and the encryption type on success
            //
        
            if (WriteDataToReg(pArgs->szServiceName, uiID, REG_BINARY, (BYTE *) pszEncryptedData, dwBufLen, pArgs->fAllUser))                
            {
                //
                // A second write for the encryption type. Written as a DWORD.
                //

                uiID = UD_ID_PCS;           
                
                //
                // Now that we're UNICODE enabled, we will always be encrypting 
                // a UNICODE string, so update the crypt type, so that it can be
                // properly decrypted.
                //
                
                dwCrypt = AnsiToUnicodePcs(dwCrypt);
                
                lpData = (BYTE *) &dwCrypt;
            
                fRet = WriteDataToReg(pArgs->szServiceName, uiID, REG_DWORD, lpData, sizeof(DWORD), pArgs->fAllUser);                
            }

            // 
            // Release the buffer before we go
            // 
            
            CmFree(pszEncryptedData);

            
            break;
        }
        
        case UD_ID_NOPROMPT:
        case UD_ID_REMEMBER_PWD:
        case UD_ID_REMEMBER_INET_PASSWORD:
        case UD_ID_ACCESSPOINTENABLED:
        {            
            //
            // Store BOOL as DWORD
            //

            DWORD dwTmp = *(LPBOOL)pvData;            
            lpData = (BYTE *) &dwTmp;

            fRet = WriteDataToReg(pArgs->szServiceName, uiID, REG_DWORD, lpData, sizeof(DWORD), pArgs->fAllUser);                
            break;
        }

        default:
            break;
    }

    MYDBGASSERT(fRet);
    return fRet;
}

//+----------------------------------------------------------------------------
//
// Function:  WriteDataToReg
//
// Synopsis:  Stores the specified data as the specifed value under the 
//            specified key under the userinfo root.
//
// Arguments: LPCTSTR pszKey - The key name (service name)
//            UINT uiDataID - The resource ID, used to name the value 
//            DWORD dwType - The registry data type
//            CONST BYTE *lpData - Ptr to the data to be stored
//            DWORD cbData - The size of the data buffer
//            BOOL fAllUser - Flag indicating that profile is All-User
//
// Returns:   BOOL - TRUE on success, otherwise FALSE
//
// History:   nickball    Created   5/21/98
//
//+----------------------------------------------------------------------------
BOOL WriteDataToReg(
    LPCTSTR pszKey, 
    UINT uiDataID, 
    DWORD dwType, 
    CONST BYTE *lpData, 
    DWORD cbData,
    BOOL fAllUser)
{
    MYDBGASSERT(pszKey && *pszKey);
    MYDBGASSERT(lpData);

    HKEY    hKeyCm;
    DWORD   dwDisposition;
    DWORD   dwRes = 1;
    LPTSTR  pszSubKey; 

    if (NULL == pszKey || !*pszKey || NULL == lpData)
    {
        return FALSE;
    }
                  
    //
    // Per-user data is always stored under HKEY_CURRENT_USER
    // Build the sub key to be opened.
    //

    pszSubKey = BuildUserInfoSubKey(pszKey, fAllUser);

    if (NULL == pszSubKey)
    {
        return FALSE;
    }
    
    //
    // Open the sub key under HKCU
    //
    
    dwRes = RegCreateKeyExU(HKEY_CURRENT_USER,
                            pszSubKey,
                            0,
                            TEXT(""),
                            REG_OPTION_NON_VOLATILE,
                            KEY_SET_VALUE,
                            NULL,
                            &hKeyCm,
                            &dwDisposition);

    //
    // If we opened the key successfully, write the value
    //
    
    if (ERROR_SUCCESS == dwRes)
    {                        
        dwRes = RegSetValueExU(hKeyCm, 
                               TranslateUserDataID(uiDataID), 
                               NULL, 
                               dwType,
                               lpData, 
                               cbData);             
#ifdef DEBUG
        if (ERROR_SUCCESS == dwRes)
        {
            CMTRACE1(TEXT("WriteDataToReg() - %s written to registry"), TranslateUserDataID(uiDataID));
        }
#endif
        
        RegCloseKey(hKeyCm);
    }

    CmFree(pszSubKey);

    return (ERROR_SUCCESS == dwRes);
}

//+----------------------------------------------------------------------------
//
// Function:  DeleteDataFromReg
//
// Synopsis:  Deletes the specified value under the specified by uiDataID
//
// Arguments: LPCTSTR pszKey - The key name (service name)
//            UINT uiDataID - The resource ID, used to name the value 
//            BOOL fAllUser - Flag indicating that profile is All-User
//
// Returns:   BOOL - TRUE on success, otherwise FALSE
//
// History:   nickball    Created   5/21/98
//
//+----------------------------------------------------------------------------
BOOL DeleteDataFromReg(
    LPCTSTR pszKey, 
    UINT uiDataID,
    BOOL fAllUser)
{
    MYDBGASSERT(pszKey && *pszKey);

    HKEY    hKeyCm;
    DWORD   dwRes = 1;
    LPTSTR  pszSubKey; 

    if (NULL == pszKey || !*pszKey)
    {
        return FALSE;
    }
                  
    //
    // Per-user data is always stored under HKEY_CURRENT_USER
    // Build the sub key to be opened.
    //

    pszSubKey = BuildUserInfoSubKey(pszKey, fAllUser);

    if (NULL == pszSubKey)
    {
        return FALSE;
    }
    
    //
    // Open the sub key under HKCU
    //

    dwRes = RegOpenKeyExU(HKEY_CURRENT_USER,
                          pszSubKey,
                          0,
                          KEY_SET_VALUE,
                          &hKeyCm);
       
    //
    // If we opened the key successfully, delete the value
    //
    
    if (ERROR_SUCCESS == dwRes)
    {                        
        dwRes = RegDeleteValueU(hKeyCm, TranslateUserDataID(uiDataID));

        //
        // Delete the key used for encrypting the passwords
        //
        if (UD_ID_PASSWORD == uiDataID)
        {
            dwRes = RegDeleteValueU(hKeyCm, c_pszCmRegKeyEncryptedPasswordKey);
        }

        if (UD_ID_INET_PASSWORD == uiDataID)
        {
            dwRes = RegDeleteValueU(hKeyCm, c_pszCmRegKeyEncryptedInternetPasswordKey);
        }

#ifdef DEBUG
        if (ERROR_SUCCESS == dwRes)
        {
            CMTRACE1(TEXT("DeleteDataFromReg() - %s removed from registry"), TranslateUserDataID(uiDataID));
        }
#endif
                
        RegCloseKey(hKeyCm);
    }

    CmFree(pszSubKey);

    return (ERROR_SUCCESS == dwRes);
}

//+----------------------------------------------------------------------------
//
// Function:  GetDataFromReg
//
// Synopsis:  Allocates a buffer for and retrieves the specifed data from the
//            registry.
//
// Arguments: LPCTSTR pszKey - The key name (service name)
//            UINT uiDataID - The resource ID, used to name the value 
//            DWORD dwType - The registry data type 
//            DWORD dwSize - Numbrt of bytes in the data buffer
//            BOOL fAllUser - Flag indicating that profile is All-User
//
// Returns:   LPBYTE - Ptr to retrieved data, NULL on error
//
// History:   nickball    Created   5/21/98
//
//+----------------------------------------------------------------------------
LPBYTE GetDataFromReg(
    LPCTSTR pszKey, 
    UINT uiDataID, 
    DWORD dwType, 
    DWORD dwSize,
    BOOL fAllUser)
{    
    MYDBGASSERT(pszKey);

    DWORD dwSizeTmp = dwSize;
    DWORD dwTypeTmp = dwType;

    if (NULL == pszKey || !*pszKey)
    {
        return NULL;
    }

    //
    // Allocate a buffer of the desired size
    //

    LPBYTE lpData = (BYTE *) CmMalloc(dwSize);

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

    //
    // Read the data from the registry
    //

    if (!ReadDataFromReg(pszKey, uiDataID, &dwTypeTmp, lpData, &dwSizeTmp, fAllUser))
    {
        CmFree(lpData);
        lpData = NULL;
    }

    return lpData;
}
//+---------------------------------------------------------------------------
//
//  Function:   ReadUserInfoFromReg
//
//  Synopsis:   Read the specified userinfo data from the registry.
//
//  Arguments:  pArgs           ptr to ArgsStruct
//              uiDataID        the resource ID associated with the data
//              ppvData         ptr to ptr to be allocated and filled
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
BOOL ReadUserInfoFromReg(
    ArgsStruct  *pArgs,
    UINT        uiDataID,
    PVOID       *ppvData)
{
    MYDBGASSERT(pArgs);    
    MYDBGASSERT(ppvData);    

    BYTE *lpData = NULL;

    if (NULL == pArgs || NULL == ppvData)
    {
        return FALSE;
    }

    //
    // Set size and type as appropriate
    //

    switch (uiDataID)
    {
        case UD_ID_USERNAME:
        case UD_ID_INET_USERNAME:
        case UD_ID_DOMAIN: 
        case UD_ID_CURRENTACCESSPOINT:
        {    
            lpData =  GetDataFromReg(pArgs->szServiceName, uiDataID, REG_SZ, (UNLEN + 1) * sizeof(TCHAR), pArgs->fAllUser);           
            
            if (lpData)
            {
                *ppvData = lpData;            
            }
            
            break;
        }

        case UD_ID_PASSWORD:
        case UD_ID_INET_PASSWORD:            
        {    
            BYTE *lpTmp = NULL;

            //
            // Get the encryption type 
            //

            lpData = GetDataFromReg(pArgs->szServiceName, UD_ID_PCS, REG_DWORD, sizeof(DWORD), pArgs->fAllUser);

            if (!lpData)
            {
                return FALSE;
            }
            
            //
            // Since we know the return value in this case is a DWORD, then cast it to DWORD pointer 
            // and get the value
            //
            DWORD dwCrypt = *((DWORD*)lpData);
            CmFree(lpData);    

            //
            // Now retrieve the encrypted password
            //
            
            lpData = GetDataFromReg(pArgs->szServiceName, uiDataID, REG_BINARY, CM_MAX_PWD, pArgs->fAllUser);

            if (!lpData)
            {
                return FALSE;
            }

            //
            // Decrypt it
            //

            DWORD dwSize = lstrlenU((LPTSTR)lpData)*sizeof(TCHAR);

            //
            // Crypt routines only know about Ansi PCS values, so convert as necessary
            //
            LPTSTR pszSubKey = BuildUserInfoSubKey(pArgs->szServiceName, pArgs->fAllUser);           
            LPSTR pszAnsiSubKey = WzToSzWithAlloc(pszSubKey);

            if (UD_ID_INET_PASSWORD == uiDataID)
            {
                dwCrypt |= CMSECURE_ET_USE_SECOND_RND_KEY;
            }

            lpTmp = DecryptPassword(pArgs, (LPBYTE)lpData, UnicodeToAnsiPcs(dwCrypt), dwSize, TRUE, pszAnsiSubKey);

            //
            // Free the buffer for the reg query
            //

            CmFree(lpData);         
            
            //
            // We're Unicode now, so if the password was encrypted 
            // as an Ansi string convert the data to a UNICODE string.
            // Otherwise, just update the supplied buffer.
            //

            if (IsAnsiPcs(dwCrypt) && lpTmp)
            {
                *ppvData = SzToWzWithAlloc((LPSTR)lpTmp);
                CmFree(lpTmp);
            }
            else
            {
                *ppvData = lpTmp;            
            }

            //
            // Assign lpData for return purposes
            //

            lpData = (BYTE*) *ppvData;  // NULL on failure
            
            CmFree(pszSubKey);
            CmFree(pszAnsiSubKey);
            break;
        }

        case UD_ID_NOPROMPT:
        case UD_ID_REMEMBER_PWD:
        case UD_ID_REMEMBER_INET_PASSWORD:
        case UD_ID_ACCESSPOINTENABLED:
        {            
            lpData =  GetDataFromReg(pArgs->szServiceName, uiDataID, REG_DWORD, sizeof(DWORD), pArgs->fAllUser);

            if (lpData)
            {
                //
                // Translate to DWORD pointer and check the value
                //

                if (*((DWORD*)lpData))
                {
                    *(BOOL *)*ppvData = TRUE;
                }
                else
                {
                    *(BOOL *)*ppvData = FALSE;
                }
            
                CmFree(lpData);            
            }
            
            break;
        }

        default:
            MYDBGASSERT(FALSE);
            return FALSE;
    }           

    return (NULL != lpData); 
}

//+----------------------------------------------------------------------------
//
// Function:  ReadDataFromReg
//
// Synopsis:  Retrieves the data from the specifed value under the 
//            specified key under the userinfo root.
//
// Arguments: LPCTSTR pszKey - The key name (service name)
//            UINT uiDataID - The resource ID, used to name the value 
//            LPDWORD lpdwType - The registry data type expected, and returned
//            CONST BYTE *lpData - Ptr to buffer for data
//            LPDWORD lpcbData - The size of the data buffer
//            BOOL fAllUser - Flag indicating that profile is All-User
//
// Returns:   BOOL - TRUE on success, otherwise FALSE
//
// History:   nickball    Created   5/21/98
//
//+----------------------------------------------------------------------------
BOOL ReadDataFromReg(
    LPCTSTR pszKey, 
    UINT uiDataID, 
    LPDWORD lpdwType, 
    BYTE *lpData, 
    LPDWORD lpcbData,
    BOOL fAllUser)
{   
    MYDBGASSERT(pszKey && *pszKey);
    MYDBGASSERT(lpData);
    MYDBGASSERT(lpcbData);
    MYDBGASSERT(lpdwType);

    HKEY    hKeyCm;
    DWORD   dwRes = 1;
    DWORD   dwTypeTmp; // the value returned by query

    LPTSTR  pszSubKey; 

    if (NULL == pszKey || !*pszKey || NULL == lpData)
    {
        return FALSE;
    }
                  
    //
    // Per-user data is always stored under HKEY_CURRENT_USER
    // Build the sub key to be opened.
    //

    pszSubKey = BuildUserInfoSubKey(pszKey, fAllUser);

    if (NULL == pszSubKey)
    {
        return FALSE;
    }
    
    //
    // Open the sub key under HKCU
    //
    
    dwRes = RegOpenKeyExU(HKEY_CURRENT_USER,
                          pszSubKey,
                          0,
                          KEY_QUERY_VALUE,
                          &hKeyCm);
    //
    // If we opened the key successfully, retrieve the value
    //
    
    if (ERROR_SUCCESS == dwRes)
    {                        
        dwRes = RegQueryValueExU(hKeyCm, 
                                 TranslateUserDataID(uiDataID),
                                 NULL,
                                 &dwTypeTmp,
                                 lpData, 
                                 lpcbData);        
        
        if (ERROR_SUCCESS == dwRes)
        {
            CMTRACE1(TEXT("ReadDataFromReg() - %s read from registry"), TranslateUserDataID(uiDataID));
            MYDBGASSERT(*lpdwType == dwTypeTmp);

            if (*lpdwType == dwTypeTmp)
            {
                *lpdwType = dwTypeTmp;
            }
        }
        
        RegCloseKey(hKeyCm);
    }

    CmFree(pszSubKey);
    
    return (ERROR_SUCCESS == dwRes && (*lpdwType == dwTypeTmp)); // sanity check that type was expected
}

//+---------------------------------------------------------------------------
//
//  Function:   DeleteUserInfoFromReg
//
//  Synopsis:   Delete userinfo data from registry
//
//  Arguments:  pArgs           ptr to ArgsStruct
//              uiEntry         cmp field entry id
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
BOOL DeleteUserInfoFromReg(
    ArgsStruct  *pArgs,
    UINT        uiEntry
)
{
    return DeleteDataFromReg(pArgs->szServiceName, uiEntry, pArgs->fAllUser);
}

//+---------------------------------------------------------------------------
//
//  Function:   DeleteUserInfoFromRas
//
//  Synopsis:   Delete userinfo data from the RAS credential cache
//
//  Arguments:  pArgs           ptr to ArgsStruct
//              uiEntry         cmp field entry id
//
//  Returns:    int    TRUE = success, FALSE = failure, -1 if RAS doesn't
//                                                         store this info
//
//----------------------------------------------------------------------------
int DeleteUserInfoFromRas(
    ArgsStruct  *pArgs,
    UINT        uiEntry
)
{
    LPTSTR pszEmpty = TEXT("");

    return WriteUserInfoToRas(pArgs, uiEntry, pszEmpty);
}

//+---------------------------------------------------------------------------
//
//  Function:   ReadPasswordFromCmp
//
//  Synopsis:   Read a null terminated password string from Cmp.
//
//  Arguments:  pArgs           ptr to ArgsStruct
//              uiEntry         cmp entry name
//              ppszPassword    ptr to ptr of the password buffer.
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
BOOL ReadPasswordFromCmp(
    ArgsStruct  *pArgs,
    UINT        uiEntry,
    LPTSTR      *ppszPassword
)
{
    MYDBGASSERT(pArgs);
    MYDBGASSERT(ppszPassword);

    if (NULL == pArgs || NULL == ppszPassword)
    {
        return FALSE;
    }

    //
    // Read in password from profile
    //
    
    BOOL fOk = FALSE;

    LPTSTR pszEncryptedData = pArgs->piniProfile->GPPS(c_pszCmSection, TranslateUserDataID(uiEntry));

    if (*pszEncryptedData)
    {
        //
        // Trim away all the spaces at both ends
        //

        CmStrTrim(pszEncryptedData);

        //
        // Get the type and decrypt
        //
        
        DWORD dwEncryptionType = (DWORD)pArgs->piniProfile->GPPI(c_pszCmSection, 
                                                       c_pszCmEntryPcs,
                                                       CMSECURE_ET_RC2);   // default   
        //
        //  Since this was saved in the CMP in Ansi form, we need to convert the characters back to
        //  Ansi form so that we can decrypt them.  We still may not be able to (if we cannot
        //  round trip the Unicode conversion for instance) but then we will fail and display a
        //  blank password.  Not the end of the world but hopefully avoidable.
        //
        
        LPSTR pszAnsiEncryptedData;
        LPSTR pszAnsiUnEncryptedData;

        pszAnsiEncryptedData = WzToSzWithAlloc(pszEncryptedData);
        
        if (NULL != pszAnsiEncryptedData)
        {
            DWORD dwSize = lstrlenA(pszAnsiEncryptedData)*sizeof(TCHAR);
            
            //
            // Here we don't need to differentiate between main password and internet password
            // because we are reading this from a file and the mask is used when reading to/from 
            // registry.
            //

            pszAnsiUnEncryptedData = (LPSTR)DecryptPassword(pArgs, 
                                                            (LPBYTE)pszAnsiEncryptedData, 
                                                            dwEncryptionType, 
                                                            dwSize, 
                                                            FALSE,
                                                            NULL);

            if (pszAnsiUnEncryptedData)
            {
                *ppszPassword = SzToWzWithAlloc(pszAnsiUnEncryptedData);

                if (NULL != *ppszPassword)
                {
                    fOk = ((BOOL)**ppszPassword);
                }
                CmWipePasswordA(pszAnsiUnEncryptedData);
                CmFree(pszAnsiUnEncryptedData);
            }    
        }

        CmFree(pszAnsiEncryptedData);
    }

    CmFree(pszEncryptedData);

    return fOk;
}

//+---------------------------------------------------------------------------
//
//  Function:   ReadUserInfoFromCmp
//
//  Synopsis:   Read a userinfo data from cmp.
// 
//  Arguments:  pArgs           ptr to ArgsStruct
//              uiEntry         the cmp file entry
//              ppvData         ptr to ptr to the data buffer.  If the userinfo
//                              is multiple byte(e.g. password), the func allocs
//                              the buffer.
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
BOOL ReadUserInfoFromCmp(
    ArgsStruct  *pArgs,
    UINT        uiEntry,
    PVOID       *ppvData
)
{   
    switch (uiEntry)
    {
        case UD_ID_USERNAME:
        case UD_ID_INET_USERNAME:
        case UD_ID_DOMAIN:
            *ppvData = (PVOID)pArgs->piniProfile->GPPS(c_pszCmSection, TranslateUserDataID(uiEntry));
            break;

        case UD_ID_PASSWORD:
        case UD_ID_INET_PASSWORD:
            return ReadPasswordFromCmp(pArgs, uiEntry, (LPTSTR *)ppvData);
            break;

        case UD_ID_NOPROMPT:
        case UD_ID_REMEMBER_PWD:
        case UD_ID_REMEMBER_INET_PASSWORD:
            *(BOOL *)(*ppvData) = pArgs->piniProfile->GPPB(c_pszCmSection, TranslateUserDataID(uiEntry));
            break;

            //
            //  None of these should be in the CMP by this point.  Return a failure value.
            //
        case UD_ID_PCS:
        case UD_ID_ACCESSPOINTENABLED:
        case UD_ID_CURRENTACCESSPOINT: // if we are trying to read the access point
            CMASSERTMSG(FALSE, TEXT("ReadUserInfoFromCmp -- trying to read a value that should never be in the cmp, why?"));
            *ppvData = NULL;
            return FALSE;
            break;

        default:
            MYDBGASSERT(0);
            break;
    }

    return TRUE;
}

//+---------------------------------------------------------------------------
//
//  Function:   DeleteUserInfoFromCmp
//
//  Synopsis:   Deletes userinfo data from cmp.
// 
//  Arguments:  pArgs           ptr to ArgsStruct
//              uiEntry         the cmp file entry
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
BOOL DeleteUserInfoFromCmp(
    ArgsStruct  *pArgs,
    UINT        uiEntry
)
{
    BOOL bReturn = FALSE;
    UINT  uiKeepDefCreds = 0;
    const TCHAR* const c_pszKeepDefaultCredentials = TEXT("KeepDefaultCredentials"); 

    if (NULL == pArgs)
    {
        return bReturn;
    }

    switch (uiEntry)
    {
        case UD_ID_USERNAME:
        case UD_ID_DOMAIN:
        case UD_ID_INET_USERNAME:
        case UD_ID_NOPROMPT:
        case UD_ID_REMEMBER_PWD:
        case UD_ID_REMEMBER_INET_PASSWORD:
        case UD_ID_PASSWORD:
        case UD_ID_INET_PASSWORD:

            //
            // Get KeepDefaultCredentials value from CMP
            //
            uiKeepDefCreds = GetPrivateProfileIntU(c_pszCmSection, c_pszKeepDefaultCredentials, 0,
                                                   pArgs->piniProfile->GetFile());

            if (0 == uiKeepDefCreds) 
            {
                if (WritePrivateProfileStringU(c_pszCmSection, TranslateUserDataID(uiEntry), 
                                               NULL, pArgs->piniProfile->GetFile()))
                {
                    bReturn = TRUE;
                }
            }
            break;

        default:
            MYDBGASSERT(0);
            break;

    }
    return bReturn;
}

//+---------------------------------------------------------------------------
//
//  Function:   RasGetCredsWrapper
//
//  Synopsis:   Wrapper function to call RasGetCredentials.  The function
//              calls RasGetCredentials and then copies the appropriate data
//              from the RASCREDENTIALS struct into the buffer pointed to by
//              *ppvData (allocated on the caller behalf).  Note that the value
//              set in dwMask determines which data item is retrieved from the
//              credentials cache.  Currently, dwMask must be one of RASCM_UserName,
//              RASCM_Domain, or RASCM_Password.
// 
//  Arguments:  pArgs           ptr to ArgsStruct
//              pszPhoneBook    full path to the phonebook file to get the 
//                              data from, or NULL to use the all user default pbk
//              dwMask          dwMask value for the RASCREDENTIALS struct
//              ppvData         ptr to ptr to the data buffer.  If the userinfo
//                              is multiple byte(e.g. password), the func allocs
//                              the buffer.
//
//  Returns:    DWORD   ERROR_SUCCESS on success, winerror on failure
//
//----------------------------------------------------------------------------
DWORD RasGetCredsWrapper(
    ArgsStruct *pArgs,
    LPCTSTR pszPhoneBook,
    DWORD dwMask,
    PVOID *ppvData
)
{
    DWORD dwRet = ERROR_INVALID_PARAMETER;

    MYDBGASSERT(pArgs && pArgs->rlsRasLink.pfnGetCredentials);
    MYDBGASSERT(ppvData);
    MYDBGASSERT((RASCM_UserName == dwMask) || (RASCM_Domain == dwMask) || (RASCM_Password == dwMask));

    if (pArgs && ppvData && pArgs->rlsRasLink.pfnGetCredentials)
    {
        LPTSTR pszConnectoid = GetRasConnectoidName(pArgs, pArgs->piniService, FALSE);

        if (pszConnectoid)
        {
            RASCREDENTIALS RasCredentials = {0};
            RasCredentials.dwSize = sizeof(RasCredentials);
            
            if (CM_CREDS_GLOBAL == pArgs->dwCurrentCredentialType)
            {
                RasCredentials.dwMask = dwMask | RASCM_DefaultCreds;
            }
            else
            {
                RasCredentials.dwMask = dwMask; 
            }
            
            dwRet = pArgs->rlsRasLink.pfnGetCredentials(pszPhoneBook, pszConnectoid, &RasCredentials);

            if (ERROR_SUCCESS == dwRet)
            {
                LPTSTR pszData = NULL;

                if (RASCM_UserName == dwMask)
                {
                    pszData = RasCredentials.szUserName;
                }
                else if (RASCM_Domain == dwMask)
                {
                    pszData = RasCredentials.szDomain;                
                }
                else if (RASCM_Password == dwMask)
                {
                    pszData = RasCredentials.szPassword;
                }

                LPTSTR pszReturn = CmStrCpyAlloc(pszData);

                if (NULL == pszReturn)
                {
                    dwRet = ERROR_NOT_ENOUGH_MEMORY;
                }
                else
                {
                    *ppvData = pszReturn;
                }
            }

            CmWipePassword(RasCredentials.szPassword);

            CmFree(pszConnectoid);
        }
    }

    return dwRet;
}

//+---------------------------------------------------------------------------
//
//  Function:   ReadUserInfoFromRas
//
//  Synopsis:   Read userinfo data from the RAS credentials cache
// 
//  Arguments:  pArgs           ptr to ArgsStruct
//              uiEntry         the cmp file entry
//              ppvData         ptr to ptr to the data buffer.  If the userinfo
//                              is multiple byte(e.g. password), the func allocs
//                              the buffer.
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
BOOL ReadUserInfoFromRas(
    ArgsStruct  *pArgs,
    UINT        uiEntry,
    PVOID       *ppvData
)
{
    BOOL bReturn = FALSE;

    if (OS_NT5 && pArgs && pArgs->bUseRasCredStore)
    {
        DWORD dwMask;
        LPTSTR pszPhoneBook = NULL;

        switch (uiEntry)
        {
            case UD_ID_USERNAME:
                dwMask = RASCM_UserName;
                bReturn = (ERROR_SUCCESS == RasGetCredsWrapper(pArgs, pArgs->pszRasPbk, dwMask, ppvData));

                break;

            case UD_ID_PASSWORD:
                dwMask = RASCM_Password;
                bReturn = (ERROR_SUCCESS == RasGetCredsWrapper(pArgs, pArgs->pszRasPbk, dwMask, ppvData));
                break;

            case UD_ID_DOMAIN:
                dwMask = RASCM_Domain;
                bReturn = (ERROR_SUCCESS == RasGetCredsWrapper(pArgs, pArgs->pszRasPbk, dwMask, ppvData));
                break;

            case UD_ID_INET_PASSWORD:
                dwMask = RASCM_Password;
                pszPhoneBook = CreateRasPrivatePbk(pArgs);

                if (pszPhoneBook)
                {
                    bReturn = (ERROR_SUCCESS == RasGetCredsWrapper(pArgs, pszPhoneBook, dwMask, ppvData));
                    CmFree(pszPhoneBook);
                }
                break;

            case UD_ID_INET_USERNAME:
                dwMask = RASCM_UserName;
                pszPhoneBook = CreateRasPrivatePbk(pArgs);

                if (pszPhoneBook)
                {
                    bReturn = (ERROR_SUCCESS == RasGetCredsWrapper(pArgs, pszPhoneBook, dwMask, ppvData));
                    CmFree(pszPhoneBook);
                }
                break;
        }
    }

    if (bReturn)
    {
        if (CM_CREDS_GLOBAL == pArgs->dwCurrentCredentialType)
        {
            CMTRACE1(TEXT("ReadUserInfoFromRas() - %s retrieved from the Global RAS Credential store"), TranslateUserDataID(uiEntry));
        }
        else
        {
            CMTRACE1(TEXT("ReadUserInfoFromRas() - %s retrieved from the User RAS Credential store"), TranslateUserDataID(uiEntry));
        }
    }

    return bReturn;
}

//+---------------------------------------------------------------------------
//
//  Function:   GetUserInfo
//
//  Synopsis:   Get an userinfo.  The user info can reside in either the
//              cache, cmp, or registry.  This functions hides this from the
//              user.
//
//  We first try the cmp file.  If that fails, we try the cache.
//       We'll get the following user info:
//           username, 
//           password, 
//           domain,
//           remember main passwd,
//           dial automatically,
//           inet username,
//           inet passwd
//           remember inet password
//           inet use same user name
// 
//  Arguments:  pArgs           ptr to ArgsStruct
//              uiEntry         the cmp file entry
//              pvData          ptr to ptr to the data buffer.  If the userinfo
//                              is multiple byte(e.g. password), the func allocs
//                              the buffer.
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
BOOL GetUserInfo(
    ArgsStruct  *pArgs, 
    UINT        uiEntry,
    PVOID       *ppvData
)
{
    BOOL bReturn = ReadUserInfoFromRas(pArgs, uiEntry, ppvData);

    if (!bReturn)
    {
        bReturn = ReadUserInfoFromReg(pArgs, uiEntry, ppvData);        
    }

    if (!bReturn)
    {
        bReturn = ReadUserInfoFromCmp(pArgs, uiEntry, ppvData);
    }

    return bReturn;
}

//+---------------------------------------------------------------------------
//
//  Function:   SaveUserInfo
//
//  Synopsis:   Save an userinfo.  The user info can reside in either the
//              RAS cred cache or the registry.  This functions abstracts
//              this from the user.
//
//  We first try the RAS cred cache.  If the RAS cred cache doesn't hold that
//  piece of info we then save it in the registry.
//       We'll save the following user info:
//           username, 
//           password, 
//           domain,
//           remember main passwd,
//           dial automatically,
//           inet username,
//           inet passwd
//           remember inet password
//           inet use same user name
// 
//  Arguments:  pArgs           ptr to ArgsStruct
//              uiEntry         the cmp file entry
//              pvData          ptr to the data buffer.  If the userinfo is
//                              multiple byte(e.g. password), the func allocs
//                              the buffer.
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
BOOL SaveUserInfo(
    ArgsStruct  *pArgs, 
    UINT        uiEntry,
    PVOID       pvData
)
{
    //
    //  Try giving the Data to RAS first.  If the function returns
    //  -1, then this is data that RAS doesn't hold for us and we will
    //  have to put it in the registry instead.
    //
    int iReturn = WriteUserInfoToRas(pArgs, uiEntry, pvData);

    if (-1 == iReturn)
    {
        //
        // Just write the data to the registry. Use CMP only as
        // an upgrade reference for UserInfo data post CM 1.1
        //

        iReturn = WriteUserInfoToReg(pArgs, uiEntry, pvData);
    }

    return iReturn;
}

//+---------------------------------------------------------------------------
//
//  Function:   DeleteUserInfo
//
//  Synopsis:   Delete an userinfo.  The user info can reside in either the
//              RAS Cred cache or the registry.  This functions abstracts
//              this from the user.
//
//       We first try the RAS cache first.  If that piece of info isn't stored
//       in the RAS cache then we try the registry.
//
//       We'll delete the following user info:
//           username, 
//           password, 
//           domain,
//           remember main passwd,
//           dial automatically,
//           inet username,
//           inet passwd
//           remember inet password
//           inet use same user name
// 
//  Arguments:  pArgs           ptr to ArgsStruct
//              uiEntry         the cmp file entry
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
BOOL DeleteUserInfo(
    ArgsStruct  *pArgs, 
    UINT        uiEntry
)
{
    int iReturn = DeleteUserInfoFromRas(pArgs, uiEntry);

    if (-1 == iReturn)
    {
        iReturn = DeleteUserInfoFromReg(pArgs, uiEntry);
    }

    return iReturn;
}

//+---------------------------------------------------------------------------
//
//  Function:   NeedToUpgradeUserInfo
//
//  Synopsis:   Do we need to upgrade the cm 1.0/1.1 userinfo to the cm 1.2 format?
// 
//  Arguments:  pArgs - Ptr to global args struct
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
int NeedToUpgradeUserInfo(
    ArgsStruct  *pArgs)
{
    MYDBGASSERT(pArgs);

    DWORD dwRes;
    HKEY hKeyCm;
    LPTSTR pszSubKey;
    int iReturn = c_iNoUpgradeRequired;

    if (pArgs)
    {
        //
        //  If this is NT5 or greater, we want to be storing our credentials with RAS
        //  instead of the registry.  
        //
        //  If this isn't NT5 we still want to upgrade the user to using the registry as 
        //  storage instead of the cmp if they haven't already
        //  been upgraded.  Thus the simple test is to open the service name key in HKCU. 
        //  This key will exist, if the user has already run 1.2 bits.
        //

        pszSubKey = BuildUserInfoSubKey(pArgs->szServiceName, pArgs->fAllUser);

        dwRes = RegOpenKeyExU(HKEY_CURRENT_USER,
                              pszSubKey,
                              0,
                              KEY_QUERY_VALUE,
                              &hKeyCm);

        if (ERROR_SUCCESS == dwRes)
        {
            //
            //  Then we have the registry method, unless we are supposed to be using the RAS
            //  cred store we are done.  If we are supposed to be using the RAS cred store
            //  we need to check to make sure that we are using it.  Note we could have a problem
            //  here if the user has registry cred data and then their registry gets write protected.
            //  This would allow us to read from it but not delete the old data.  Thus the user
            //  would never be able to save any changes because we would always think they needed
            //  to upgrade.  An unlikely scenario but possible ...
            //

            if (pArgs->bUseRasCredStore)
            {
                LPTSTR pszUserName = NULL;

                BOOL bRet = ReadUserInfoFromReg(pArgs, UD_ID_USERNAME, (PVOID*)&pszUserName);

                if (bRet && (NULL != pszUserName) && (TEXT('\0') != pszUserName[0]))
                {
                    //
                    //  Then we have the username in the registry.  Lets upgrade to the RAS
                    //  credential store.
                    //
                    iReturn = c_iUpgradeFromRegToRas;
                }

                CmFree(pszUserName);
            }

            RegCloseKey(hKeyCm);
        }
        else
        {
            iReturn = c_iUpgradeFromCmp;
        }

        CmFree(pszSubKey);
    }
    else
    {
        CMASSERTMSG(FALSE, TEXT("NeedToUpgradeUserInfo -- NULL pArgs passed"));    
    }

    //
    // We don't want to upgrade if it's ICS. This prevents from adding info to the registry.
    //
    if (CM_LOGON_TYPE_ICS == pArgs->dwWinLogonType)
    {
        iReturn = c_iNoUpgradeRequired;
    }


    return iReturn;
}

//+---------------------------------------------------------------------------
//
//  Function:   UpgradeUserInfoFromRegToRasAndReg
//
//  Synopsis:   Upgrade the userinfo from CM 1.2 registry only format to the
//              CM 1.3 format which uses both RAS credential storage and
//              the registry.
// 
//  Arguments:  pArgs           ptr to ArgsStruct
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
BOOL UpgradeUserInfoFromRegToRasAndReg(
    ArgsStruct  *pArgs
)
{
    BOOL bReturn = FALSE;

    if (OS_NT5)
    {
        LPTSTR pszTmp;

        pszTmp = NULL;

        //
        // If we get an empty string "" from ReadUserInfoFromReg we don't want to 
        // save the empty string to the RAS Credstore because it might overwrite 
        // global credentials information. This can happen if User1 saves global
        // credentials and User2 tries using the same profile. Since User2 is running 
        // this profile for the 1st time, he'll run through an upgrade path and if global
        // creds exist we don't want to null them out.
        //
        
        if (ReadUserInfoFromReg(pArgs, UD_ID_INET_USERNAME, (PVOID*)&pszTmp))
        {
            DeleteUserInfoFromReg(pArgs, UD_ID_INET_USERNAME);
            if (pszTmp && lstrlenU(pszTmp))
            {
                WriteUserInfoToRas(pArgs, UD_ID_INET_USERNAME, pszTmp);
            }
            CmFree(pszTmp);
        }

        pszTmp = NULL;
        if (ReadUserInfoFromReg(pArgs, UD_ID_INET_PASSWORD, (PVOID*)&pszTmp))
        {
            DeleteUserInfoFromReg(pArgs, UD_ID_INET_PASSWORD);
            if (pszTmp && lstrlenU(pszTmp))
            {
                WriteUserInfoToRas(pArgs, UD_ID_INET_PASSWORD, pszTmp);
            }
            CmFree(pszTmp);
        }

        pszTmp = NULL;
        if (ReadUserInfoFromReg(pArgs, UD_ID_USERNAME, (PVOID*)&pszTmp))
        {
            DeleteUserInfoFromReg(pArgs, UD_ID_USERNAME);
            if (pszTmp && lstrlenU(pszTmp))
            {
                WriteUserInfoToRas(pArgs, UD_ID_USERNAME, pszTmp);
            }
            CmFree(pszTmp);
        }

        pszTmp = NULL;
        if (ReadUserInfoFromReg(pArgs, UD_ID_DOMAIN, (PVOID*)&pszTmp))
        {
            DeleteUserInfoFromReg(pArgs, UD_ID_DOMAIN);
            if (pszTmp && lstrlenU(pszTmp))
            {
                WriteUserInfoToRas(pArgs, UD_ID_DOMAIN, pszTmp);
            }
            CmFree(pszTmp);
        }

        pszTmp = NULL;
        if (ReadUserInfoFromReg(pArgs, UD_ID_PASSWORD, (PVOID*)&pszTmp))
        {
            DeleteUserInfoFromReg(pArgs, UD_ID_PASSWORD);
            if (pszTmp && lstrlenU(pszTmp))
            {
                WriteUserInfoToRas(pArgs, UD_ID_PASSWORD, pszTmp);
            }
            CmFree(pszTmp);
        }

        //
        //  Now delete the PCS value as it is no longer meaningful
        //
        DeleteUserInfoFromReg(pArgs, UD_ID_PCS);
    }
    else
    {
        MYDBGASSERT(FALSE);
    }


    return bReturn;
}


//+---------------------------------------------------------------------------
//
//  Function:   UpgradeUserInfoFromCmp
//
//  Synopsis:   Upgrade the userinfo from cm1.0/1,1 format to 1.3 format.
// 
//  Arguments:  pArgs           ptr to ArgsStruct
//
//  Returns:    BOOL    TRUE = success, FALSE = failure
//
//----------------------------------------------------------------------------
BOOL UpgradeUserInfoFromCmp(
    ArgsStruct  *pArgs
)
{
    LPTSTR      pszTmp;
    BOOL        fTmp;
    PVOID       pv;

    //
    // First retrieve each of the non-cached data items
    // Then delete username, internetusername, domain, password, 
    // internetpassword, remember password, remember internet password
    // and noprompt (dial automatically) from the CMP file.
    // If the KeepDefaultCredentials is set to 1 in the .CMP file then the 
    // DeleteUserInfoFromCmp function does not actually delete the values from 
    // the file.
    // If we get an empty string "" from ReadUserInfoFromCmp we don't want to 
    // save the empty string to the RAS Credstore because it might overwrite 
    // global credentials information. This can happen if User1 saves global
    // credentials and User2 tries using the same profile. Since User2 is running 
    // this profile for the 1st time, he'll run through an upgrade path and if global
    // creds exist we don't want to null them out.
    //

    pszTmp = NULL;
    ReadUserInfoFromCmp(pArgs, UD_ID_USERNAME, (PVOID*)&pszTmp);
    if (pszTmp && lstrlenU(pszTmp))
    {
        SaveUserInfo(pArgs, UD_ID_USERNAME, pszTmp);
    }
    DeleteUserInfoFromCmp(pArgs, UD_ID_USERNAME);
    CmFree(pszTmp);

    pszTmp = NULL;
    ReadUserInfoFromCmp(pArgs, UD_ID_DOMAIN, (PVOID*)&pszTmp);
    if (pszTmp && lstrlenU(pszTmp))
    {
        SaveUserInfo(pArgs, UD_ID_DOMAIN, pszTmp);
    }    
    DeleteUserInfoFromCmp(pArgs, UD_ID_DOMAIN);
    CmFree(pszTmp);

    pszTmp = NULL;
    ReadUserInfoFromCmp(pArgs, UD_ID_INET_USERNAME, (PVOID*)&pszTmp);
    if (pszTmp && lstrlenU(pszTmp))
    {
        SaveUserInfo(pArgs, UD_ID_INET_USERNAME, pszTmp);
    }
    DeleteUserInfoFromCmp(pArgs, UD_ID_INET_USERNAME);
    CmFree(pszTmp);

    pv = &fTmp;
    ReadUserInfoFromCmp(pArgs, UD_ID_NOPROMPT, &pv);
    SaveUserInfo(pArgs, UD_ID_NOPROMPT, pv);
    DeleteUserInfoFromCmp(pArgs, UD_ID_NOPROMPT);

    pv = &fTmp;
    ReadUserInfoFromCmp(pArgs, UD_ID_REMEMBER_PWD, &pv);
    SaveUserInfo(pArgs, UD_ID_REMEMBER_PWD, pv);
    DeleteUserInfoFromCmp(pArgs, UD_ID_REMEMBER_PWD);

    pv = &fTmp;
    ReadUserInfoFromCmp(pArgs, UD_ID_REMEMBER_INET_PASSWORD, &pv);
    SaveUserInfo(pArgs, UD_ID_REMEMBER_INET_PASSWORD, pv);
    DeleteUserInfoFromCmp(pArgs, UD_ID_REMEMBER_INET_PASSWORD);

    //
    // Construct old cache entry name
    //

    LPTSTR pszCacheEntryName = GetLegacyKeyName(pArgs);
    
    //
    // main passwd
    //
    pszTmp = NULL;
    
    //
    // To get the passwords, the cm 1.1 logic is that we first try the cmp, then the cache.
    //

    if (ReadUserInfoFromCmp(pArgs, UD_ID_PASSWORD, (PVOID*)&pszTmp))
    {
        if (pszTmp && lstrlenU(pszTmp))
        {
            SaveUserInfo(pArgs, UD_ID_PASSWORD, pszTmp);
        }
    }
    else
    {
        CmFree(pszTmp);
        pszTmp = NULL;

#ifdef  TEST_USERINFO_UPGRADE
    
        MYVERIFY(WriteStringToCache(pArgs, pszCacheEntryName, TEXT("CM 1.1 main password")));
#endif        
        
        //
        // Try to read it from cache
        //

        if (ReadStringFromCache(pArgs, pszCacheEntryName, &pszTmp))
        {
            if (pszTmp && lstrlenU(pszTmp))
            {
                if (SaveUserInfo(pArgs, UD_ID_PASSWORD, pszTmp))
                {

#ifdef  TEST_USERINFO_UPGRADE

                MYVERIFY(DeleteStringFromCache(pArgs, pszCacheEntryName));
#endif
                }
            }
        }
    }
    DeleteUserInfoFromCmp(pArgs, UD_ID_PASSWORD);
    CmFree(pszTmp);

    //
    // inet passwd
    //
    pszTmp = NULL;
    if (ReadUserInfoFromCmp(pArgs, UD_ID_INET_PASSWORD, (PVOID*)&pszTmp))
    {
        if (pszTmp && lstrlenU(pszTmp))
        {
            SaveUserInfo(pArgs, UD_ID_INET_PASSWORD, pszTmp);
        }
    }
    else
    {
        CmFree(pszTmp);
        pszTmp = NULL;

        //
        // Build tunnel entry name and read string from cache
        //
      
        pszCacheEntryName = CmStrCatAlloc(&pszCacheEntryName, TEXT("-tunnel"));

#ifdef  TEST_USERINFO_UPGRADE
        
        MYVERIFY(WriteStringToCache(pArgs, pszCacheEntryName, TEXT("CM 1.1 internet password")));
#endif
       
        if (ReadStringFromCache(pArgs, pszCacheEntryName, &pszTmp))
        {
            if (pszTmp && lstrlenU(pszTmp))
            {
                if (SaveUserInfo(pArgs, UD_ID_INET_PASSWORD, pszTmp))
                {

#ifdef  TEST_USERINFO_UPGRADE

                MYVERIFY(DeleteStringFromCache(pArgs, pszCacheEntryName));
#endif
                }
            }
        }
    }
    DeleteUserInfoFromCmp(pArgs, UD_ID_INET_PASSWORD);
    CmFree(pszTmp);

    CmFree(pszCacheEntryName);

    return TRUE; // MarkUserInfoUpgraded(pArgs);
}

//+----------------------------------------------------------------------------
//
// Function:  GetLegacyKeyName
//
// Synopsis:  Builds the string fragment used to build cache entry name. The "
//            sign-in" prefix is maintained for legacy compatibility
//
// Arguments: ArgsStruct *pArgs - Ptr to global args struct
//
// Returns:   LPTSTR - Ptr to allocated string containing "<service name> - Sign-In"
//
// Note:      Used exclusively for cache entry name construction
//
// History:   nickball    Created Header    4/16/98
//
//+----------------------------------------------------------------------------
LPTSTR GetLegacyKeyName(ArgsStruct *pArgs)
{
    MYDBGASSERT(pArgs);

    //
    // Service name is the basis of the key name. We also include 
    // IDMSG_TITLESERVICE and append a suffix of " (Connection Manager)"
    //

    LPTSTR pszRes = CmFmtMsg(g_hInst, IDMSG_TITLESERVICE, pArgs->szServiceName);
    
    MYDBGASSERT(pszRes && *pszRes);

    if (pszRes)
    {
        pszRes = CmStrCatAlloc(&pszRes, c_pszCacheEntryNameSuffix);
    }

    return (pszRes);
}

//+----------------------------------------------------------------------------
//
// Function:  EncryptPassword
//
// Synopsis:  Wrapper for encrypting password
//
// Arguments: ArgsStruct *pArgs - Ptr to global args struct
//            LPCTSTR pszPassword - The password to be encrypted
//            LPDWORD lpdwBufSize - Buffer for size of the encrypted buffer - optional
//            LPDWORD lpdwCryptType - Buffer for crypto type used
//            BOOL    fReg - Password is disguised for registry storage
//
// Returns:   LPTSTR - Ptr to allocated buffer containing encrypted form of password
//
// History:   nickball    Created Header    5/22/98
//
//+----------------------------------------------------------------------------

LPTSTR EncryptPassword(
    ArgsStruct *pArgs, 
    LPCTSTR pszPassword, 
    LPDWORD lpdwBufSize, 
    LPDWORD lpdwCryptType,
    BOOL /*fReg*/,
    LPSTR pszSubKey)
{
    MYDBGASSERT(pArgs);
    MYDBGASSERT(pszPassword);
    MYDBGASSERT(lpdwCryptType);
    DWORD dwEncryptedBufferLen;
    DWORD dwSize = 0;

    LPTSTR pszEncryptedData = NULL;
    TCHAR szSourceData[PWLEN + 1];

    if (NULL == pArgs || NULL == pszPassword || NULL == lpdwCryptType)
    { 
        return NULL;
    }

    //
    // Standard encryption, copy the password
    //

    lstrcpyU(szSourceData, pszPassword);
   
    //
    // It is not safe to call InitSecure more than once
    //
    if (!pArgs->fInitSecureCalled)
    {
        pArgs->fInitSecureCalled = TRUE;
        InitSecure(FALSE); // don't use fast encryption anymore
    }

    //
    // Encrypt the provided password
    //

    if (EncryptData(
            (LPBYTE)szSourceData, 
            (lstrlenU(szSourceData)+1) * sizeof(TCHAR),
            (LPBYTE*)&pszEncryptedData,
            &dwEncryptedBufferLen,
            lpdwCryptType,
#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
            pszSubKey))
#else
            (PFN_CMSECUREALLOC)CmMalloc,
            (PFN_CMSECUREFREE)CmFree,
            pszSubKey))
#endif
    {
        if (lpdwBufSize)
        {
            *lpdwBufSize = dwEncryptedBufferLen;
        }   
    }

    MYDBGASSERT(pszEncryptedData);
    
    CmWipePassword(szSourceData);
    return pszEncryptedData;
}

//+----------------------------------------------------------------------------
//
// Function:  DecryptPassword
//
// Synopsis:  Wrapper to decrypt password
//
// Arguments: ArgsStruct *pArgs - Ptr to global args struct
//            LPCTSTR pszEncryptedData - The encrypted data
//            DWORD dwEncryptionType - The encryption type of the data
//            BOOL    fReg - Password is disguised for registry storage
//
// Returns:   LPTSTR - Ptr to a buffer containing the decrypted form of the password.
//
// History:   nickball    Created     5/22/98
//
//+----------------------------------------------------------------------------
LPBYTE DecryptPassword(
    ArgsStruct *pArgs, 
    LPBYTE pszEncryptedData, 
    DWORD dwEncryptionType,
    DWORD dwEncryptedBytes,
    BOOL /*fReg*/,
    LPSTR pszSubKey)
{      
    MYDBGASSERT(pArgs);
    MYDBGASSERT(pszEncryptedData);
    
    DWORD dwDecryptedBufferLen;
    LPBYTE pszDecryptedData = NULL;

    if (NULL == pArgs || NULL == pszEncryptedData)
    { 
        return NULL;
    }

    //
    // It is not safe to call InitSecure more than once
    //

    if (!pArgs->fInitSecureCalled)
    {
        pArgs->fInitSecureCalled = TRUE;
        InitSecure(FALSE); // don't use fast encryption anymore
    }

    if (DecryptData(pszEncryptedData, dwEncryptedBytes, &pszDecryptedData, &dwDecryptedBufferLen,
                    dwEncryptionType, 
#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
             pszSubKey))

#else
                    (PFN_CMSECUREALLOC)CmMalloc, 
                    (PFN_CMSECUREFREE)CmFree,
                    pszSubKey))
#endif
    {
        return pszDecryptedData;
    }

    return NULL; 
}

//+----------------------------------------------------------------------------
//
// Function:  TranslateUserDataID
//
// Synopsis:  Wrapper to map user data ID to string name of .CMP entry
//
// Arguments: UINT uiDataID - UserInfo data ID to be translated
//
// Returns:   LPCTSTR - Ptr to a constant containing the .CMP entry flag
//
// History:   nickball    Created     10/13/98
//
//+----------------------------------------------------------------------------
LPCTSTR TranslateUserDataID(UINT uiDataID)
{   
    switch(uiDataID)
    {

    case UD_ID_USERNAME:
        return c_pszCmEntryUserName;
        break;

    case UD_ID_INET_USERNAME:
        return c_pszCmEntryInetUserName;
        break;

    case UD_ID_DOMAIN:
        return c_pszCmEntryDomain;
        break;

    case UD_ID_PASSWORD:
        return c_pszCmEntryPassword;
        break;

    case UD_ID_INET_PASSWORD:
        return c_pszCmEntryInetPassword;
        break;

    case UD_ID_NOPROMPT:
        return c_pszCmEntryNoPrompt;
        break;

    case UD_ID_REMEMBER_PWD:
        return c_pszCmEntryRememberPwd;
        break;
    
    case UD_ID_REMEMBER_INET_PASSWORD:
        return c_pszCmEntryRememberInetPwd;
        break;
 
    case UD_ID_PCS:
        return c_pszCmEntryPcs;
        break;

    case UD_ID_ACCESSPOINTENABLED:
        return c_pszCmEntryAccessPointsEnabled;
        break;

    case UD_ID_CURRENTACCESSPOINT:
        return c_pszCmEntryCurrentAccessPoint;
        break;

    default:
        break;
    }

    MYDBGASSERT(FALSE);
    return NULL;
}