/*++

    Copyright (c) 1998-2000 Microsoft Corporation

Module Name:

    w32drprn

Abstract:

    This module defines the parent for the Win32 client-side RDP
    printer redirection "device" class hierarchy, W32DrPRN.

Author:

    Tad Brockway 3/23/99

Revision History:

--*/

#include <precom.h>

#define TRC_FILE  "W32DrPRN"

#include <string.h>
#include "w32drprn.h"
#include "w32utl.h"
#include "drobjmgr.h"
#include "w32drman.h"
#include "w32proc.h"
#include "drdbg.h"
#ifdef OS_WINCE
#include "ceconfig.h"
#endif

DWORD W32DrPRN::_maxCacheDataSize = DEFAULT_MAXCACHELEN;

///////////////////////////////////////////////////////////////
//
//  W32DrPRN Members
//

W32DrPRN::W32DrPRN(ProcObj *processObject, const DRSTRING printerName, 
                 const DRSTRING driverName, const DRSTRING portName, 
                 const DRSTRING pnpName,
                 BOOL isDefaultPrinter, ULONG deviceID, 
                 const TCHAR *devicePath) :
            W32DrDeviceAsync(processObject, deviceID, devicePath), 
            DrPRN(printerName, driverName, pnpName, isDefaultPrinter)
/*++

Routine Description:

    Constructor

Arguments:

    printerName -   Name of printing device.
    driverName  -   Name of print driver name.
    portName    -   Name of client-side printing port.
    pnpName     -   PnP ID String
    default     -   Is this the default printer?
    id          -   Unique device identifier for printing device.
    devicePath  -   Path to the device.

Return Value:

    NA

 --*/
{
    //
    //  Record the port name.
    //
    SetPortName(portName);
}

W32DrPRN *
W32DrPRN::ResolveCachedPrinter(
    IN ProcObj *procObj, 
    IN DrDeviceMgr *deviceMgr,
    IN HKEY hParentKey,
    IN LPTSTR printerName
    )
/*++

Routine Description:

    Open the subkey of hParentKey associated with the specified
    printer name and instantiate a manual printer or find an existing
    automatic printer object in the device manager, depending on the
    type of cached data found.

Arguments:

    procObj     -   Associated Processing Object.
    hParentKey  -   Parent key of printer key.
    printerName -   Name of printer ... and name of printer subkey.

Return Value:

    None.

 --*/
{
    W32DrPRN *prnDevice = NULL;
    DWORD cachedDataSize;
    LPTSTR regValueName;
    LONG result;
    HKEY hPrinterKey;
    DWORD ulType;
    BOOL isManual = FALSE;


    DC_BEGIN_FN("W32DrPRN::ResolveCachedPrinter");

    //
    //  Open the key for the cached printer.
    //
    result = RegCreateKeyEx(
                hParentKey, printerName, 0L,
                NULL, REG_OPTION_NON_VOLATILE,
                KEY_ALL_ACCESS, NULL,
                &hPrinterKey, NULL
                );
    if (result != ERROR_SUCCESS) {
        TRC_ERR((TB, _T("RegCreateKeyEx failed:  %ld."),result));
        hPrinterKey = NULL;
        goto CleanUpAndExit;
    }

    //
    //  See if the value name for the cached printer data is for
    //  a manual printer.
    //
    regValueName = (LPTSTR)REG_RDPDR_PRINTER_CACHE_DATA;
    cachedDataSize = 0;
#ifndef OS_WINCE
    result = RegQueryValueEx(hPrinterKey, regValueName,
                        NULL, &ulType, NULL, &cachedDataSize
                        );
    //
    // Check for hacks
    //
    if (cachedDataSize >= GetMaxCacheDataSize() * 1000) {
        ASSERT(FALSE);
        goto CleanUpAndExit;
    }

#else
    cachedDataSize = GetCachedDataSize(hPrinterKey);
#endif
    //
    //  If no manual printer then check for an automatic printer.
    //
    if (result == ERROR_FILE_NOT_FOUND) {

        regValueName = (LPTSTR)REG_RDPDR_AUTO_PRN_CACHE_DATA;
        cachedDataSize = 0;
        result = RegQueryValueEx(hPrinterKey, regValueName,
                            NULL, &ulType, NULL, &cachedDataSize
                            );

        //
        //  If the entry exists and has some data associated with it
        //  then see if we have a corresponding automatic printer to
        //  add the data to.
        //
        if ((result == ERROR_SUCCESS) && (cachedDataSize > 0)) {
            prnDevice = (W32DrPRN *)deviceMgr->GetObject(
                                (LPTSTR)printerName, 
                                RDPDR_DTYP_PRINT
                                );
            if (prnDevice != NULL) {
                ASSERT(!STRICMP(prnDevice->ClassName(), TEXT("W32DrAutoPrn")));
            }
        }
        else {
            prnDevice = NULL;
        }
    }
    //
    //  Otherwise, if there is some actual cached data then instantiate
    //  a manual printer object and add it to the device manager.
    //
    else if ((result == ERROR_SUCCESS) && (cachedDataSize > 0)) {
        TCHAR UniquePortName[MAX_PATH];
        ULONG DeviceId;

        isManual = TRUE;

        // 
        //  The unique port name is going to be passed to the server
        //  as preferred dos name (max 7 characters long).  As we want to
        //  keep a unique dos name for each printer device, we need 
        //  to fake our own port name.
        //
        DeviceId = deviceMgr->GetUniqueObjectID();
        
        StringCchPrintf(UniquePortName,
                        SIZE_TCHARS(UniquePortName),
                        TEXT("PRN%ld"), DeviceId);
        UniquePortName[7] = TEXT('\0');

#ifndef OS_WINCE
        prnDevice = new W32DrManualPrn(procObj, printerName, TEXT(""),
                                    UniquePortName, FALSE, 
                                    DeviceId);
#else
        //check of it is the default printer
        BOOL fDefault = FALSE;
        HKEY hk = NULL;
        WCHAR szWDefault[PREFERRED_DOS_NAME_SIZE];
        UCHAR szADefault[PREFERRED_DOS_NAME_SIZE];
        DWORD dwSize = sizeof(szWDefault);
        if ( (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, REG_RDPDR_WINCE_DEFAULT_PRN, 0, 0, &hk))  && 
             (ERROR_SUCCESS == RegQueryValueEx(hk, NULL, NULL, &ulType, (LPBYTE )szWDefault, &dwSize)) && 
             (ulType == REG_SZ) && (dwSize < sizeof(szWDefault)) && 
             (WideCharToMultiByte(GetACP(), 0, szWDefault, -1, (char *)szADefault, sizeof(szADefault), NULL, NULL) > 0) )
        {
            UCHAR szPort[PREFERRED_DOS_NAME_SIZE] = {0};
            dwSize = sizeof(szPort);
            RegQueryValueEx(hPrinterKey, regValueName, NULL, &ulType, szPort, &dwSize);
            fDefault = (0 == _stricmp((char *)szADefault, (char *)szPort));
        }
        if (hk)
            RegCloseKey(hk);

        prnDevice = new W32DrManualPrn(procObj, printerName, TEXT(""),
                                    UniquePortName, fDefault, 
                                    DeviceId);
#endif

        if (prnDevice != NULL) {
            prnDevice->Initialize();
            if (!prnDevice->IsValid() || 
                (deviceMgr->AddObject(prnDevice) != ERROR_SUCCESS)) {
                delete prnDevice;
                prnDevice = NULL;
            }
        }
        else {
            TRC_ERR((TB, _T("Out of memory when crating manual printer.")));
        }
    }
    else {
        TRC_NRM((TB, _T("Can't resolve printer %s."),printerName));
        prnDevice = NULL;
    }

    //
    //  If ended up with a printer device object then add the cached data.
    //
    if ((prnDevice != NULL) && 
        (prnDevice->SetCachedDataSize(cachedDataSize) == ERROR_SUCCESS)) {

        //
        //  Read the cached data.
        //
#ifndef OS_WINCE
        result = RegQueryValueEx(hPrinterKey, regValueName,
                                NULL, &ulType, prnDevice->GetCachedDataPtr(), 
                                &cachedDataSize
                                );
#else
        ulType = REG_BINARY;
        result = ReadCachedData(hPrinterKey, 
                                prnDevice->GetCachedDataPtr(), 
                                &cachedDataSize
                                );
#endif

        //
        //  Let the printer device object know that we are done recovering 
        //  cached data.
        //
        if (result == ERROR_SUCCESS) {
            //
            //  Make sure the found data is binary data.
            //
            ASSERT(ulType == REG_BINARY);
            if (ulType == REG_BINARY) {
                prnDevice->CachedDataRestored();
            }
            else {
                result = ERROR_INVALID_DATA;
            }
        }
        else {
            TRC_NRM((TB, _T("RegQueryValueEx failed:  %ld."),result));
        }

        //
        //  On error processing the cached data.
        //
        if ((result != ERROR_SUCCESS) || (!prnDevice->IsValid())) {
            //
            //  For a manual printer, we should close and delete its reg key.
            //
            if (isManual) {
                TRC_ALT((TB, _T("Deleting manual printer %s on cache data error."), 
                        printerName));
                ASSERT(hPrinterKey != NULL);
                RegCloseKey(hPrinterKey);
                hPrinterKey = NULL;
                RegDeleteKey(hParentKey, printerName);
            }
            //
            //  If the printer is an auto printer, zero the cached data for this device 
            //  on error and delete the reg value, but we should still redirect the 
            //  printer.
            //
            else {
                prnDevice->SetCachedDataSize(0);
                RegDeleteValue(hPrinterKey, regValueName);
            }
        }
    }


    //
    //  See if our resulting printer is valid after all this processing.  If not, 
    //  it should be whacked and removed from the device object list.
    //
    if ((prnDevice != NULL) && !prnDevice->IsValid()) {
        TRC_ERR((TB, _T("Whacking invalid printer device %s."), printerName));
        deviceMgr->RemoveObject(prnDevice->GetID());
        delete prnDevice;
        prnDevice = NULL;
    }

