windows-xp/Source/XPSP1/NT/net/winnet/mprreg.cxx

/*++

Copyright (c) 1991  Microsoft Corporation

Module Name:

    MPRREG.CXX

Abstract:

    Contains functions used by MPR to manipulate the registry.
        MprOpenKey
        MprGetKeyValue
        MprEnumKey
        MprGetKeyInfo
        MprFindDriveInRegistry
        I_MprSaveConn
        MprSaveDeferFlags
        MprSetRegValue
        MprCreateRegKey
        MprReadConnectionInfo
        MprForgetRedirConnection
        MprGetRemoteName


    QUESTIONS:
    1)  Do I need to call RegFlushKey after creating a new key?

Author:

    Dan Lafferty (danl) 12-Dec-1991

Environment:

    User Mode - Win32


Revision History:

    21-Feb-1997     AnirudhS
        Change MprRememberConnection to I_MprSaveConn and MprSaveDeferFlags
        for use by setup and by DEFER_UNKNOWN.

    12-Jun-1996     AnirudhS
        Got rid of the REMOVE_COLON/RESTORE_COLON scheme for converting
        device names to registry key names, since it caused writes to
        read-only input parameters.

    08-Mar-1996     AnirudhS
        Save the provider type, not the provider name, for persistent
        connections.  Fix old heap corruption bugs that show up when the
        user profile contains incomplete info.

    16-Jun-1995     AnirudhS
        Returned DWORDs rather than BOOLs from some functions; changed some
        formal parameters from LPWSTR to LPCWSTR.

    24-Nov-1992     Danl
        Fixed compiler warnings by always using HKEY rather than HANDLE.

    03-Sept-1992    Danl
        MprGetRemoteName:  Changed ERROR_BUFFER_OVERFLOW to WN_MORE_DATA.

    12-Dec-1991     danl
        Created

--*/

//
// Includes
//
#include "precomp.hxx"
#include <malloc.h>     // _alloca
#include <tstring.h>    // MEMCPY
#include <debugfmt.h>   // FORMAT_LPTSTR
#include <wincred.h>    // CRED_MAX_USERNAME_LENGTH


//
// Macros
//

//
// STACK_ALLOC
//
// Allocates space on the stack for a copy of an input string.  The result
// could be NULL if the string is too long to be copied on the stack.
//
#define STACK_ALLOC(str)  ((LPWSTR) _alloca((wcslen(str)+1)*sizeof(WCHAR)))



VOID
RemoveColon(
    LPWSTR  pszCopy,
    LPCWSTR pszSource
    )
/*++

Routine Description:

    This function makes a copy of a string and searches through the copy
    for a colon.  If a colon is found, it is replaced by a '\0'.

Arguments:

    pszCopy - Pointer to the space for the copy.

    pszSource - Pointer to the source string.

Return Value:

    None.

--*/
{
    wcscpy(pszCopy, pszSource);
    WCHAR * pColon = wcschr(pszCopy, L':');
    if (pColon != NULL)
    {
        *pColon = L'\0';
    }
}



BOOL
MprOpenKey(
    IN  HKEY    hKey,
    IN  LPTSTR  lpSubKey,
    OUT PHKEY   phKeyHandle,
    IN  DWORD   desiredAccess
    )

/*++

Routine Description:

    This function opens a handle to a key inside the registry.  The major
    handle and the path to the subkey are required as input.

Arguments:

    hKey - This is one of the well-known root key handles for the portion
        of the registry of interest.

    lpSubKey - A pointer a string containing the path to the subkey.

    phKeyHandle - A pointer to the location where the handle to the subkey
        is to be placed.

    desiredAccess - Desired Access (Either KEY_READ or KEY_WRITE or both).

Return Value:

    TRUE - The operation was successful

    FALSE - The operation was not successful.


--*/
{

    DWORD   status;
    REGSAM  samDesired = KEY_READ;
    HKEY HKCU ;

    if(desiredAccess & DA_WRITE) {
        samDesired = KEY_READ | KEY_WRITE;
    }
    else if (desiredAccess & DA_DELETE) {
        samDesired = DELETE;
    }

    HKCU = NULL ;

    if ( hKey == HKEY_CURRENT_USER ) {
        status = RegOpenCurrentUser(
                        MAXIMUM_ALLOWED,
                        &HKCU );

        if ( status != 0 )
        {
            return FALSE ;
        }

        hKey = HKCU ;
    }

    status = RegOpenKeyEx(
            hKey,                   // hKey
            lpSubKey,               // lpSubKey
            0L,                     // ulOptions (reserved)
            samDesired,             // desired access security mask
            phKeyHandle);           // Newly Opened Key Handle

    if ( HKCU )
    {
        RegCloseKey( HKCU );
    }

    if (status != NO_ERROR) {
        MPR_LOG3(ERROR,"MprOpenKey: RegOpenKeyEx(%#lx \"%ws\") failed %d\n",
                      hKey, lpSubKey, status);
        return (FALSE);
    }
    return(TRUE);
}

BOOL
MprGetKeyValue(
    IN  HKEY    KeyHandle,
    IN  LPTSTR  ValueName,
    OUT LPTSTR  *ValueString
    )