CleanUpAndExit:

    //
    //  Close the printer registry key.
    //
    if (hPrinterKey != NULL) {
        RegCloseKey(hPrinterKey);
    }

    DC_END_FN();
    return prnDevice;
}

VOID
W32DrPRN::ProcessPrinterCacheInfo(
    IN PRDPDR_PRINTER_CACHEDATA_PACKET pCachePacket,
    IN UINT32 maxDataLen
    )
/*++

Routine Description:

    Process device cache info packet from the server.

Arguments:

    pCachePacket - Pointer to the cache info packet from server.
    maxDataLen - Maximum data length for this packet

Return Value:

    NA

 --*/
{
    DC_BEGIN_FN("DrPRN::ProcessPrinterCacheInfo");
    //
    // Compute the valid maximum length that any of the events have
    //
    maxDataLen -= sizeof(RDPDR_PRINTER_CACHEDATA_PACKET);
    switch ( pCachePacket->EventId ) 
    {
        case RDPDR_ADD_PRINTER_EVENT :
            AddPrinterCacheInfo(
                    (PRDPDR_PRINTER_ADD_CACHEDATA)(pCachePacket + 1), maxDataLen);
        break;

        case RDPDR_DELETE_PRINTER_EVENT :
            DeletePrinterCacheInfo(
                    (PRDPDR_PRINTER_DELETE_CACHEDATA)(pCachePacket + 1), maxDataLen);
        break;

        case RDPDR_UPDATE_PRINTER_EVENT :
            UpdatePrinterCacheInfo(
                    (PRDPDR_PRINTER_UPDATE_CACHEDATA)(pCachePacket + 1), maxDataLen);
        break;

        case RDPDR_RENAME_PRINTER_EVENT :
            RenamePrinterCacheInfo(
                    (PRDPDR_PRINTER_RENAME_CACHEDATA)(pCachePacket + 1), maxDataLen);
        break;
        default:
            TRC_ALT((TB, _T("Unhandled %ld."), pCachePacket->EventId));
        break;
    }

    //
    //  Clean up the server message because the transaction is complete. 
    //
    delete pCachePacket;
    DC_END_FN();
}

ULONG
W32DrPRN::AddPrinterCacheInfo(
    PRDPDR_PRINTER_ADD_CACHEDATA pAddPrinterData,
    UINT32 maxDataLen
    )
/*++

Routine Description:

    Writes device cache info to the registry.

Arguments:

    pAddPrinterData - pointer to the RDPDR_PRINTER_ADD_CACHEDATA structure.
    maxDataLen - Maximum data length for this data
    
Return Value:

    Windows Error Code.

 --*/
{
    ULONG ulError;
    LPTSTR pszKeyName;
    LPWSTR pszUnicodeKeyString;
    PBYTE lpStringData;

    HKEY hKey = NULL;
    HKEY hPrinterKey = NULL;
    ULONG ulDisposition;
    ULONG ulPrinterData;

    DC_BEGIN_FN("W32DrPRN::AddPrinterCacheInfo");

    ASSERT(pAddPrinterData->PrinterNameLen != 0);

    if( pAddPrinterData->PrinterNameLen == 0 ) {
        ulError = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }

    ulPrinterData =
        sizeof(RDPDR_PRINTER_ADD_CACHEDATA) +
            pAddPrinterData->PnPNameLen +
            pAddPrinterData->DriverLen +
            pAddPrinterData->PrinterNameLen +
            pAddPrinterData->CachedFieldsLen;

    //
    // Make sure that the data length is valid.
    // Make sure that the cache info doesn't exceed
    // the max configured length
    //
    //
    if(ulPrinterData > maxDataLen ||
       ulPrinterData > GetMaxCacheDataSize() * 1000) {
        ulError = ERROR_INVALID_DATA;
        TRC_ERR((TB, _T("Cache Data Length is invalid - %ld"), ulError));
        ASSERT(FALSE);
        goto Cleanup;
    }
    //
    //  Prepare registry key name.
    //
    lpStringData = (PBYTE)(pAddPrinterData + 1);
    pszUnicodeKeyString = (LPWSTR)
        (lpStringData +
            pAddPrinterData->PnPNameLen +
            pAddPrinterData->DriverLen);

#ifdef UNICODE
    pszKeyName = pszUnicodeKeyString;
#else
    //
    //  Convert the unicode string to ansi.
    //
    CHAR achAnsiKeyName[MAX_PATH];

    RDPConvertToAnsi(
        pszUnicodeKeyString,
        (LPSTR)achAnsiKeyName,
        sizeof(achAnsiKeyName) );

    pszKeyName = (LPSTR)achAnsiKeyName;
#endif

    //
    //  Open rdpdr cached printers key.
    //
    ulError =
        RegCreateKeyEx(
            HKEY_CURRENT_USER,
            REG_RDPDR_CACHED_PRINTERS,
            0L,
            NULL,
            REG_OPTION_NON_VOLATILE,
            KEY_ALL_ACCESS,
            NULL,
            &hKey,
            &ulDisposition);
    if (ulError != ERROR_SUCCESS) {
        TRC_ERR((TB, _T("RegCreateKeyEx %ld."), ulError));
        goto Cleanup;
    }

    //
    //  Create/Open registry key.
    //
    ulError =
        RegCreateKeyEx(
            hKey,
            pszKeyName,
            0L,
            NULL,
            REG_OPTION_NON_VOLATILE,
            KEY_ALL_ACCESS,
            NULL,
            &hPrinterKey,
            &ulDisposition);
    if (ulError != ERROR_SUCCESS) {

        TRC_ERR((TB, _T("RegCreateKeyEx %ld."), ulError));
        goto Cleanup;
    }

    //
    //  Write cache data.
    //
    ulError =
        RegSetValueEx(
            hPrinterKey,
            REG_RDPDR_PRINTER_CACHE_DATA,
            NULL,
            REG_BINARY,
            (PBYTE)pAddPrinterData,
            ulPrinterData
            );
    if (ulError != ERROR_SUCCESS) {
        TRC_ERR((TB, _T("RegSetValueEx() failed, %ld."), ulError));
        goto Cleanup;
    }

    //
    //  We are done.
    //
Cleanup:
    if( hPrinterKey != NULL ) {
        RegCloseKey( hPrinterKey );
    }
    if( hKey != NULL ) {
        RegCloseKey( hKey );
    }

    DC_END_FN();

    return ulError;
}

ULONG
W32DrPRN::DeletePrinterCacheInfo(
    PRDPDR_PRINTER_DELETE_CACHEDATA pDeletePrinterData,
    UINT32 maxDataLen
    )