/*++

Routine Description:

    This function takes a key handle and a value name, and returns a value
    string that is associated with that name.

    NOTE:  The pointer to the ValueString is allocated by this function.

Arguments:

    KeyHandle - This is a handle for the registry key that contains the value.

    ValueName - A pointer to a string that identifies the value being
        obtained.

    ValueString - A pointer to a location that upon exit will contain the
        pointer to the returned value.

Return Value:

    TRUE - Success

    FALSE - A fatal error occured.

--*/
{
    DWORD       status;
    DWORD       maxValueLen;
    TCHAR       Temp[1];
    LPTSTR      TempValue;
    DWORD       ValueType;
    DWORD       NumRequired;
    DWORD       CharsReturned;

    //
    // Find the buffer size requirement for the value.
    //
    status = RegQueryValueEx(
                KeyHandle,          // hKey
                ValueName,          // lpValueName
                NULL,               // lpTitleIndex
                &ValueType,         // lpType
                NULL,               // lpData
                &maxValueLen);      // lpcbData

    if (status != NO_ERROR) {
        MPR_LOG2(ERROR,"MprGetKeyValue:RegQueryValueEx(\"%ws\") failed %d\n",
                        ValueName, status);
        *ValueString = NULL;
        return(FALSE);
    }

    //
    // Allocate buffer to receive the value string.
    //
    maxValueLen += sizeof(TCHAR);

    TempValue = (LPTSTR) LocalAlloc(LMEM_FIXED, maxValueLen);

    if(TempValue == NULL) {
        MPR_LOG(ERROR,"MprGetKeyValue:LocalAlloc failed\n", 0);
        *ValueString = NULL;
        return(FALSE);
    }

    //
    // Read the value.
    //
    status = RegQueryValueEx(
                KeyHandle,          // hKey
                ValueName,          // lpValueName
                NULL,               // lpTitleIndex
                &ValueType,         // lpType
                (LPBYTE)TempValue,  // lpData
                &maxValueLen);      // lpcbData

    if (status != NO_ERROR) {
        MPR_LOG2(ERROR,"MprGetKeyValue:RegQueryValueEx(\"%ws\") failed %d\n",
                        ValueName, status);
        LocalFree(TempValue);
        *ValueString = NULL;
        return(FALSE);
    }

    //
    // Make sure the value is null-terminated.  Strings obtained from
    // the registry may or may not be null-terminated.
    //
    TempValue [ maxValueLen / sizeof(TCHAR) ] = 0;

    //========================================================
    //
    // If the value is of REG_EXPAND_SZ type, then expand it.
    //
    //========================================================

    if (ValueType != REG_EXPAND_SZ) {
        *ValueString = TempValue;
        return(TRUE);
    }

    //
    // If the ValueType is REG_EXPAND_SZ, then we must call the
    // function to expand environment variables.
    //
    MPR_LOG(TRACE,"MprGetKeyValue: Must expand the string for "
        FORMAT_LPTSTR "\n", ValueName);

    //
    // Make the first call just to get the number of characters that
    // will be returned.
    //
    NumRequired = ExpandEnvironmentStrings (TempValue,Temp, 1);

    if (NumRequired > 1) {

        *ValueString = (LPTSTR) LocalAlloc(LPTR, (NumRequired+1)*sizeof(TCHAR));

        if (*ValueString == NULL) {

            MPR_LOG(ERROR, "MprGetKeyValue: LocalAlloc of numChar= "
                FORMAT_DWORD " failed \n",NumRequired );

            (void) LocalFree(TempValue);
            return(FALSE);
        }

        CharsReturned = ExpandEnvironmentStrings (
                            TempValue,
                            *ValueString,
                            NumRequired);

        (void) LocalFree(TempValue);

        if (CharsReturned > NumRequired || CharsReturned == 0) {
            MPR_LOG(ERROR, "MprGetKeyValue: ExpandEnvironmentStrings "
                " failed for " FORMAT_LPTSTR " \n", ValueName);

            (void) LocalFree(*ValueString);
            *ValueString = NULL;
            return(FALSE);
        }

        //
        // Now insert the NUL terminator.
        //
        (*ValueString)[CharsReturned] = 0;
    }
    else {
        //
        // This call should have failed because of our ridiculously small
        // buffer size.
        //

        MPR_LOG(ERROR, "MprGetKeyValue: ExpandEnvironmentStrings "
            " Should have failed because we gave it a BufferSize=1\n",0);

        //
        // This could happen if the string was a single character long and
        // didn't really have any environment values to expand.  In this
        // case, we return the TempValue buffer pointer.
        //
        *ValueString = TempValue;
    }

    return(TRUE);

}


BOOL
MprGetKeyDwordValue(
    IN  HKEY    KeyHandle,
    IN  LPCWSTR ValueName,
    OUT DWORD * Value
    )

/*++

Routine Description:

    This function takes a key handle and a value name, and returns a DWORD
    value that is associated with that name.

Arguments:

    KeyHandle - This is a handle for the registry key that contains the value.

    ValueName - A pointer to a string that identifies the value being
        obtained.  If this value does not have REG_DWORD type the function
        returns FALSE.

    Value - A pointer to a location that upon exit will contain the returned
        DWORD value.

Return Value:

    TRUE - Success

    FALSE - A fatal error occured.

--*/
{
    DWORD dwSize = sizeof(DWORD);
    DWORD dwType;
    DWORD status = RegQueryValueEx(
                        KeyHandle,
                        ValueName,
                        0,      // reserved
                        &dwType,   // type
                        (LPBYTE) Value,
                        &dwSize);

    if (status)
    {
        MPR_LOG2(ERROR,"MprGetKeyDwordValue: RegQueryValueEx(\"%ws\") failed %ld\n",
                        ValueName, status);
        return FALSE;
    }
    else if (dwType != REG_DWORD || dwSize != sizeof(DWORD))
    {
        MPR_LOG3(ERROR,"MprGetKeyDwordValue: RegQueryValueEx(\"%ws\") returned "
                       "type %ld, size %ld\n", ValueName, dwType, dwSize);
        return FALSE;
    }

    return TRUE;
}


LONG
MprGetKeyNumberValue(
    IN  HKEY    KeyHandle,
    IN  LPCWSTR ValueName,
    IN  LONG    Default
    )

/*++

Routine Description:

    This function takes a key handle and a value name, and returns a numeric
    value that is associated with that name.  If an error occurs while
    retrieving the value, the specified Default value is returned.

    For compatibility, the behavior of this function is exactly the same as
    Win95's RegEntry::GetNumber function.  The value is assumed to be a 4-byte
    type, such as REG_BINARY or REG_DWORD.  If this is not the case, the
    function does exactly the same as Win95.

Arguments:

    KeyHandle - This is a handle for the registry key that contains the value.

    ValueName - A pointer to a string that identifies the value being
        obtained.

    Default - Value to return if one could not be obtained from the registry.

Return Value:

    Value retrieved from the registry, or default if an error occurs.

--*/
{
    LONG    dwNumber;
    DWORD   dwSize = sizeof(dwNumber);

    DWORD error = RegQueryValueEx(
                        KeyHandle,
                        ValueName,
                        0,      // reserved
                        NULL,   // type
                        (LPBYTE) &dwNumber,
                        &dwSize);

    if (error)
        dwNumber = Default;

    return dwNumber;
}


BOOL
MprGetKeyStringValue(
    IN  HKEY    KeyHandle,
    IN  LPCWSTR ValueName,
    IN  DWORD   cchMaxValueLength,
    OUT LPWSTR  *Value
    )

/*++

Routine Description:

    This function takes a key handle, a value name, and a max size and allocates/returns
    a string value that is associated with that name.

Arguments:

    KeyHandle - This is a handle for the registry key that contains the value.

    ValueName - A pointer to a string that identifies the value being
        obtained.  If this value does not have REG_SZ type the function
        returns FALSE.

    cchMaxValueLength - Size of the OUT buffer to allocate, in characters.

    Value - A pointer to a location that upon exit will contain the returned
        LPWSTR value.

Return Value:

    TRUE - Success

    FALSE - A fatal error occured.

--*/
{
    DWORD status;
    DWORD dwType;
    DWORD dwSize = (cchMaxValueLength + 1) * sizeof(WCHAR);

    *Value = (LPWSTR) LocalAlloc(LMEM_ZEROINIT, dwSize);

    if (*Value == NULL)
    {
        return FALSE;
    }

    status = RegQueryValueEx(KeyHandle,
                             ValueName,
                             0,      // reserved
                             &dwType,   // type
                             (LPBYTE) *Value,
                             &dwSize);

    if (status || (dwSize % 2) != 0)
    {
        LocalFree(*Value);
        *Value = NULL;
        return FALSE;
    }

    if (dwType != REG_SZ)
    {
        //
        // Legacy -- MPR writes out a NULL username as a DWORD 0x0.  Make sure
        // these values are NULL-terminated
        //

        (*Value)[cchMaxValueLength] = L'\0';
        return TRUE;
    }

    return TRUE;
}


DWORD
MprEnumKey(
    IN  HKEY    KeyHandle,
    IN  DWORD   SubKeyIndex,
    OUT LPTSTR  *SubKeyName,
    IN  DWORD   MaxSubKeyNameLen
    )

/*++

Routine Description:

    This function obtains a single name of a subkey from the registry.
    A key handle for the primary key is passed in.  Subkeys are enumerated
    one-per-call with the passed in index indicating where we are in the
    enumeration.

    NOTE:  This function allocates memory for the returned SubKeyName.

Arguments:

    KeyHandle - Handle to the key whose sub keys are to be enumerated.

    SubKeyIndex - Indicates the number (index) of the sub key to be returned.

    SubKeyName - A pointer to the location where the pointer to the
        subkey name string is to be placed.

    MaxSubKeyNameLen - This is the length of the largest subkey.  This value
        was obtained from calling MprGetKeyInfo.  The length is in number
        of characters and does not include the NULL terminator.

Return Value:

    WN_SUCCESS - The operation was successful.

    STATUS_NO_MORE_SUBKEYS - The SubKeyIndex value was larger than the
        number of subkeys.

    error returned from LocalAlloc


--*/
{
    DWORD       status;
    FILETIME    lastWriteTime;
    DWORD       bufferSize;

    //
    // Allocate buffer to receive the SubKey Name.
    //
    // NOTE: Space is allocated for an extra character because in the case
    //  of a drive name, we need to add the trailing colon.
    //
    bufferSize = (MaxSubKeyNameLen + 2) * sizeof(TCHAR);
    *SubKeyName = (LPTSTR) LocalAlloc(LMEM_FIXED, bufferSize);

    if(*SubKeyName == NULL) {
        MPR_LOG(ERROR,"MprEnumKey:LocalAlloc failed %d\n", GetLastError());
        return(WN_OUT_OF_MEMORY);
    }

    //
    // Get the Subkey name at that index.
    //
    status = RegEnumKeyEx(
                KeyHandle,          // hKey
                SubKeyIndex,        // dwIndex
                *SubKeyName,        // lpName
                &bufferSize,        // lpcbName
                NULL,               // lpTitleIndex
                NULL,               // lpClass
                NULL,               // lpcbClass
                &lastWriteTime);    // lpftLastWriteTime

    if (status != NO_ERROR) {
        MPR_LOG(ERROR,"MprEnumKey:RegEnumKeyEx failed %d\n",status);
        LocalFree(*SubKeyName);
        return(status);
    }
    return(WN_SUCCESS);
}

BOOL
MprGetKeyInfo(
    IN  HKEY    KeyHandle,
    OUT LPDWORD TitleIndex    OPTIONAL,
    OUT LPDWORD NumSubKeys,
    OUT LPDWORD MaxSubKeyLen,
    OUT LPDWORD NumValues     OPTIONAL,
    OUT LPDWORD MaxValueLen
    )

/*++

Routine Description:



Arguments:

    KeyHandle - Handle to the key for which we are to obtain information.

    NumSubKeys - This is a pointer to a location where the number
        of sub keys is to be placed.

    MaxSubKeyLen - This is a pointer to a location where the length of
        the longest subkey name is to be placed.

    NumValues - This is a pointer to a location where the number of
        key values is to be placed. This pointer is optional and can be
        NULL.

    MaxValueLen - This is a pointer to a location where the length of
        the longest data value is to be placed.


Return Value:

    TRUE - The operation was successful.

    FALSE - A failure occured.  The returned values are not to be believed.

--*/

{
    DWORD       status;
    DWORD       maxClassLength;
    DWORD       numValueNames;
    DWORD       maxValueNameLength;
    DWORD       securityDescLength;
    FILETIME    lastWriteTime;

    //
    // Get the Key Information
    //

    status = RegQueryInfoKey(
                KeyHandle,
                NULL,                   // Class
                NULL,                   // size of class buffer (in bytes)
                NULL,                   // DWORD to receive title index
                NumSubKeys,             // number of subkeys
                MaxSubKeyLen,           // length(chars-no null) of longest subkey name
                &maxClassLength,        // length of longest subkey class string
                &numValueNames,         // number of valueNames for this key
                &maxValueNameLength,    // length of longest ValueName
                MaxValueLen,            // length of longest value's data field
                &securityDescLength,    // lpcbSecurityDescriptor
                &lastWriteTime);        // the last time the key was modified

    if (status != 0)
    {
        MPR_LOG(ERROR,"MprGetKeyInfo: RegQueryInfoKey Error %d\n",status);
        return(FALSE);
    }

    if (NumValues != NULL) {
        *NumValues = numValueNames;
    }

    //
    // Support for title index has been removed from the Registry API.
    //
    if (TitleIndex != NULL) {
        *TitleIndex = 0;
    }

    return(TRUE);
}

BOOL
MprFindDriveInRegistry (
    IN     LPCTSTR  DriveName,
    IN OUT LPTSTR   *pRemoteName
    )