/*++

Routine Description:

    Delete device cache info from the registry.

Arguments:

    pDeletePrinterData - pointer to the RDPDR_PRINTER_DELETE_CACHEDATA structure.
    maxDataLen - Maximum data length for this data
    
Return Value:

    Windows Error Code.

 --*/
{
    ULONG ulError;
    LPTSTR pszKeyName;
    LPWSTR pszUnicodeKeyString;

    HKEY hKey = NULL;
    ULONG ulDisposition;

    DC_BEGIN_FN("W32DrPRN::DeletePrinterCacheInfo");

    ASSERT(pDeletePrinterData->PrinterNameLen != 0);

    if( pDeletePrinterData->PrinterNameLen == 0 ) {
        ulError = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
    ULONG ulPrinterData = 
        sizeof(RDPDR_PRINTER_DELETE_CACHEDATA) + 
        pDeletePrinterData->PrinterNameLen;
    //
    // Make sure that the data length is valid
    //
    if(ulPrinterData > maxDataLen ||
       ulPrinterData > GetMaxCacheDataSize() * 1000) {
        ulError = ERROR_INVALID_DATA;
        TRC_ERR((TB, _T("Cache Data Length is invalid - %ld"), ulError));
        ASSERT(FALSE);
        goto Cleanup;
    }
    //
    // prepare registry key name.
    //
    pszUnicodeKeyString = (LPWSTR)(pDeletePrinterData + 1);

#ifdef UNICODE

    pszKeyName = pszUnicodeKeyString;

#else // UNICODE

    //
    // convert the unicode string to ansi.
    //

    CHAR achAnsiKeyName[MAX_PATH];

    RDPConvertToAnsi(
        pszUnicodeKeyString,
        (LPSTR)achAnsiKeyName,
        sizeof(achAnsiKeyName) );

    pszKeyName = (LPSTR)achAnsiKeyName;

#endif // UNICODE

    //
    // open rdpdr cached printers key.
    //

    ulError =
        RegCreateKeyEx(
            HKEY_CURRENT_USER,
            REG_RDPDR_CACHED_PRINTERS,
            0L,
            NULL,
            REG_OPTION_NON_VOLATILE,
            KEY_ALL_ACCESS,
            NULL,
            &hKey,
            &ulDisposition);

    if (ulError != ERROR_SUCCESS) {

        TRC_ERR((TB, _T("RegCreateKeyEx() failed, %ld."), ulError));
        goto Cleanup;
    }

    //
    // delete registry key.
    //
    // Note : assumed, no sub-key presends.
    //

    ulError = RegDeleteKey( hKey, pszKeyName );

    if (ulError != ERROR_SUCCESS) {

        TRC_ERR((TB, _T("RegDeleteKey() failed, %ld."), ulError));
        goto Cleanup;
    }

Cleanup:

    if( hKey != NULL ) {
        RegCloseKey( hKey );
    }

    DC_END_FN();
    return ulError;
}

ULONG
W32DrPRN::RenamePrinterCacheInfo(
    PRDPDR_PRINTER_RENAME_CACHEDATA pRenamePrinterData,
    UINT32 maxDataLen    
    )
/*++

Routine Description:

    Rename device cache info in the registry.

Arguments:

    pRenamePrinterData - pointer to the RDPDR_PRINTER_RENAME_CACHEDATA
        structure.
    maxDataLen - Maximum data length for this data
    
Return Value:

    Windows Error Code.

 --*/
{
    DC_BEGIN_FN("W32DrPRN::RenamePrinterCacheInfo");

    ULONG ulError;

    LPTSTR pszOldKeyName;
    LPTSTR pszNewKeyName;
    LPWSTR pszOldUnicodeKeyString;
    LPWSTR pszNewUnicodeKeyString;

    HKEY hKey = NULL;
    HKEY hOldKey = NULL;
    HKEY hNewKey = NULL;
    ULONG ulDisposition;
    ULONG ulType;

    ULONG ulPrinterDataLen;
    ULONG ulAllocPrinterDataLen = REGISTRY_ALLOC_DATA_SIZE;
    PBYTE pbPrinterData = NULL;
    BOOL bBufferExpanded = FALSE;

    BOOL bAutoPrinter = FALSE;
    LPTSTR pszValueStr;

    pszValueStr = (LPTSTR)REG_RDPDR_PRINTER_CACHE_DATA;

    ASSERT(pRenamePrinterData->OldPrinterNameLen != 0);

    ASSERT(pRenamePrinterData->NewPrinterNameLen != 0);

    if( pRenamePrinterData->OldPrinterNameLen == 0 ) {
        ulError = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }

    if( pRenamePrinterData->NewPrinterNameLen == 0 ) {
        ulError = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }

    ULONG ulPrinterData = 
        sizeof(RDPDR_PRINTER_RENAME_CACHEDATA) + 
        pRenamePrinterData->OldPrinterNameLen +
        pRenamePrinterData->NewPrinterNameLen;

    //
    // Make sure that the data length is valid
    //
    if(ulPrinterData > maxDataLen ||
       ulPrinterData > GetMaxCacheDataSize() * 1000) {
        ulError = ERROR_INVALID_DATA;
        TRC_ERR((TB, _T("Cache Data Length is invalid - %ld"), ulError));
        ASSERT(FALSE);
        goto Cleanup;
    }
    //
    // prepare registry key name.
    //

    pszOldUnicodeKeyString = (LPWSTR)(pRenamePrinterData + 1);
    pszNewUnicodeKeyString = (LPWSTR)
        ((PBYTE)pszOldUnicodeKeyString +
        pRenamePrinterData->OldPrinterNameLen);

    TRC_ERR((TB, _T("pszOldUnicodeKeyString is %ws."), pszOldUnicodeKeyString));
    TRC_ERR((TB, _T("pszNewUnicodeKeyString is %ws."), pszNewUnicodeKeyString));

    // 
    // No change in queue name.
    //
    if( _wcsicmp(pszOldUnicodeKeyString, pszNewUnicodeKeyString) == 0 ) {
        ulError = ERROR_SUCCESS;
        goto Cleanup;
    }

#ifdef UNICODE

    pszOldKeyName = pszOldUnicodeKeyString;
    pszNewKeyName = pszNewUnicodeKeyString;

#else // UNICODE

    //
    // convert the unicode string to ansi.
    //

    CHAR achOldAnsiKeyName[MAX_PATH];
    CHAR achNewAnsiKeyName[MAX_PATH];

    RDPConvertToAnsi(
        pszOldUnicodeKeyString,
        (LPSTR)achOldAnsiKeyName,
        sizeof(achOldAnsiKeyName) );

    pszOldKeyName = (LPSTR)achOldAnsiKeyName;

    RDPConvertToAnsi(
        pszNewUnicodeKeyString,
        (LPSTR)achNewAnsiKeyName,
        sizeof(achNewAnsiKeyName) );

    pszNewKeyName = (LPSTR)achNewAnsiKeyName;

    

#endif // UNICODE

    //
    // open rdpdr cached printers key.
    //

    ulError =
        RegCreateKeyEx(
            HKEY_CURRENT_USER,
            REG_RDPDR_CACHED_PRINTERS,
            0L,
            NULL,
            REG_OPTION_NON_VOLATILE,
            KEY_ALL_ACCESS,
            NULL,
            &hKey,
            &ulDisposition);

    if (ulError != ERROR_SUCCESS) {

        TRC_ERR((TB, _T("RegCreateKeyEx() failed, %ld."), ulError));
        goto Cleanup;
    }

    //
    // Open old Key.
    //

    ulError =
        RegOpenKeyEx(
            hKey,
            pszOldKeyName,
            0L,
            KEY_ALL_ACCESS,
            &hOldKey);

    if (ulError != ERROR_SUCCESS) {

        TRC_ERR((TB, _T("RegOpenKeyEx() failed, %ld."), ulError));
        goto Cleanup;
    }

    //
    // read cache data.
    //

ReadAgain:

    pbPrinterData = new BYTE[ulAllocPrinterDataLen];
    if( pbPrinterData == NULL ) {
        ulError = ERROR_NOT_ENOUGH_MEMORY;
        goto Cleanup;
    }


    ulPrinterDataLen = ulAllocPrinterDataLen;
    ulError =
        RegQueryValueEx(
            hOldKey,
            pszValueStr,
            NULL,
            &ulType,
            pbPrinterData,
            &ulPrinterDataLen);

    TRC_ERR((TB, _T("RegQueryValueEx returned: %ld."), ulError));

    if (ulError != ERROR_SUCCESS) {
        if( ulError == ERROR_MORE_DATA ) {

            //
            // do the buffer expansion only once to aviod infinite look
            // in case of registry corruption or so.
            //

            if( !bBufferExpanded ) {

                ASSERT(ulPrinterDataLen > ulAllocPrinterDataLen);

                //
                // need bigger buffer.
                // Compute new buffer size.
                //

                ulAllocPrinterDataLen =
                    ((ulPrinterDataLen / REGISTRY_ALLOC_DATA_SIZE) + 1) *
                    REGISTRY_ALLOC_DATA_SIZE;

                //
                // free old buffer.
                //

                delete pbPrinterData;
                pbPrinterData = NULL;

                ASSERT(ulAllocPrinterDataLen >= ulPrinterDataLen);

                bBufferExpanded = TRUE;
                goto ReadAgain;
            }
        }
        else {
            //
            // It could be auto printer. Try again.
            //
            if (!bAutoPrinter) {
                bAutoPrinter = TRUE;
                pszValueStr = (LPTSTR)REG_RDPDR_AUTO_PRN_CACHE_DATA;

                //
                // free old buffer
                //

                delete pbPrinterData;
                pbPrinterData = NULL;

                goto ReadAgain;
            }
        }
    }

    if (ulError != ERROR_SUCCESS) {

        TRC_ERR((TB, _T("RegQueryValueEx() failed, %ld."), ulError));
        goto Cleanup;
    }

    ASSERT(ulType == REG_BINARY);

    if( ulType != REG_BINARY ) {

        TRC_ERR((TB, _T("RegQueryValueEx returns wrong type, %ld."), ulType));
        goto Cleanup;
    }

    //
    // Update the printer name in the cache info
    //
    ulError = DrPRN::UpdatePrinterNameInCacheData(
        &pbPrinterData,
        &ulPrinterDataLen,
        (PBYTE)pszNewUnicodeKeyString,
        pRenamePrinterData->NewPrinterNameLen);

    //
    // Let's not worry about the success/failure of the above function.
    // We will anyway right the cache information to the new key
    //

    //
    // write the data to the new key.
    //

    //
    // open new key.
    //

    ulError =
        RegCreateKeyEx(
            hKey,
            pszNewKeyName,
            0L,
            NULL,
            REG_OPTION_NON_VOLATILE,
            KEY_ALL_ACCESS,
            NULL,
            &hNewKey,
            &ulDisposition);

    if (ulError != ERROR_SUCCESS) {

        TRC_ERR((TB, _T("RegCreateKeyEx() failed, %ld."), ulError));
        goto Cleanup;
    }

    ASSERT(ulDisposition != REG_OPENED_EXISTING_KEY);

    ulError =
        RegSetValueEx(
            hNewKey,
            pszValueStr,
            NULL,
            ulType,
            pbPrinterData,
            ulPrinterDataLen);

    if (ulError != ERROR_SUCCESS) {

        TRC_ERR((TB, _T("RegSetValueEx() failed, %ld."), ulError));
        goto Cleanup;
    }

    //
    // Try to rename the local printer
    //
    if (bAutoPrinter) {
        RenamePrinter(pszOldKeyName, pszNewKeyName);
    }
    //
    // now delete old registry key.
    //
    // Note : assumed, no sub-key presends.
    //

    ulError = RegCloseKey( hOldKey );
    if (ulError != ERROR_SUCCESS) {

        TRC_ERR((TB, _T("RegCloseKey() failed, %ld."), ulError));
        goto Cleanup;
    }

    hOldKey = NULL;

    ulError = RegDeleteKey( hKey, pszOldKeyName );

    if (ulError != ERROR_SUCCESS) {

        TRC_ERR((TB, _T("RegDeleteKey() failed, %ld."), ulError));
        goto Cleanup;
    }

Cleanup:

    if( hKey != NULL ) {
        RegCloseKey( hKey );
    }

    if( hOldKey != NULL ) {
        RegCloseKey( hOldKey );
    }

    if( hNewKey != NULL ) {
        RegCloseKey( hNewKey );
    }

    if (pbPrinterData) {
        delete pbPrinterData;
    }

    DC_END_FN();
    return ulError;
}

ULONG
W32DrPRN::UpdatePrinterCacheInfo(
    PRDPDR_PRINTER_UPDATE_CACHEDATA pUpdatePrinterData,
    UINT32 maxDataLen    
    )
/*++

Routine Description:

    Update device cache info in the registry.

Arguments:

    pUpdatePrinterData - pointer to the RDPDR_PRINTER_UPDATE_CACHEDATA
        structure.
    maxDataLen - Maximum data length for this data
    
Return Value:

    Windows Error Code.

 --*/
{
    DC_BEGIN_FN("W32DrPRN::UpdatePrinterCacheInfo");
    ULONG ulError;
    LPTSTR pszKeyName;
    LPWSTR pszUnicodeKeyString;

    HKEY hKey = NULL;
    HKEY hPrinterKey = NULL;
    ULONG ulDisposition;
    ULONG ulConfigDataLen;
    PBYTE pbConfigData;

    ULONG ulPrinterDataLen;
    ULONG ulAllocPrinterDataLen = REGISTRY_ALLOC_DATA_SIZE;
    PBYTE pbPrinterData = NULL;

    BOOL bAutoPrinter = FALSE;

    ASSERT(pUpdatePrinterData->PrinterNameLen != 0);

    if( pUpdatePrinterData->PrinterNameLen == 0 ) {
        ulError = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }

    ulPrinterDataLen = 
        sizeof(RDPDR_PRINTER_UPDATE_CACHEDATA) + 
        pUpdatePrinterData->PrinterNameLen +
        pUpdatePrinterData->ConfigDataLen;

    //
    // Make sure that the data length is valid
    //
    if(ulPrinterDataLen > maxDataLen || 
       ulPrinterDataLen > GetMaxCacheDataSize() * 1000) {
        ulError = ERROR_INVALID_DATA;
        TRC_ERR((TB, _T("Cache Data Length is invalid - %ld"), ulError));
        ASSERT(FALSE);
        goto Cleanup;
    }

    //
    // prepare registry key name.
    //


    pszUnicodeKeyString = (LPWSTR)(pUpdatePrinterData + 1);

#ifdef UNICODE

    pszKeyName = pszUnicodeKeyString;

#else // UNICODE

    //
    // convert the unicode string to ansi.
    //

    CHAR achAnsiKeyName[MAX_PATH];

    RDPConvertToAnsi(
        pszUnicodeKeyString,
        (LPSTR)achAnsiKeyName,
        sizeof(achAnsiKeyName) );

    pszKeyName = (LPSTR)achAnsiKeyName;

#endif // UNICODE

    //
    // open rdpdr cached printers key.
    //

    ulError =
        RegCreateKeyEx(
            HKEY_CURRENT_USER,
            REG_RDPDR_CACHED_PRINTERS,
            0L,
            NULL,
            REG_OPTION_NON_VOLATILE,
            KEY_ALL_ACCESS,
            NULL,
            &hKey,
            &ulDisposition);

    if (ulError != ERROR_SUCCESS) {

        TRC_ERR((TB, _T("RegCreateKeyEx() failed, %ld."), ulError));
        goto Cleanup;
    }

    //
    // update registry data.
    //

    //
    // Open registry key.
    //

    ulError =
        RegCreateKeyEx(
            hKey,
            pszKeyName,
            0L,
            NULL,
            REG_OPTION_NON_VOLATILE,
            KEY_ALL_ACCESS,
            NULL,
            &hPrinterKey,
            &ulDisposition);

    if (ulError != ERROR_SUCCESS) {
        TRC_ERR((TB, _T("RegCreateKeyEx() failed, %ld."), ulError));
        goto Cleanup;
    }

    if( ulDisposition != REG_OPENED_EXISTING_KEY ) {

        //
        // we do not find a cache entry, so it must be automatic printer
        // cache data.
        //

        bAutoPrinter = TRUE;
        TRC_NRM((TB, _T("Created new Key, Auto cache printer detected.")));
    }

    if( !bAutoPrinter ) {

        //
        // read old cache data.
        //

        ULONG ulType;

#ifndef OS_WINCE
        do {

            pbPrinterData = new BYTE[ulAllocPrinterDataLen];
            if( pbPrinterData == NULL ) {
                ulError = ERROR_NOT_ENOUGH_MEMORY;
                goto Cleanup;
            }

            ulPrinterDataLen = ulAllocPrinterDataLen;
            ulError =
                RegQueryValueEx(
                    hPrinterKey,
                    (PTCHAR)REG_RDPDR_PRINTER_CACHE_DATA,
                    NULL,
                    &ulType,
                    pbPrinterData,
                    &ulPrinterDataLen);

            if( ulError == ERROR_MORE_DATA ) {

                ASSERT(ulPrinterDataLen > ulAllocPrinterDataLen);

                //
                // need bigger buffer.
                // Compute new buffer size.
                //

                ulAllocPrinterDataLen =
                    ((ulPrinterDataLen / REGISTRY_ALLOC_DATA_SIZE) + 1) *
                        REGISTRY_ALLOC_DATA_SIZE;

                //
                // free old buffer.
                //

                delete pbPrinterData;
                pbPrinterData = NULL;

                ASSERT(ulAllocPrinterDataLen >= ulPrinterDataLen);
            }
            else if( ulError == ERROR_FILE_NOT_FOUND ) {

                //
                // we do not find a cache entry, so it must be automatic
                // printer cache data.
                //

                TRC_NRM((TB, _T("No Old Cache data, Auto cache printer detected.")));
                bAutoPrinter = TRUE;
                ulError = ERROR_SUCCESS;
                ulType = REG_BINARY;
            }

        } while ( ulError == ERROR_MORE_DATA );
#else
        ulPrinterDataLen = GetCachedDataSize(hPrinterKey);
        pbPrinterData = new BYTE[ulPrinterDataLen];
        if( pbPrinterData == NULL ) {
            ulError = ERROR_NOT_ENOUGH_MEMORY;
            goto Cleanup;
        }
        ulType = REG_BINARY;
        ulError = ReadCachedData(hPrinterKey, pbPrinterData, &ulPrinterDataLen);
#endif
    

        if (ulError != ERROR_SUCCESS) {
            TRC_ERR((TB, _T("RegQueryValueEx() failed, %ld."), ulError));
            goto Cleanup;
        }

        ASSERT(ulType == REG_BINARY);
    }

    if( !bAutoPrinter ) {

        //
        // update the printer data.
        //

        ulConfigDataLen = pUpdatePrinterData->ConfigDataLen;
        pbConfigData =
            (PBYTE)(pUpdatePrinterData + 1) +
                pUpdatePrinterData->PrinterNameLen;

        ulError =
            DrPRN::UpdatePrinterCacheData(
                &pbPrinterData,
                &ulPrinterDataLen,
                pbConfigData,
                ulConfigDataLen );

        if (ulError != ERROR_SUCCESS) {
            TRC_ERR((TB, _T("UpdatePrinterCacheData() failed, %ld."), ulError));
            goto Cleanup;
        }

        //
        // write cache data.
        //

#ifndef OS_WINCE
        ulError =
            RegSetValueEx(
                hPrinterKey,
                REG_RDPDR_PRINTER_CACHE_DATA,
                NULL,
                REG_BINARY,
                pbPrinterData,
                ulPrinterDataLen );
#else
        ulError = WriteCachedData(hPrinterKey, pbPrinterData, ulPrinterDataLen);
#endif
    }
    else {

        pbConfigData = (PBYTE)(pUpdatePrinterData+1);
        pbConfigData += pUpdatePrinterData->PrinterNameLen;

        //
        // write cache data.
        //

        ulError =
            RegSetValueEx(
                hPrinterKey,
                REG_RDPDR_AUTO_PRN_CACHE_DATA,
                NULL,
                REG_BINARY,
                pbConfigData,
                pUpdatePrinterData->ConfigDataLen );
    }

    if (ulError != ERROR_SUCCESS) {

        TRC_ERR((TB, _T("RegSetValueEx() failed, %ld."), ulError));
        goto Cleanup;
    }

    //
    // we are done.
    //

Cleanup:

    if( hPrinterKey != NULL ) {
        RegCloseKey( hPrinterKey );
    }

    if( hKey != NULL ) {
        RegCloseKey( hKey );
    }

    //
    // delete data buffers.
    //

    delete pbPrinterData;

    DC_END_FN();
    return ulError;
}

VOID
W32DrPRN::RenamePrinter(
    LPTSTR pwszOldname,
    LPTSTR pwszNewname
    )
{
    DC_BEGIN_FN("W32DrPRN::RenamePrinter");

    ASSERT(pwszOldname != NULL);

    ASSERT(pwszNewname != NULL);

    if (!(pwszOldname && pwszNewname)) {
        DC_END_FN();
        return;
    }

#ifndef OS_WINCE

    HANDLE hPrinter = NULL;
    BOOL bRunningOn9x = TRUE;
    OSVERSIONINFO osVersion;

    PRINTER_INFO_2 * ppi2 = NULL;
    PRINTER_INFO_2A * ppi2a = NULL; //ansi version
    DWORD size = 0;

    if (!OpenPrinter(pwszOldname, &hPrinter, NULL)) {
        TRC_ERR((TB, _T("OpenPrinter() failed, %ld."), GetLastError()));
        goto Cleanup;
    }

    //
    // We don't have GetPrinter/SetPrinter wrappers
    // so just call either the A or W api's depending on the platform
    // this works because we treat the returned data as an opaque
    // blob and pass it from one API to the next.
    //
    // Doing it this way is more efficient than calling wrappers
    // that would do a _lot_ of uncessary conversions. Although
    // it does make the code a little bit bigger.
    //
    //
    osVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    if (GetVersionEx(&osVersion)) {
        if (osVersion.dwPlatformId == VER_PLATFORM_WIN32_NT) {
            bRunningOn9x = FALSE;
        }
    }
    else
    {
        TRC_ERR((TB, _T("GetVersionEx:  %08X"), GetLastError()));
    }

    //
    // Code is duplicated to into two large separate
    // branches to reduce number of overall branches
    //
    if(!bRunningOn9x)
    {
        //Not win9x, use UNICODE API's
        if (!GetPrinter(
                hPrinter,
                2,
                (LPBYTE)ppi2,
                0,
                &size)) {

            if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
                TRC_ERR((TB, _T("GetPrinter() failed, %ld."), GetLastError()));
                goto Cleanup;
            }

            ppi2 = (PRINTER_INFO_2 *) new BYTE [size];

            if (ppi2 != NULL) {
                if (!GetPrinter(
                        hPrinter,
                        2,
                        (LPBYTE)ppi2,
                        size,
                        &size)) {

                    TRC_ERR((TB, _T("GetPrinter() failed, %ld."), GetLastError()));
                    goto Cleanup;
                }
            }
            else {
                TRC_ERR((TB, _T("GetPrinter() failed, %ld."), GetLastError()));
                goto Cleanup;
            }

            //
            // replace the name
            //
            ppi2->pPrinterName = pwszNewname;
            ppi2->pSecurityDescriptor = NULL; //we don't want to modify the security descriptors.
    
            if (!SetPrinter(hPrinter, 2, (LPBYTE)ppi2, 0)) {
                TRC_ERR((TB, _T("SetPrinter() failed, %ld."), GetLastError()));
            }
        }
    }
    else
    {
        //Do this in ANSI mode
        if (!GetPrinterA(
                hPrinter,
                2,
                (LPBYTE)ppi2a,
                0,
                &size)) {

            if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
                TRC_ERR((TB, _T("GetPrinter() failed, %ld."), GetLastError()));
                goto Cleanup;
            }

            ppi2a = (PRINTER_INFO_2A *) new BYTE [size];

            if (ppi2 != NULL) {
                if (!GetPrinterA(
                        hPrinter,
                        2,
                        (LPBYTE)ppi2a,
                        size,
                        &size)) {

                    TRC_ERR((TB, _T("GetPrinter() failed, %ld."), GetLastError()));
                    goto Cleanup;
                }
            }
            else {
                TRC_ERR((TB, _T("GetPrinter() failed, %ld."), GetLastError()));
                goto Cleanup;
            }

            //
            // replace the name
            //
            CHAR ansiPrinterName[2048];
            RDPConvertToAnsi( pwszNewname, ansiPrinterName,
                              sizeof(ansiPrinterName) );
            ppi2a->pPrinterName = ansiPrinterName;
            ppi2a->pSecurityDescriptor = NULL; //we don't want to modify the security descriptors.
    
            if (!SetPrinterA(hPrinter, 2, (LPBYTE)ppi2a, 0)) {
                TRC_ERR((TB, _T("SetPrinter() failed, %ld."), GetLastError()));
            }
        }
    }