/*++

Routine Description:

    This function determines whether a particular re-directed drive
    name resides in the network connection section of the current user's
    registry path.  If the drive is already "remembered" in this section,
    this function returns TRUE.

Arguments:

    DriveName - A pointer to a string containing the name of the redirected
        drive.

    pRemoteName - If the DriveName is found in the registry, and if this
        is non-null, the remote name for the connection is read, and a
        pointer to the string is stored in this pointer location.
        If the remote name cannot be read from the registry, a NULL
        pointer is returned in this location.


Return Value:

    TRUE  - The redirected drive is "remembered in the registry".
    FALSE - The redirected drive is not saved in the registry.

--*/
{
    BOOL    bStatus = TRUE;
    HKEY    connectKey = NULL;
    HKEY    subKey = NULL;

    LPWSTR  KeyName = STACK_ALLOC(DriveName);
    if (KeyName == NULL) {
        return FALSE;
    }
    RemoveColon(KeyName, DriveName);

    //
    // Get a handle for the connection section of the user's registry
    // space.
    //
    if (!MprOpenKey(
            HKEY_CURRENT_USER,
            CONNECTION_KEY_NAME,
            &connectKey,
            DA_READ)) {

        MPR_LOG(ERROR,"MprFindDriveInRegistry: MprOpenKey Failed\n",0);
        return (FALSE);
    }

    if (!MprOpenKey(
            connectKey,
            KeyName,
            &subKey,
            DA_READ)) {

        MPR_LOG(TRACE,"MprFindDriveInRegistry: Drive %s Not Found\n",DriveName);
        bStatus = FALSE;
    }
    else {
        //
        // The drive was found in the registry, if the caller wants to have
        // the RemoteName, then get it.
        //
        if (pRemoteName != NULL) {

            //
            // Get the RemoteName (memory is allocated by this function)
            //

            if(!MprGetKeyValue(
                    subKey,
                    REMOTE_PATH_NAME,
                    pRemoteName)) {

                MPR_LOG(TRACE,"MprFindDriveInRegistry: Could not read "
                    "Remote path for Drive %ws \n",DriveName);
                pRemoteName = NULL;
            }
        }
    }

    if ( subKey )
        RegCloseKey(subKey);
    if ( connectKey )
        RegCloseKey(connectKey);

    return(bStatus);
}


DWORD
I_MprSaveConn(
    IN HKEY             HiveRoot,
    IN LPCWSTR          ProviderName,
    IN DWORD            ProviderType,
    IN LPCWSTR          UserName,
    IN LPCWSTR          LocalName,
    IN LPCWSTR          RemoteName,
    IN DWORD            ConnectionType,
    IN BYTE             ProviderFlags,
    IN DWORD            DeferFlags
    )
/*++

Routine Description:

    Writes the information about a connection to the network connection
    section of a user's registry path.

    NOTE:  If connection information is already stored in the registry for
    this drive, the current information will be overwritten with the new
    information.

Arguments:

    HiveRoot - A handle to the root of the user hive in which this
        information should be written, such as HKEY_CURRENT_USER.

    ProviderName - The provider that completed the connection.

    ProviderType - The provider type, if known.  If not known, zero should
        be passed, and a type will not be written to the registry.  (This
        is used by setup when upgrading from Win95 to NT.)

    UserName - The name of the user on whose behalf the connection was made.

    LocalName - The name of the local device that is redirected, with or
        without a trailing colon, such as "J" or "J:" or "LPT1".

    RemoteName - The network path to which the connection was made.

    ConnectionType - either RESOURCETYPE_DISK or RESOURCETYPE_PRINT.

    ProviderFlags - A byte of data to be saved along with the connection,
        and passed back to the provider when the connection is restored.

    DeferFlags - A DWORD to be saved in the connection's "Defer" value.  If
        this is zero, the value is not stored.
        The meaning of the bits of this DWORD are as follows:
        DEFER_EXPLICIT_PASSWORD - a password was explicitly specified when
        the connection was made.
        DEFER_UNKNOWN - it is not known whether a password was explicitly
        specified when the connection was made.
        DEFER_DEFAULT_CRED - The provider believes that default creds were
            used when the connection was made.

Return Value:

    ERROR_SUCCESS - If the operation was successful.

    Other Win32 errors - If the operation failed in any way.  If a failure
        occurs, the information is not stored in the registry.

--*/
{
    HKEY    connectKey;
    HKEY    localDevHandle;
    LPCTSTR pUserName;
    DWORD   status, IgnoredStatus;

    //
    // Remove the colon on the name since the registry doesn't like
    // this in a key name.
    //
    LPWSTR KeyName = STACK_ALLOC(LocalName);
    if (KeyName == NULL) {
        return ERROR_NOT_ENOUGH_MEMORY;
    }
    RemoveColon(KeyName, LocalName);

    //
    // Get a handle for the connection section of the user's registry
    // space.
    //
    if ((status = MprCreateRegKey(
            HiveRoot,
            CONNECTION_KEY_NAME,
            &connectKey)) != ERROR_SUCCESS) {

        MPR_LOG(ERROR,"I_MprSaveConn: \\HKEY_CURRENT_USER\\network "
                      "could not be opened or created, error %ld\n", status);
        return(status);
    }

    //
    // Get (or create) the handle for the local name (without colon).
    //
    if ((status = MprCreateRegKey(
            connectKey,
            KeyName,
            &localDevHandle)) != ERROR_SUCCESS) {

        MPR_LOG(ERROR,"I_MprSaveConn: MprCreateRegKey Failed, "
                      "error %ld\n", status);
        RegCloseKey(connectKey);
        return(status);
    }


    //
    // Now that the key is created, store away the appropriate values.
    //

    MPR_LOG(TRACE,"RememberConnection: Setting RemotePath\n",0);

    if((status = MprSetRegValue(
            localDevHandle,
            REMOTE_PATH_NAME,
            RemoteName,
            0)) != ERROR_SUCCESS) {

        MPR_LOG(ERROR,
            "I_MprSaveConn: MprSetRegValueFailed %lu - RemotePath\n",status);
        goto CleanExit;
    }

    MPR_LOG(TRACE,"RememberConnection: Setting User\n",0);

    pUserName = UserName;
    if (UserName == NULL) {
        pUserName = TEXT("");
    }
    if((status = MprSetRegValue(
            localDevHandle,
            USER_NAME,
            pUserName,
            0)) != ERROR_SUCCESS) {

        goto CleanExit;
    }

    MPR_LOG(TRACE,"RememberConnection: Setting ProviderName\n",0);
    if((status = MprSetRegValue(
            localDevHandle,
            PROVIDER_NAME,
            ProviderName,
            0)) != ERROR_SUCCESS) {

        goto CleanExit;
    }

    if (ProviderType != 0)
    {
        MPR_LOG(TRACE,"RememberConnection: Setting ProviderType\n",0);
        if((status = MprSetRegValue(
                localDevHandle,
                PROVIDER_TYPE,
                NULL,
                ProviderType)) != ERROR_SUCCESS) {

            goto CleanExit;
        }
    }
    // else RegDeleteValue -- not done because ProviderType is 0 only
    // during upgrade, while writing to a fresh user hive

    MPR_LOG(TRACE,"RememberConnection: Setting ConnectionType\n",0);
    if((status = MprSetRegValue(
            localDevHandle,
            CONNECTION_TYPE,
            NULL,
            ConnectionType)) != ERROR_SUCCESS) {

        goto CleanExit;
    }

    if (ProviderFlags != 0)
    {
        MPR_LOG(TRACE,"RememberConnection: Setting ProviderFlags\n",0);
        if((status = MprSetRegValue(
                localDevHandle,
                PROVIDER_FLAGS,
                NULL,
                ProviderFlags)) != ERROR_SUCCESS) {

            goto CleanExit;
        }
    }

    // We can't roll this back if something fails after it, so we
    // must do this last
    if ((status = MprSaveDeferFlags(localDevHandle, DeferFlags))
        != ERROR_SUCCESS) {

        goto CleanExit;
    }

    //
    // Flush the new key, and then close the handle to it.
    //

    MPR_LOG(TRACE,"RememberConnection: Flushing Registry Key\n",0);

    IgnoredStatus = RegFlushKey(localDevHandle);
    if (IgnoredStatus != NO_ERROR) {
        MPR_LOG(ERROR,"RememberConnection: Flushing Registry Key Failed %ld\n",
        IgnoredStatus);
    }

CleanExit:
    RegCloseKey(localDevHandle);
    if (status != ERROR_SUCCESS) {
        IgnoredStatus = RegDeleteKey(connectKey, KeyName);
        if (IgnoredStatus != NO_ERROR) {
            MPR_LOG(ERROR, "RememberConnection: RegDeleteKey Failed %d\n", IgnoredStatus);
        }
    }
    RegCloseKey(connectKey);
    return(status);

}