Cleanup:
    if (hPrinter != NULL) {
        ClosePrinter(hPrinter);
    }

    if (ppi2) {
        delete[] ppi2;
    }
    else if (ppi2a)
    {
        //can't have gone through both UNICODE and ANSI branches
        delete[] ppi2a;
    }

#endif //!OS_WINCE

    DC_END_FN();
}

ULONG 
W32DrPRN::GetDevAnnounceDataSize()
/*++

Routine Description:

    Return the size (in bytes) of a device announce packet for
    this device.

Arguments:

    NA

Return Value:

    The size (in bytes) of a device announce packet for this device.

 --*/
{
    ULONG size = 0;

    DC_BEGIN_FN("W32DrPRN::GetDevAnnounceDataSize");

    ASSERT(IsValid());
    if (!IsValid()) { return 0; }

    size = 0;

    //
    //  Add the base announce size.
    //
    size += sizeof(RDPDR_DEVICE_ANNOUNCE);

    //
    //  Add the printer announce header.
    //
    size += sizeof(RDPDR_PRINTERDEVICE_ANNOUNCE);

    //
    //  Include printer name.
    //
    size += ((STRLEN(_printerName) + 1) * sizeof(WCHAR));

    //
    //  Include printer driver name.
    //
    size += ((STRLEN(_driverName) + 1) * sizeof(WCHAR));

    //
    //  Include cached data.
    //
    size += _cachedDataSize;

    DC_END_FN();

    return size;
}

VOID 
W32DrPRN::GetDevAnnounceData(
    IN PRDPDR_DEVICE_ANNOUNCE pDeviceAnnounce
    )
/*++

Routine Description:

    Add a device announce packet for this device to the input buffer. 

Arguments:

    pDeviceAnnounce -   Device Packet to Append Device Data To
    deviceType      -   Device Type Identifier
    deviceID        -   Identifier for Device

Return Value:

    NA

 --*/
{
    PRDPDR_PRINTERDEVICE_ANNOUNCE pPrinterAnnounce;
    PBYTE pbStringData;

    DC_BEGIN_FN("W32DrPRN::GetDevAnnounceData");

    ASSERT(IsValid());
    if (!IsValid()) { return; }

    //
    //  Record the device ID.
    //
    pDeviceAnnounce->DeviceType = GetDeviceType();
    pDeviceAnnounce->DeviceId   = GetID();

    //
    //  Record the port name in ANSI.
    //
#ifdef UNICODE
    RDPConvertToAnsi(GetPortName(), (LPSTR)pDeviceAnnounce->PreferredDosName,
                  sizeof(pDeviceAnnounce->PreferredDosName)
                  );
#else
    STRCPY((char *)pDeviceAnnounce->PreferredDosName, GetPortName());
#endif

    //
    //  Get pointers to printer-specific data.
    //
    pPrinterAnnounce =
        (PRDPDR_PRINTERDEVICE_ANNOUNCE)(pDeviceAnnounce + 1);

    //
    //  Embedded data pointer.
    //
    pbStringData = (PBYTE)(pPrinterAnnounce + 1);

    //
    //  Flags
    //
    pPrinterAnnounce->Flags = 0;
    if (_isDefault) {
        pPrinterAnnounce->Flags |= RDPDR_PRINTER_ANNOUNCE_FLAG_DEFAULTPRINTER;
    }

    if (_isNetwork) {
        pPrinterAnnounce->Flags |= RDPDR_PRINTER_ANNOUNCE_FLAG_NETWORKPRINTER;
    }

    if (_isTSqueue) {
        pPrinterAnnounce->Flags |= RDPDR_PRINTER_ANNOUNCE_FLAG_TSPRINTER;
    }

    //
    //  ANSI Code Page
    //
    pPrinterAnnounce->CodePage = 0;

    //
    //  Misc. Field Lengths
    //
    pPrinterAnnounce->PnPNameLen = 0;
    pPrinterAnnounce->CachedFieldsLen = 0;

    //
    //  Copy the driver name.
    //
    if (GetDriverName() != NULL) {
#if defined(UNICODE)
        //
        //  Unicode to Unicode just requires a memcpy.
        //
        pPrinterAnnounce->DriverLen = ((STRLEN(GetDriverName()) + 1) *
                                      sizeof(WCHAR));
        memcpy(pbStringData, _driverName, pPrinterAnnounce->DriverLen);
#else
        //
        //  On Win32 ANSI, we will convert to Unicode.
        //
        pPrinterAnnounce->DriverLen = ((STRLEN(GetDriverName()) + 1) *
                                      sizeof(WCHAR));
        RDPConvertToUnicode(_driverName, (LPWSTR)pbStringData, 
                        pPrinterAnnounce->DriverLen );
#endif
        pbStringData += pPrinterAnnounce->DriverLen;
    }
    else {
        pPrinterAnnounce->DriverLen = 0;
    }

    //
    //  Copy the printer name.
    //
    if (GetPrinterName() != NULL) {
#if defined(UNICODE)
        //
        //  Unicode to Unicode just requires a memcpy.
        //
        pPrinterAnnounce->PrinterNameLen = (STRLEN(_printerName) + 1) *
                                        sizeof(WCHAR);
        memcpy(pbStringData, _printerName, pPrinterAnnounce->PrinterNameLen );
#else
        //
        //  On Win32 ANSI, we will convert to Unicode.
        //
        pPrinterAnnounce->PrinterNameLen = (STRLEN(_printerName) + 1) *
                                        sizeof(WCHAR);
        RDPConvertToUnicode(_printerName, (LPWSTR)pbStringData,
                        pPrinterAnnounce->PrinterNameLen );
#endif
        pbStringData += pPrinterAnnounce->PrinterNameLen;
    }
    else  {
        pPrinterAnnounce->PrinterNameLen = 0;
    }

    //
    //  Copy the cached data.
    //
    if (_cachedData != NULL) {

        pPrinterAnnounce->CachedFieldsLen = _cachedDataSize;

        memcpy(pbStringData, _cachedData, (size_t)_cachedDataSize);

        pbStringData += _cachedDataSize;
    }

    //
    //  Computer the length of the data area that follows the device announce
    //  header.
    //
    pDeviceAnnounce->DeviceDataLength =
        (ULONG)(pbStringData - (PBYTE)pPrinterAnnounce);


    DC_END_FN();
}