DWORD
MprSaveDeferFlags(
    IN HKEY     RegKey,
    IN DWORD    DeferFlags
    )
{
    DWORD status;

    if (DeferFlags == 0)
    {
        MPR_LOG0(TRACE,"Removing DeferFlags\n");
        status = RegDeleteValue(RegKey, DEFER_FLAGS);
        if (status == ERROR_FILE_NOT_FOUND)
        {
            status = ERROR_SUCCESS;
        }
    }
    else
    {
        MPR_LOG(TRACE,"Setting DeferFlags %#lx\n",DeferFlags);
        status = MprSetRegValue(
                    RegKey,
                    DEFER_FLAGS,
                    NULL,
                    DeferFlags);
    }

    return status;
}


DWORD
MprSetRegValue(
    IN  HKEY    KeyHandle,
    IN  LPTSTR  ValueName,
    IN  LPCTSTR ValueString,
    IN  DWORD   LongValue
    )

/*++

Routine Description:

    Stores a single ValueName and associated data in the registry for
    the key identified by the KeyHandle.  The data associated with the
    value can either be a string or a 32-bit LONG.  If the ValueString
    argument contains a pointer to a value, then the LongValue argument
    is ignored.

Arguments:

    KeyHandle - Handle of the key for which the value entry is to be set.

    ValueName - Pointer to a string that contains the name of the value
        being set.

    ValueString - Pointer to a string that is to become the data stored
        at that value name.  If this argument is not present, then the
        LongValue argument is the data stored at the value name.  If this
        argument is present, then LongValue is ignored.

    LongValue - A LONG sized data value that is to be stored at the
        value name.

Return Value:

    Win32 error from RegSetValueEx (0 = success)

--*/
{
    DWORD   status;
    const BYTE * valueData;
    DWORD   valueSize;
    DWORD   valueType;

    if( ARGUMENT_PRESENT(ValueString)) {
        valueData = (const BYTE *)ValueString;
        valueSize = STRSIZE(ValueString);
        valueType = REG_SZ;
    }
    else {
        valueData = (const BYTE *)&LongValue;
        valueSize = sizeof(DWORD);
        valueType = REG_DWORD;
    }
    status = RegSetValueEx(
                KeyHandle,      // hKey
                ValueName,      // lpValueName
                0,              // dwValueTitle (OPTIONAL)
                valueType,      // dwType
                valueData,      // lpData
                valueSize);     // cbData

    if(status != NO_ERROR) {
        MPR_LOG3(ERROR,"MprSetRegValue: RegSetValueEx(%#lx \"%ws\") Failed %ld\n",
                      KeyHandle, ValueName, status);
    }
    return(status);
}


DWORD
MprCreateRegKey(
    IN  HKEY    BaseKeyHandle,
    IN  LPCTSTR KeyName,
    OUT PHKEY   KeyHandlePtr
    )

/*++

Routine Description:

    Creates a key in the registry at the location described by KeyName.

Arguments:

    BaseKeyHandle - This is a handle for the base (parent) key - where the
        subkey is to be created.

    KeyName - This is a pointer to a string that describes the path to the
        key that is to be created.

    KeyHandle - This is a pointer to a location where the the handle for the
        newly created key is to be placed.

Return Value:

    Win32 error from RegCreateKeyEx (0 = success)

Note:


--*/
{
    DWORD       status;
    DWORD       disposition;


    //
    // Create the new key.
    //
    status = RegCreateKeyEx(
                BaseKeyHandle,          // hKey
                KeyName,                // lpSubKey
                0L,                     // dwTitleIndex
                TEXT("GenericClass"),   // lpClass
                0,                      // ulOptions
                KEY_WRITE,              // samDesired (desired access)
                NULL,                   // lpSecurityAttrubutes (Security Descriptor)
                KeyHandlePtr,           // phkResult
                &disposition);          // lpulDisposition

    if (status != NO_ERROR) {
        MPR_LOG3(ERROR,"MprCreateRegKey: RegCreateKeyEx(%#lx, \"%ws\") failed %d\n",
                    BaseKeyHandle, KeyName, status);
    }
    else {
        MPR_LOG(TRACE,"MprCreateRegKey: Disposition = 0x%x\n",disposition);
    }
    return(status);
}