#ifdef OS_WINCE
ULONG
W32DrPRN::GetCachedDataSize(
    HKEY hPrinterKey
    )
{
    DC_BEGIN_FN("W32DrPRN::GetCachedDataSize");

    TRC_ASSERT((hPrinterKey != NULL), (TB,_T("hPrinterKey is NULL")));

    DWORD dwRet = ERROR_SUCCESS;
    DWORD dwTotSize = 0;
    WCHAR szValueName[MAX_PATH];
    for (DWORD dwIndex = 0; dwRet == ERROR_SUCCESS; dwIndex++)
    {
        DWORD dwType;
        DWORD dwSize = 0;
        wsprintf(szValueName, L"%s%d", REG_RDPDR_PRINTER_CACHE_DATA, dwIndex);
        dwRet = RegQueryValueEx(hPrinterKey, szValueName, NULL, &dwType, NULL, &dwSize);
        if ((dwRet == ERROR_SUCCESS) && (dwType == REG_BINARY) )             
        {
            dwTotSize += dwSize;
        }
    }

    DC_END_FN();

    return dwTotSize;
}

ULONG
W32DrPRN::ReadCachedData(
    HKEY hPrinterKey,
    UCHAR *pBuf, 
    ULONG *pulSize
    )
{
    DC_BEGIN_FN("W32DrPRN::ReadCachedData");

    TRC_ASSERT((hPrinterKey != NULL), (TB,_T("hPrinterKey is NULL")));
    TRC_ASSERT(((pBuf != NULL) && (pulSize != NULL)), (TB,_T("Invalid parameters pBuf = 0x%08x, pulSize=0x%08x"), pBuf, pulSize));

    DWORD dwRet = ERROR_SUCCESS;
    DWORD dwRemaining = *pulSize;
    WCHAR szValueName[MAX_PATH];
    
    for (DWORD dwIndex = 0; dwRet == ERROR_SUCCESS; dwIndex++)
    {
        DWORD dwType;
        DWORD dwSize = dwRemaining;
    
        wsprintf(szValueName, L"%s%d", REG_RDPDR_PRINTER_CACHE_DATA, dwIndex);
        dwRet = RegQueryValueEx(hPrinterKey, szValueName, NULL, &dwType, pBuf, &dwSize);
        if ((dwRet == ERROR_SUCCESS) && (dwType == REG_BINARY) )             
        {
            dwRemaining -= dwSize;
            pBuf += dwSize;
        }
    }
    *pulSize -= dwRemaining;
    return (*pulSize > 0) ? ERROR_SUCCESS : dwRet;  
}