BOOL
MprReadConnectionInfo(
    IN  HKEY            KeyHandle,
    IN  LPCTSTR         DriveName,
    IN  DWORD           Index,
    OUT LPDWORD         ProviderFlags,
    OUT LPDWORD         DeferFlags,
    OUT LPTSTR          *UserNamePtr,
    OUT LPNETRESOURCEW  NetResource,
    OUT HKEY            *SubKeyHandleOut,
    IN  DWORD           MaxSubKeyLen
    )

/*++

Routine Description:

    This function reads the data associated with a connection key.
    Buffers are allocated to store:

        UserName, RemoteName, LocalName, Provider

    Pointers to those buffers are returned.

    Also the connection type is read and stored in the NetResource structure.

    If the provider type is found in the registry, and a matching provider
    type is found in the GlobalProviderInfo array, the provider name is not
    read from the registry.  Instead it is read from the GlobalProviderInfo
    array.

    If the provider name is read from the registry and a matching provider
    name is found in the GlobalProviderInfo array, the provider type is
    written to the registry.

Arguments:

    KeyHandle - This is an already opened handle to the key whose
        sub-keys are to be enumerated.

    DriveName - This is the local name of the drive (eg. "f:") for which
        the connection information is to be obtained.  If DriveName is
        NULL, then the Index is used to enumerate the keyname.  Then
        that keyname is used.

    Index - This is the index that identifies the subkey for which we
        would like to receive information.

    ProviderFlags - This is a pointer to a location where the ProviderFlags
        value stored with the connection will be placed.  If this value
        cannot be retrieved, 0 will be placed here.

    DeferFlags - This is a pointer to a location where the DeferFlags
        value stored with the connection will be placed.  If this value
        cannot be retrieved, 0 will be placed here.

    UserNamePtr - This is a pointer to a location where the pointer to the
        UserName string is to be placed.  If there is no user name, a
        NULL pointer will be returned.

    NetResource - This is a pointer to a NETRESOURCE structure where
        information such as lpRemoteName, lpLocalName, lpProvider, and Type
        are to be placed.

    SubKeyHandleOut - This is a pointer to a location where the handle to
        the subkey that holds information about this connection will be
        placed.  This may be NULL.  If it is not NULL the caller must close
        the handle.

Return Value:



Note:


--*/
{
    DWORD           status = NO_ERROR;
    LPTSTR          driveName = NULL;
    HKEY            subKeyHandle = NULL;
    DWORD           cbData;
    DWORD           ProviderType = 0;
    LPPROVIDER      Provider;

    //
    // Initialize the Pointers that are to be updated.
    //
    *UserNamePtr = NULL;
    NetResource->lpLocalName = NULL;
    NetResource->lpRemoteName = NULL;
    NetResource->lpProvider = NULL;
    NetResource->dwType = 0L;

    //
    // If we don't have a DriveName, then get one by enumerating the
    // next key name.
    //

    if (DriveName == NULL) {
        //
        // Get the name of a subkey of the network connection key.
        // (memory is allocated by this function).
        //
        status = MprEnumKey(KeyHandle, Index, &driveName, MaxSubKeyLen);
        if (status != WN_SUCCESS) {
            return(FALSE);
        }
    }
    else {
        //
        // We have a drive name, alloc new space and copy it to that
        // location.
        //
        driveName = (LPTSTR) LocalAlloc(LMEM_FIXED, STRSIZE(DriveName));
        if (driveName == NULL) {
            MPR_LOG(ERROR, "MprReadConnectionInfo: Local Alloc Failed %d\n",
                GetLastError());
            return(FALSE);
        }

        RemoveColon(driveName, DriveName);
    }

    MPR_LOG1(TRACE,"MprReadConnectionInfo: LocalName = %ws\n",driveName);

    //
    // Open the sub-key
    //
    if (!MprOpenKey(
            KeyHandle,
            driveName,
            &subKeyHandle,
            DA_WRITE)){

        status = WN_BAD_PROFILE;
        MPR_LOG1(TRACE,"MprReadConnectionInfo: Could not open %ws Key\n",driveName);
        goto CleanExit;
    }

    //
    // Add the trailing colon to the driveName.
    //
    cbData = STRLEN(driveName);
    driveName[cbData]   = TEXT(':');
    driveName[cbData+1] = TEXT('\0');

    //
    // Store the drive name in the return structure.
    //
    NetResource->lpLocalName = driveName;

    //
    // Get the RemoteName (memory is allocated by this function)
    //

    if(!MprGetKeyValue(
            subKeyHandle,
            REMOTE_PATH_NAME,
            &(NetResource->lpRemoteName))) {

        status = WN_BAD_PROFILE;
        MPR_LOG0(TRACE,"MprReadConnectionInfo: Could not get RemoteName\n");
        goto CleanExit;
    }

    //
    // Get the UserName (memory is allocated by this function)
    //

    if(!MprGetKeyStringValue(
            subKeyHandle,
            USER_NAME,
            CRED_MAX_USERNAME_LENGTH,
            UserNamePtr))
    {
        status = WN_BAD_PROFILE;
        MPR_LOG0(TRACE,"MprReadConnectionInfo: Could not get UserName\n");
        goto CleanExit;
    }
    else
    {
        //
        // If there is no user name (the length is 0), then set the
        // return pointer to NULL.
        //
        if (STRLEN(*UserNamePtr) == 0) {
            LocalFree(*UserNamePtr);
            *UserNamePtr = NULL;
        }
    }

    //
    // Get the Provider Type and load the providers if necessary.  Both
    // MprGetConnection and a remembered enumeration can make it to this
    // point in this state and we don't want to do a Level 2
    // initialization every time one of those functions is called simply
    // because this case _might_ be hit.  For example, calling
    // MprGetConnection on an unconnected drive letter may or may not
    // have a name associated with it in the registry.  If so, there's
    // no need to load the providers to get information from them.  This
    // is equivalent to INIT_IF_NECESSARY(NETWORK_LEVEL,status)
    //
    if (MprGetKeyDwordValue(
            subKeyHandle,
            PROVIDER_TYPE,
            &ProviderType)
        &&
        (MprLevel2Init(NETWORK_LEVEL) == WN_SUCCESS)
        &&
        ((Provider = MprFindProviderByType(ProviderType)) != NULL))
    {
        MPR_LOG(RESTORE,"MprReadConnectionInfo: Found recognized provider type %#lx\n",
                        ProviderType);
        //
        // Got a recognized provider type from the registry.
        // If we have a name for this provider in memory, use it, rather than
        // reading the name from the registry.
        // (memory is allocated for the name)
        //
        if (Provider->Resource.lpProvider != NULL)
        {
            NetResource->lpProvider =
                    (LPWSTR) LocalAlloc(0, STRSIZE(Provider->Resource.lpProvider));

            if (NetResource->lpProvider == NULL)
            {
                status = WN_BAD_PROFILE;
                MPR_LOG(RESTORE,"MprReadConnectionInfo: LocalAlloc failed %ld\n",
                              GetLastError());
                goto CleanExit;
            }

            wcscpy(NetResource->lpProvider, Provider->Resource.lpProvider);
        }
    }

    //
    // If we haven't got a provider name yet, try to read it from the registry.
    // (Memory is allocated by this function.)
    // This could legitimately happen in 2 cases:
    // (1) We are reading a profile that was created by a Windows NT 3.51 or
    // earlier machine and has not yet been converted to a 4.0 or later
    // profile.  Windows NT versions 3.51 and earlier wrote only the provider
    // name to the registry, not the type.
    // (2) We are reading a floating profile that was written by another
    // machine which has a network provider installed that isn't installed on
    // this machine.  Or, a network provider was de-installed from this
    // machine.
    //
    if (NetResource->lpProvider == NULL)
    {
        if(!MprGetKeyValue(
                subKeyHandle,
                PROVIDER_NAME,
                &(NetResource->lpProvider)))
        {
            status = WN_BAD_PROFILE;
            MPR_LOG0(RESTORE,"MprReadConnectionInfo: Could not get ProviderName\n");
            goto CleanExit;
        }

        //
        // Got a provider name from the registry.
        // If we didn't read a provider type from the registry, but we
        // recognize the provider name, write the type now for future use.
        // (This would occur in case (1) above.)
        // Failure to write the type is ignored.
        // (Pathological cases in which we get an unrecognized type but a
        // recognized name are left untouched.)
        // Since it's possible to get to this point without having the
        // providers loaded, we'll init if necessary here (see reasoning
        // above). This is equivalent to INIT_IF_NECESSARY(NETWORK_LEVEL,status)
        //
        status = MprLevel2Init(NETWORK_LEVEL);

        if (status != WN_SUCCESS) {
            goto CleanExit;
        }

        Provider = MprFindProviderByName(NetResource->lpProvider);
        if (Provider != NULL && Provider->Type != 0 && ProviderType == 0)
        {
            MPR_LOG2(RESTORE,"MprReadConnectionInfo: Setting ProviderType %#lx for %ws\n",
                            Provider->Type, driveName);

            status = MprSetRegValue(
                            subKeyHandle,
                            PROVIDER_TYPE,
                            NULL,
                            Provider->Type);

            if (status != ERROR_SUCCESS)
            {
                MPR_LOG(RESTORE,"MprReadConnectionInfo: Couldn't set ProviderType, %ld\n",
                                status);
            }
        }
    }


    //
    // Get the ProviderFlags (failure is ignored)
    //
    cbData = sizeof(DWORD);

    status = RegQueryValueEx(
                subKeyHandle,                   // hKey
                PROVIDER_FLAGS,                 // lpValueName
                NULL,                           // lpTitleIndex
                NULL,                           // lpType
                (LPBYTE)ProviderFlags,          // lpData
                &cbData);                       // lpcbData

    if (status == NO_ERROR) {
        MPR_LOG2(RESTORE,"MprReadConnectionInfo: Got ProviderFlags %#lx for %ws\n",
                 *ProviderFlags, driveName);
    }
    else {
        *ProviderFlags = 0;
    }


    //
    // Get the DeferFlags (failure is ignored)
    //
    if (MprGetKeyDwordValue(
            subKeyHandle,
            DEFER_FLAGS,
            DeferFlags
            ))
    {
        MPR_LOG2(RESTORE,"MprReadConnectionInfo: Got DeferFlags %#lx for %ws\n",
                 *DeferFlags, driveName);
    }
    else
    {
        *DeferFlags = 0;
    }


    //
    // Get the Connection Type
    //
    cbData = sizeof(DWORD);

    status = RegQueryValueEx(
                subKeyHandle,                   // hKey
                CONNECTION_TYPE,                // lpValueName
                NULL,                           // lpTitleIndex
                NULL,                           // lpType
                (LPBYTE)&(NetResource->dwType), // lpData
                &cbData);                       // lpcbData

    if (status != NO_ERROR) {
        MPR_LOG1(ERROR,"MprReadConnectionInfo:RegQueryValueEx failed %d\n",
            status);

        MPR_LOG0(TRACE,"MprReadConnectionInfo: Could not get ConnectionType\n");
        status = WN_BAD_PROFILE;
    }


CleanExit:
    if (status != NO_ERROR) {
        LocalFree(driveName);
        LocalFree(NetResource->lpRemoteName);
        LocalFree(*UserNamePtr);
        LocalFree(NetResource->lpProvider);
        NetResource->lpLocalName = NULL;
        NetResource->lpRemoteName = NULL;
        NetResource->lpProvider = NULL;
        *UserNamePtr = NULL;
        if (subKeyHandle != NULL) {
            RegCloseKey(subKeyHandle);
        }
        return(FALSE);
    }
    else {
        if (SubKeyHandleOut == NULL) {
            RegCloseKey(subKeyHandle);
        }
        else {
            *SubKeyHandleOut = subKeyHandle;
        }
        return(TRUE);
    }
}