ULONG
W32DrPRN::WriteCachedData(
    HKEY hPrinterKey,
    UCHAR *pBuf, 
    ULONG ulSize
    )
{
    DC_BEGIN_FN("W32DrPRN::WriteCachedData");

    TRC_ASSERT((hPrinterKey != NULL), (TB,_T("hPrinterKey is NULL")));
    TRC_ASSERT((pBuf != NULL), (TB,_T("pBuf is NULL!")));

    DWORD dwRet = ERROR_SUCCESS;
    DWORD dwRemaining = ulSize;
    WCHAR szValueName[MAX_PATH];
    
    for (DWORD dwIndex = 0; dwRemaining > 0; dwIndex++)
    {
        DWORD dwSize = (dwRemaining >= 4096) ? 4096 : dwRemaining;
    
        wsprintf(szValueName, L"%s%d", REG_RDPDR_PRINTER_CACHE_DATA, dwIndex);
        dwRet = RegSetValueEx(hPrinterKey, szValueName, NULL, REG_BINARY, pBuf, dwSize);
        if (dwRet == ERROR_SUCCESS)          
        {
            dwRemaining -= dwSize;
            pBuf += dwSize;
        }
        else
        {
            TRC_ERR((TB, _T("Error -  RegQueryValueEx on %s failed"), szValueName));
            for (DWORD dw=0; dw<dwIndex; dw++)
            {
                wsprintf(szValueName, L"%s%d", REG_RDPDR_PRINTER_CACHE_DATA, dw);
                RegDeleteValue(hPrinterKey, szValueName);
            }
            return dwRet;
        }

    }
    DC_END_FN();
    return ERROR_SUCCESS;   
}

#endif