VOID
MprForgetRedirConnection(
    IN LPCTSTR  lpName
    )

/*++

Routine Description:

    This function removes a key for the specified redirected device from
    the current users portion of the registry.

Arguments:

    lpName - This is a pointer to a redirected device name.

Return Value:


Note:


--*/
{
    DWORD   status;
    HKEY    connectKey;

    MPR_LOG(TRACE,"In MprForgetConnection for %s\n", lpName);

    LPWSTR KeyName = STACK_ALLOC(lpName);
    if (KeyName == NULL) {
        return;
    }
    RemoveColon(KeyName, lpName);

    //
    // Get a handle for the connection section of the user's registry
    // space.
    //
    if (!MprOpenKey(
            HKEY_CURRENT_USER,
            CONNECTION_KEY_NAME,
            &connectKey,
            DA_READ)) {

        MPR_LOG(ERROR,"WNetForgetRedirCon: MprOpenKey #1 Failed\n",0);
        return;
    }

    status = RegDeleteKey(connectKey, KeyName);

    if (status != NO_ERROR) {
        MPR_LOG(ERROR, "WNetForgetRedirCon: NtDeleteKey Failed %d\n", status);
    }

    //
    // Flush the connect key, and then close the handle to it.
    //

    MPR_LOG(TRACE,"ForgetRedirConnection: Flushing Connection Key\n",0);

    status = RegFlushKey(connectKey);
    if (status != NO_ERROR) {
        MPR_LOG(ERROR,"RememberConnection: Flushing Connection Key Failed %ld\n",
        status);
    }

    RegCloseKey(connectKey);

    return;
}
BOOL
MprGetRemoteName(
    IN      LPTSTR  lpLocalName,
    IN OUT  LPDWORD lpBufferSize,
    OUT     LPTSTR  lpRemoteName,
    OUT     LPDWORD lpStatus
    )
/*++

Routine Description:

    This fuction Looks in the CURRENT_USER portion of the registry for
    connection information related to the lpLocalName passed in.

Arguments:

    lpLocalName - Pointer to a string containing the name of the device to
        look up.

    lpBufferSize - Pointer to a the size information for the buffer.
        On input, this contains the size of the buffer passed in.
        if lpStatus contain WN_MORE_DATA, this will contain the
        buffer size required to obtain the full string.

    lpRemoteName - Pointer to a buffer where the remote name string is
        to be placed.

    lpStatus - Pointer to a location where the proper return code is to
        be placed in the case where the connection information exists.

Return Value:

    TRUE - If the connection information exists.

    FALSE - If the connection information does not exist.  When FALSE is
        returned, none of output parameters are valid.

--*/
{
    HKEY            connectKey;
    DWORD           numSubKeys;
    DWORD           maxSubKeyLen;
    DWORD           maxValueLen;
    DWORD           status;
    DWORD           ProviderFlags;
    DWORD           DeferFlags;
    NETRESOURCEW    netResource;
    LPTSTR          userName;


    //
    // Get a handle for the connection section of the user's registry
    // space.
    //
    if (!MprOpenKey(
            HKEY_CURRENT_USER,
            CONNECTION_KEY_NAME,
            &connectKey,
            DA_READ)) {

        MPR_LOG(ERROR,"WNetGetConnection: MprOpenKey Failed\n",0);
        return(FALSE);
    }

    if(!MprGetKeyInfo(
        connectKey,
        NULL,
        &numSubKeys,
        &maxSubKeyLen,
        NULL,
        &maxValueLen)) {

        MPR_LOG(ERROR,"WNetGetConnection: MprGetKeyInfo Failed\n",0);
        RegCloseKey(connectKey);
        return(FALSE);
    }

    //
    // Read the connection information.
    // NOTE:  This function allocates buffers for UserName and the
    //        following strings in the net resource structure:
    //          lpRemoteName,
    //          lpLocalName,
    //          lpProvider
    //
    if (MprReadConnectionInfo(
            connectKey,
            lpLocalName,
            0,
            &ProviderFlags,
            &DeferFlags,
            &userName,
            &netResource,
            NULL,
            maxSubKeyLen)) {

        //
        // The read succeeded.  Therefore we have connection information.
        //

        if (*lpBufferSize >= STRSIZE(netResource.lpRemoteName)) {

            __try {
                STRCPY(lpRemoteName, netResource.lpRemoteName);
            }
            __except(EXCEPTION_EXECUTE_HANDLER) {
                status = GetExceptionCode();
                if (status != EXCEPTION_ACCESS_VIOLATION) {
                    MPR_LOG(ERROR,"WNetGetConnection:Unexpected Exception 0x%lx\n",status);
                }
                status = WN_BAD_POINTER;
            }
            if (status != WN_BAD_POINTER) {

                //
                // We successfully copied the remote name to the users
                // buffer without an error.
                //
                status = WN_SUCCESS;
            }
        }
        else {
            *lpBufferSize = STRSIZE(netResource.lpRemoteName);
            status = WN_MORE_DATA;
        }

        //
        // Free up the resources allocated by MprReadConnectionInfo.
        //

        LocalFree(userName);
        LocalFree(netResource.lpLocalName);
        LocalFree(netResource.lpRemoteName);
        LocalFree(netResource.lpProvider);

        *lpStatus = status;
        RegCloseKey(connectKey);
        return(TRUE);
    }
    else {
        //
        // The read did not succeed.
        //
        RegCloseKey(connectKey);
        return(FALSE);
    }
}

DWORD
MprGetPrintKeyInfo(
    HKEY    KeyHandle,
    LPDWORD NumValueNames,
    LPDWORD MaxValueNameLength,
    LPDWORD MaxValueLen)

/*++

Routine Description:

    This function reads the data associated with a print reconnection key.

Arguments:

    KeyHandle - This is an already opened handle to the key whose
        info is rto be queried.

    NumValueNames - Used to return the number of values

    MaxValueNameLength - Used to return the max value name length

    MaxValueLen - Used to return the max value data length

Return Value:

    0 if success. Win32 error otherwise.


Note:

--*/
{
    DWORD       err;
    DWORD       maxClassLength;
    DWORD       securityDescLength;
    DWORD       NumSubKeys ;
    DWORD       MaxSubKeyLen ;
    FILETIME    lastWriteTime;

    //
    // Get the Key Information
    //

    err = RegQueryInfoKey(
              KeyHandle,
              NULL,                   // Class
              NULL,                   // size of class buffer (in bytes)
              NULL,                   // DWORD to receive title index
              &NumSubKeys,            // number of subkeys
              &MaxSubKeyLen,          // length of longest subkey name
              &maxClassLength,        // length of longest subkey class string
              NumValueNames,          // number of valueNames for this key
              MaxValueNameLength,     // length of longest ValueName
              MaxValueLen,            // length of longest value's data field
              &securityDescLength,    // lpcbSecurityDescriptor
              &lastWriteTime);        // the last time the key was modified

    return(err);
}

DWORD
MprForgetPrintConnection(
    IN LPTSTR   lpName
    )

/*++

Routine Description:

    This function removes a rememembered print reconnection value.

Arguments:

    lpName - name of path to forget

Return Value:

    0 if success. Win32 error otherwise.


Note:

--*/
{
    HKEY  hKey ;
    DWORD err ;

    if (!MprOpenKey(
            HKEY_CURRENT_USER,
            PRINT_CONNECTION_KEY_NAME,
            &hKey,
            DA_WRITE))
    {
        return (GetLastError()) ;
    }

    err = RegDeleteValue(hKey,
                         lpName) ;

    RegCloseKey(hKey) ;
    return err ;
}