windows-server-2003/termsrv/notify/umrdpprn.c

/*++

Copyright (c) 1998 Microsoft Corporation

Module Name :

    umrdpprn.c

Abstract:

    User-Mode Component for RDP Device Management that Handles Printing Device-
    Specific tasks.

    This is a supporting module.  The main module is umrdpdr.c.

Author:

    TadB

Revision History:
--*/

#include "precomp.h"
#pragma hdrstop

#include <winspool.h>
#include <rdpdr.h>
#include <aclapi.h>
#include "setupapi.h"
#include "printui.h"
#include "drdevlst.h"
#include "umrdpdr.h"
#include "umrdpprn.h"
#include "drdbg.h"
#include "rdpprutl.h"
#include "tsnutl.h"
#include "rdpdr.h"

#include "errorlog.h"
#include <wlnotify.h>
#include <time.h>

////////////////////////////////////////////////////////
//
//      Defines
//

#ifndef BOOL
#define BOOL int
#endif

#ifndef ARRAYSIZE
#define ARRAYSIZE(a) (sizeof(a) / sizeof(a[0]))
#endif

#define PRINTUILIBNAME  TEXT("printui.dll")

//
//  Printui Printer Configuration Save/Restore Flags.
//

//  This one should be called as user for fetching the configuration data.
#define CMDLINE_FOR_STORING_CONFIGINFO_IMPERSONATE L"/q /Ss /n \"%ws\" /a \"%ws\" 2 7 c d u g"

//  This one should be called first as system for restoring configuration data.
#define CMDLINE_FOR_RESTORING_CONFIGINFO_NOIMPERSONATE L"/q /Sr /n \"%ws\" /a \"%ws\" 2 7 c d g r p h i" 
//  This one should be called second as user for restoring configuration data.
#define CMDLINE_FOR_RESTORING_CONFIGINFO_IMPERSONATE L"/q /Sr /n \"%ws\" /a \"%ws\" u r"


#define TEMP_FILE_PREFIX L"prn"

#define INF_PATH   L"\\inf\\ntprint.inf"

//
//  Reg key for configurable parms.
//
#define CONFIGREGKEY     \
    L"SYSTEM\\CurrentControlSet\\Control\\Terminal Server\\Wds\\rdpwd"

//
//  Location of configurable threshold for delta between printer installation
//  time and forwarding of first user-initiated configuration change data
//  to the client.  The units for this value is in seconds.
//
#define CONFIGTHRESHOLDREGVALUE   \
    L"PrintRdrConfigThreshold"

//
//  Default Value for Configurable Printer Configuration Threshold
//
#define CONFIGTHRESHOLDDEFAULT  20

//
//  Registry key for storing default, per-user, printer names.
//
#define USERDEFAULTPRNREGKEY \
    L"SYSTEM\\CurrentControlSet\\Control\\Terminal Server\\Wds\\rdpwd\\DefaultPrinterStore"

#define TSSERIALDEVICEMAP  \
    L"HARDWARE\\DEVICEMAP\\SERIALCOMM"
    
//
//  Registry location of configurable client driver name mapping INF and INF
//  section.
//
#define CONFIGUSERDEFINEDMAPPINGINFNAMEVALUE\
    L"PrinterMappingINFName"
#define CONFIGUSERDEFINEDMAPPINGINFSECTIONVALUE\
    L"PrinterMappingINFSection"

//
//  Location of Windows Directory Path
//
#define WINDOWSDIRKEY       L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion"
#define WINDOWSDIRVALUENAME L"PathName"

//  Get a numeric representation of our session ID.
#if defined(UNITTEST)
#define GETTHESESSIONID()   0
#else
extern ULONG g_SessionId;
#define GETTHESESSIONID()   g_SessionId
#endif

#if defined(UNITTEST)
HINSTANCE g_hInstance;
#else
extern HINSTANCE g_hInstance;
#endif

extern BOOL fRunningOnPTS;

//  Return true if the device type represents a serial or parallel port.
#define ISPRINTPORT(type)   (((type) == RDPDR_DTYP_SERIAL) || \
                            ((type) == RDPDR_DTYP_PARALLEL) || \
                            ((type) == RDPDR_DRYP_PRINTPORT))

//  Maximum number of characters in a session ID (Max chars in a dword is 17)
#define MAXSESSIONIDCHARS   17

//  The field types we are waiting on (Printer Config change Notification)
#define IS_CONFIG_INFO_FIELD(field) \
    (field == PRINTER_NOTIFY_FIELD_SHARE_NAME) || \
    (field == PRINTER_NOTIFY_FIELD_DEVMODE) || \
    (field == PRINTER_NOTIFY_FIELD_COMMENT) || \
    (field == PRINTER_NOTIFY_FIELD_LOCATION) || \
    (field == PRINTER_NOTIFY_FIELD_SEPFILE) || \
    (field == PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR) || \
    (field == PRINTER_NOTIFY_FIELD_PARAMETERS) || \
    (field == PRINTER_NOTIFY_FIELD_DATATYPE) || \
    (field == PRINTER_NOTIFY_FIELD_ATTRIBUTES) || \
    (field == PRINTER_NOTIFY_FIELD_PRIORITY) || \
    (field == PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY) || \
    (field == PRINTER_NOTIFY_FIELD_START_TIME) || \
    (field == PRINTER_NOTIFY_FIELD_UNTIL_TIME) || \
    (field == PRINTER_NOTIFY_FIELD_STATUS)

#define CONFIG_WAIT_PERIOD (30 * 1000)

#define INFINITE_WAIT_PERIOD (0xDFFFFFFF) //just a large number.Ok for 64-bit also.

#define DEVICE_MAP_NAME          L"\\??\\"
#define DEVICE_MAP_NAME_COUNT    4     // 4 chars - \??\




////////////////////////////////////////////////////////////////////////
//
//  Typedefs
//
typedef struct tagPRINTNOTIFYREC
{
    HANDLE  notificationObject;         // Notification object registered
                                        //  FindFirstPrinterChangeNotification.
    HANDLE  printerHandle;              // Open handle to the printer.
    DWORD   serverDeviceID;             // Server-side printer identifier.
} PRINTNOTIFYREC, *PPRINTNOTIFYREC;


////////////////////////////////////////////////////////////////////////
//
//  External Prototypes
//
#if DBG
extern void DbgMsg(CHAR *msgFormat, ...);
#endif


////////////////////////////////////////////////////////////////////////
//
//  Local Prototypes
//

WCHAR *ANSIToUnicode(
    IN LPCSTR   ansiString,
    IN UINT     codePage
    );
BOOL InstallPrinterWithPortName(
    IN DWORD  deviceID,
    IN HANDLE hTokenForLoggedOnUser,
    IN BOOL   bSetDefault,
    IN ULONG  ulFlags,
    IN PCWSTR portName,
    IN PCWSTR driverName,
    IN PCWSTR printerName,
    IN PCWSTR clientComputerName,
    IN PBYTE  cacheData,
    IN DWORD  cacheDataLen
    );
BOOL HandlePrinterNameChangeNotification(
    IN DWORD serverDeviceID,
    IN LPWSTR printerName
    );
BOOL SendAddPrinterMsgToClient(
    IN PCWSTR   printerName,
    IN PCWSTR   driverName,
    IN PCSTR    dosDevicePort
    );
BOOL SendDeletePrinterMsgToClient(
    IN PCWSTR   printerName
    );
BOOL HandlePrinterDeleteNotification(
    IN DWORD serverDeviceID
    );
void HandlePrinterRefreshNotification(
    IN PPRINTER_NOTIFY_INFO notifyInfo
    );

DWORD AddSessionIDToPrinterQueue(
    IN  HANDLE  hPrinter,
    IN  DWORD   sessionID
    );

BOOL SetDefaultPrinterToFirstFound(
    BOOL impersonate
    );

DWORD GetPrinterConfigInfo(
    LPCWSTR printerName,
    LPBYTE * ppBuffer,
    LPDWORD pdwBufSize
    );
DWORD SetPrinterConfigInfo(
    LPCWSTR printerName,
    LPVOID lpBuffer,
    DWORD dwBufSize
    );

BOOL HandlePrinterConfigChangeNotification(
    IN DWORD serverDeviceID
    );
BOOL SendPrinterConfigInfoToClient(
    IN PCWSTR printerName,
    IN LPBYTE pConfigInfo,
    IN DWORD  ConfigInfoSize
    );

DWORD CallPrintUiPersistFunc(
    LPCWSTR printerName,
    LPCWSTR fileName,
    LPCWSTR formatString
    );
BOOL
SendPrinterRenameToClient(
    IN PCWSTR oldprinterName,
    IN PCWSTR newprinterName
    );
VOID LoadConfigurableValues();
BOOL GetPrinterPortName(
    IN  HANDLE hPrinter,
    OUT PWSTR *portName
    );

BOOL MapClientPrintDriverName(
    IN  PCWSTR clientDriver,
    IN OUT PWSTR *mappedName,
    IN OUT DWORD *mappedNameBufSize
    );

DWORD PrinterDriverInstalled(
    IN PCWSTR clientDriver
    );

HANDLE RegisterForPrinterPrefNotify();

PACL GiveLoggedOnUserFullPrinterAccess(
    IN LPTSTR printerName,
    IN HANDLE hToken,
    PSECURITY_DESCRIPTOR *ppsd
);

DWORD SetPrinterDACL(
    IN LPTSTR printerName,
    IN PACL pDacl
);

VOID CloseWaitablePrintingObjects();

VOID GlobalPrintNotifyObjectSignaled(
    IN HANDLE waitableObject,
    IN PVOID clientData
    );
VOID PrintPreferenceChangeEventSignaled(
    HANDLE eventHandle,
    PVOID clientData
    );
void WaitableTimerSignaled(
    HANDLE waitableObject,
    PVOID clientData
    );
BOOL
RegisterPrinterConfigChangeNotification(
    IN DWORD serverDeviceID
    );
BOOL RestoreDefaultPrinterContext();
BOOL SaveDefaultPrinterContext(PCWSTR currentlyInstallingPrinterName);
BOOL SavePrinterNameAsGlobalDefault(
    IN PCWSTR printerName
    );

// Struct used to split a full printer name.
// Once filled, each psz points to a substring in the buffer
// or to one of the original names. Nothing allocated.
typedef struct _TS_PRINTER_NAMES {
    WCHAR   szTemp[MAX_PATH+1];
    ULONG   ulTempLen;
    PCWSTR  pszFullName;
    PCWSTR  pszCurrentClient;
    PCWSTR  pszServer;
    PCWSTR  pszClient;
    PCWSTR  pszPrinter;
} TS_PRINTER_NAMES, *PTS_PRINTER_NAMES;

void FormatPrinterName(
    PWSTR pszNewNameBuf,
    ULONG ulBufLen,
    ULONG ulFlags,
    PTS_PRINTER_NAMES pPrinterNames);

DWORD AddNamesToPrinterQueue(
    IN  HANDLE  hPrinter,
    IN  PTS_PRINTER_NAMES pPrinterNames
    );

VOID TriggerConfigChangeTimer();

#ifdef UNITTEST
void TellDrToAddTestPrinter();
void SimpleUnitTest();
#endif


////////////////////////////////////////////////////////
//
//      Globals
//

//
//  Set to TRUE when the DLL is trying to shut down.
//
extern BOOL ShutdownFlag;


////////////////////////////////////////////////////////
//
//      Globals to this Module
//

//  True if this module has been successfully initialized.
BOOL PrintingModuleInitialized = FALSE;

//  Comprehensive Device List
PDRDEVLST DeviceList;

//  Handle to the print system dev mode for this user.  This is the key
//  that is modified when a user changes a printer's printing preferences.
HKEY DevModeHKey = INVALID_HANDLE_VALUE;

//  Configurable threshold for delta between printer installation
//  time and forwarding of first user-initiated configuration change data
//  to the client.  The units for this value is in seconds.
DWORD ConfigSendThreshold;

//
//  Printer Change Notification Events
//
HANDLE   PrintNotificationEvent             = INVALID_HANDLE_VALUE;
HANDLE   PrintPreferenceChangeEvent         = NULL;

HANDLE   PrintUILibHndl                     = NULL;
FARPROC  PrintUIEntryFunc                   = NULL;
FARPROC  PnpInterfaceFunc                   = NULL;
HANDLE   UMRPDPPRN_TokenForLoggedOnUser     = INVALID_HANDLE_VALUE;
HANDLE   LocalPrinterServerHandle           = NULL;
WCHAR    PrinterInfPath[MAX_PATH + (sizeof(INF_PATH)/sizeof(WCHAR)) + 2]   = L"";   // of the form "%windir%\\inf\\ntprint.inf"
LPPRINTER_INFO_2  PrinterInfo2Buf           = NULL;
DWORD    PrinterInfo2BufSize                = 0;
//WCHAR    SessionString[MAX_PATH+1];
WCHAR    g_szFromFormat[MAX_PATH+1];
WCHAR    g_szOnFromFormat[MAX_PATH+1];

BOOL g_fIsPTS = FALSE;

BOOL g_fTimerSet = FALSE;
HANDLE WaitableTimer = NULL;

BOOL g_fDefPrinterEncountered = FALSE;

//  Global debug flag.
extern DWORD GLOBAL_DEBUG_FLAGS;

//  Printer Notify Parameters
WORD PrinterFieldType[] =
{
    PRINTER_NOTIFY_FIELD_SHARE_NAME,
    PRINTER_NOTIFY_FIELD_PRINTER_NAME,
    PRINTER_NOTIFY_FIELD_COMMENT,
    PRINTER_NOTIFY_FIELD_LOCATION,
    PRINTER_NOTIFY_FIELD_DEVMODE,
    PRINTER_NOTIFY_FIELD_SEPFILE,
    PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR,
    PRINTER_NOTIFY_FIELD_PARAMETERS,
    PRINTER_NOTIFY_FIELD_DATATYPE,
    PRINTER_NOTIFY_FIELD_ATTRIBUTES,
    PRINTER_NOTIFY_FIELD_PRIORITY,
    PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY,
    PRINTER_NOTIFY_FIELD_START_TIME,
    PRINTER_NOTIFY_FIELD_UNTIL_TIME,
    PRINTER_NOTIFY_FIELD_STATUS
};

PRINTER_NOTIFY_OPTIONS_TYPE PrinterNotifyOptionsType[] =
{
    {
        PRINTER_NOTIFY_TYPE,
        0,
        0,
        0,
        sizeof(PrinterFieldType) / sizeof(WORD),
        PrinterFieldType
    }
};
PRINTER_NOTIFY_OPTIONS PrinterNotifyOptions =
{
    2,
    0,
    sizeof(PrinterNotifyOptionsType) / sizeof(PRINTER_NOTIFY_OPTIONS_TYPE),
    PrinterNotifyOptionsType
};

//
//  User-Configurable Client Driver Mapping INF Name and INF Section.
//
LPWSTR UserDefinedMappingINFName = NULL;
LPWSTR UserDefinedMappingINFSection = NULL;

//
//  Buffer for converting from Win9x driver names to Win2K driver names.
//
PWSTR   MappedDriverNameBuf = NULL;
DWORD   MappedDriverNameBufSize = 0;

//
//  Waitable Object Manager
//
WTBLOBJMGR UMRDPPRN_WaitableObjMgr = NULL;

//
//  Default Printer Name
//
WCHAR SavedDefaultPrinterName[MAX_PATH+1] = L"";

//
// Printer section names
//

static WCHAR* prgwszPrinterSectionNames[] = {
            L"Printer Driver Mapping_Windows NT x86_Version 2",
            L"Printer Driver Mapping_Windows NT x86_Version 3",
            NULL
};


BOOL IsItPTS()
{
    OSVERSIONINFOEX gOsVersion;
    ZeroMemory(&gOsVersion, sizeof(OSVERSIONINFOEX));
    gOsVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
    GetVersionEx( (LPOSVERSIONINFO ) &gOsVersion);

    return (gOsVersion.wProductType == VER_NT_WORKSTATION)  // product type must be workstation.
                && !(gOsVersion.wSuiteMask & VER_SUITE_PERSONAL) // and product suite must not be personal.
                    && (gOsVersion.wSuiteMask & VER_SUITE_SINGLEUSERTS); // it must be single user ts.
}


BOOL UMRDPPRN_Initialize(
    IN PDRDEVLST deviceList,
    IN WTBLOBJMGR waitableObjMgr,
    IN HANDLE hTokenForLoggedOnUser
    )
/*++

Routine Description:

    Initialize this module.  This must be called prior to any other functions
    in this module being called.

Arguments:

    deviceList              - Comprehensive list of redirected devices.
    waitableObjMgr          - Waitable object manager.
    hTokenForLoggedOnUser   - This is the token for the logged in user.

Return Value:

    Returns TRUE on success.  FALSE, otherwise.

--*/
{
    HKEY regKey;
    LONG sz;
    DWORD errorEventID = -1;
    DWORD errorEventLineNumber = 0;

    BOOL result, impersonated = FALSE;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:UMRDPPRN_Initialize.\n"));

    //
    //  Make sure we don't get called twice without getting cleaned up.
    //
    ASSERT((PrintNotificationEvent == INVALID_HANDLE_VALUE) &&
           (PrintPreferenceChangeEvent == NULL) &&
           (PrintUILibHndl == NULL) &&
           (PrintUIEntryFunc == NULL) &&
           (PnpInterfaceFunc == NULL) &&
           (UMRPDPPRN_TokenForLoggedOnUser == INVALID_HANDLE_VALUE) &&
           (PrinterInfo2Buf == NULL) &&
           (PrinterInfo2BufSize == 0) &&
           (UMRDPPRN_WaitableObjMgr == NULL) &&
           (WaitableTimer == NULL) &&
           (DeviceList == NULL) &&
           !PrintingModuleInitialized);

    //
    // Is it PTS?
    //
    g_fIsPTS = IsItPTS();

    //
    //  Zero the default printer name record.
    //
    wcscpy(SavedDefaultPrinterName, L"");

    //
    //  Record the device list.
    //
    DeviceList = deviceList;

    //
    //  Record the waitable object mananager.
    //
    UMRDPPRN_WaitableObjMgr = waitableObjMgr;

    //
    //  Record the token for the logged in user.
    //
    UMRPDPPRN_TokenForLoggedOnUser = hTokenForLoggedOnUser;

    ASSERT(UMRPDPPRN_TokenForLoggedOnUser != NULL);
    
    if (UMRPDPPRN_TokenForLoggedOnUser != NULL) {
        impersonated = ImpersonateLoggedOnUser(UMRPDPPRN_TokenForLoggedOnUser);
        //
        // not fatal. Just a perf hit
        //
        if (!impersonated) {
            DBGMSG(DBG_ERROR,
             ("UMRDPPRN:Impersonation failed. Error: %ld\n", GetLastError()));
        }
            
    }
    //
    //  Open the local print server while impersonating.
    //  We need to impersonate so that notifications for 
    //  the printers belonging to the current user's sessions 
    //  are not sent to any other sessions.
    //

    result = OpenPrinter(NULL, &LocalPrinterServerHandle, NULL);

    if (impersonated) {
        RevertToSelf();
    }

    //
    //  Initialize the print utility module, RDPDRPRT
    //
    if (result) {
        result = RDPDRUTL_Initialize(hTokenForLoggedOnUser);
        if (!result) {
            errorEventID = EVENT_NOTIFY_INSUFFICIENTRESOURCES;
            errorEventLineNumber = __LINE__;
        }
    }
    else {
        errorEventID = EVENT_NOTIFY_SPOOLERERROR;
        errorEventLineNumber = __LINE__;
        DBGMSG(DBG_ERROR,
            ("UMRDPPRN:Error opening printer. Error: %ld\n",
            GetLastError()));
    }

    //
    //  Load configurable values out of the registry.
    //
    LoadConfigurableValues();

    //
    //  Create the timer even that we use for staggering printer
    //  configuration changes to the client.
    //
    if (result) {
        WaitableTimer = CreateWaitableTimer(
                            NULL,       // Security Attribs
                            TRUE,      // Manual Reset
                            NULL);      // Timer Name
        if (WaitableTimer != NULL) {
            if (WTBLOBJ_AddWaitableObject(
                                UMRDPPRN_WaitableObjMgr, NULL,
                                WaitableTimer,
                                WaitableTimerSignaled
                                ) != ERROR_SUCCESS) {
                errorEventID = EVENT_NOTIFY_INSUFFICIENTRESOURCES;
                errorEventLineNumber = __LINE__;
                result = FALSE;
            }

        }
        else {
            errorEventID = EVENT_NOTIFY_INSUFFICIENTRESOURCES;
            errorEventLineNumber = __LINE__;
            DBGMSG(DBG_ERROR,
                ("UMRDPPRN:Error creating Waitable timer. Error: %ld\n",
                GetLastError()));
            result = FALSE;
        }
    }

    //
    //  Register for changes to one of this session's printers' Printing
    //  Preferences.
    //
    if (result) {
        PrintPreferenceChangeEvent = RegisterForPrinterPrefNotify();
        if (PrintPreferenceChangeEvent != NULL) {
            if (WTBLOBJ_AddWaitableObject(
                                UMRDPPRN_WaitableObjMgr, NULL,
                                PrintPreferenceChangeEvent,
                                PrintPreferenceChangeEventSignaled
                                ) != ERROR_SUCCESS) {
                errorEventID = EVENT_NOTIFY_INSUFFICIENTRESOURCES;
                errorEventLineNumber = __LINE__;
                result = FALSE;
            }
        }
        else {
            result = FALSE;
        }
    }

    //
    //  Register for change notification on addition/deletion of a
    //  printer.
    //
    if (result) {
        PrintNotificationEvent = FindFirstPrinterChangeNotification(
                                                    LocalPrinterServerHandle,
                                                    0, 0, &PrinterNotifyOptions
                                                    );
        if (PrintNotificationEvent != INVALID_HANDLE_VALUE) {
            DWORD dwLastError = WTBLOBJ_AddWaitableObject(
                                UMRDPPRN_WaitableObjMgr, NULL,
                                PrintNotificationEvent,
                                GlobalPrintNotifyObjectSignaled
                                );
            result = dwLastError == ERROR_SUCCESS;
        }
        else {
            DWORD dwLastError = GetLastError();

            errorEventID = EVENT_NOTIFY_SPOOLERERROR;
            errorEventLineNumber = __LINE__;

            ClosePrinter(LocalPrinterServerHandle);
            LocalPrinterServerHandle = NULL;
            DBGMSG(DBG_ERROR,
                ("UMRDPPRN:Error registering for printer change notification. Error: %ld\n",
                dwLastError));
        }
    }

    //
    //  Construct the inf path for printer installation
    //
    if (result) {
        DWORD dwResult;
        dwResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, WINDOWSDIRKEY, 0,
                              KEY_READ, &regKey);
        result = (dwResult == ERROR_SUCCESS);
        if (result)  {
            sz = sizeof(PrinterInfPath);
            dwResult = RegQueryValueEx(regKey,
                                    WINDOWSDIRVALUENAME,
                                    NULL,
                                    NULL,
                                    (PBYTE)PrinterInfPath,
                                    &sz);

            result = (dwResult == ERROR_SUCCESS);
            if (result) {
                wcscat(PrinterInfPath, INF_PATH);
            }
            else {
                DBGMSG(DBG_ERROR,
                    ("UMRDPPRN:Error reading registry value for windows directory. Error: %ld\n",
                    dwResult));
            }
            RegCloseKey(regKey);
        }
        else {
            errorEventID = EVENT_NOTIFY_INTERNALERROR;
            errorEventLineNumber = __LINE__;
            DBGMSG(DBG_ERROR,
                ("UMRDPPRN:Error opening registry key for windows directory. Error: %ld\n",
                dwResult));
        }
    }

    //
    //  Load the PrintUILib DLL.
    //
    if (result) {
        PrintUILibHndl = LoadLibrary(PRINTUILIBNAME);

        result = (PrintUILibHndl != NULL);
        if (!result) {
            errorEventID = EVENT_NOTIFY_INTERNALERROR;
            errorEventLineNumber = __LINE__;
            DBGMSG(DBG_ERROR,
                ("UMRDPPRN:Unable to load PRINTUI DLL. Error: %ld\n",
                GetLastError()));
        }
    }

    //
    //  Get a pointer to the only entry point that we use.
    //
    if (result) {
        PrintUIEntryFunc = GetProcAddress(PrintUILibHndl, "PrintUIEntryW");
        PnpInterfaceFunc = GetProcAddress(PrintUILibHndl, "PnPInterface");
        result = (PrintUIEntryFunc != NULL && PnpInterfaceFunc != NULL);
        if (!result) {
            errorEventID = EVENT_NOTIFY_INTERNALERROR;
            errorEventLineNumber = __LINE__;
            DBGMSG(DBG_ERROR,
                ("UMRDPPRN:Unable to locate PRINTUI DLL function. Error: %ld\n",
                GetLastError()));
        }
    }

    //
    //  Initialize the printer driver name mapping buffer to a reasonable size.
    //  Failure of this function to allocate memory is not a critical error because
    //  we can try again later, if necessary.
    //
    UMRDPDR_ResizeBuffer(&MappedDriverNameBuf, MAX_PATH * sizeof(WCHAR),
                        &MappedDriverNameBufSize);

    //
    //  Load our localizable "session" printer name component from the resource file.
    //
    if (result) {
        if (!LoadString(g_hInstance,
            g_fIsPTS?IDS_TSPTEMPLATE_FROM:IDS_TSPTEMPLATE_FROM_IN,
            g_szFromFormat,
            sizeof(g_szFromFormat) / sizeof(g_szFromFormat[0])
            )) {
            DBGMSG(DBG_ERROR, ("UMRDPPRN:LoadString failed with Error: %ld.\n", GetLastError()));
            g_szFromFormat[0] = L'\0';
        }

        if (!LoadString(g_hInstance,
            g_fIsPTS?IDS_TSPTEMPLATE_ON_FROM:IDS_TSPTEMPLATE_ON_FROM_IN,
            g_szOnFromFormat,
            sizeof(g_szOnFromFormat) / sizeof(g_szOnFromFormat[0])
            )) {
            DBGMSG(DBG_ERROR, ("UMRDPPRN:LoadString failed with Error: %ld.\n", GetLastError()));
            g_szOnFromFormat[0] = L'\0';
        }
    }

    if (result) {
        DBGMSG(DBG_INFO, ("UMRDPPRN:UMRDPPRN_Initialize succeeded.\n"));
        PrintingModuleInitialized = TRUE;
    }
    else {

        //
        //  Log an error event if we were able to discern one.
        //
        if (errorEventID != -1) {
            TsLogError(errorEventID, EVENTLOG_ERROR_TYPE, 0, NULL, errorEventLineNumber);
        }

        if (PrintUILibHndl != NULL) {
            FreeLibrary(PrintUILibHndl);
            PrintUILibHndl = NULL;
        }
        PrintUIEntryFunc = NULL;
        PnpInterfaceFunc = NULL;

        //
        //  Close down waitable objects.
        //
        CloseWaitablePrintingObjects();

        //
        //  Zero the waitable object manager.
        //
        UMRDPPRN_WaitableObjMgr = NULL;

        if (LocalPrinterServerHandle != NULL) {
            ClosePrinter(LocalPrinterServerHandle);
            LocalPrinterServerHandle = NULL;
        }

        //
        //  Release the user-configurable client driver name mapping INF
        //  and section names.
        //
        if (UserDefinedMappingINFName != NULL) {
            FREEMEM(UserDefinedMappingINFName);
            UserDefinedMappingINFName = NULL;
        }
        if (UserDefinedMappingINFSection != NULL) {
            FREEMEM(UserDefinedMappingINFSection);
            UserDefinedMappingINFSection = NULL;
        }
    }
    return result;
}

BOOL
UMRDPPRN_Shutdown()
/*++

Routine Description:

    Close down this module.  Right now, we just need to shut down the
    background thread.

Arguments:

    NA

Return Value:

    Returns TRUE on success.  FALSE, otherwise.

--*/
{
    DBGMSG(DBG_TRACE, ("UMRDPPRN:UMRDPPRN_Shutdown.\n"));

    //
    // Check if we are already shutdown
    //
    if (!PrintingModuleInitialized) {
        return TRUE;
    }

    //
    //  Unload printui.dll.
    //
    if (PrintUILibHndl != NULL) {
        FreeLibrary(PrintUILibHndl);
        PrintUILibHndl = NULL;
    }

    //
    //  Zero the printui entry point function.
    //
    PrintUIEntryFunc = NULL;
    PnpInterfaceFunc = NULL;

    //
    //  Shut down the print utility module, RDPDRPRT
    //
    RDPDRUTL_Shutdown();

    //
    //  Close down waitable objects.
    //
    CloseWaitablePrintingObjects();

    //
    //  Zero the waitable object manager.
    //
    UMRDPPRN_WaitableObjMgr = NULL;

    //
    //  Zero the device list.
    //
    DeviceList = NULL;

    //
    //  Close the handle to the open printing system dev mode registry
    //  key for this user.
    //
    if (DevModeHKey != INVALID_HANDLE_VALUE) {
        RegCloseKey(DevModeHKey);
        DevModeHKey = INVALID_HANDLE_VALUE;
    }

    //
    //  Close the handle to the local print server.
    //
    if (LocalPrinterServerHandle != NULL) {
        ClosePrinter(LocalPrinterServerHandle);
        LocalPrinterServerHandle = NULL;
    }

    //
    //  Release the printer information level 2 buffer.
    //
    if (PrinterInfo2Buf != NULL) {
        FREEMEM(PrinterInfo2Buf);
        PrinterInfo2Buf = NULL;
        PrinterInfo2BufSize = 0;
    }

    //
    //  Release the printer driver name conversion buffer.
    //
    if (MappedDriverNameBuf != NULL) {
        FREEMEM(MappedDriverNameBuf);
        MappedDriverNameBuf = NULL;
        MappedDriverNameBufSize = 0;
    }

    //
    //  Release the user-configurable client driver name mapping INF
    //  and section names.
    //
    if (UserDefinedMappingINFName != NULL) {
        FREEMEM(UserDefinedMappingINFName);
        UserDefinedMappingINFName = NULL;
    }
    if (UserDefinedMappingINFSection != NULL) {
        FREEMEM(UserDefinedMappingINFSection);
        UserDefinedMappingINFSection = NULL;
    }

    //
    //  Zero the logged on user token.
    //
    UMRPDPPRN_TokenForLoggedOnUser = INVALID_HANDLE_VALUE;

    //
    //  We are no longer initialized.
    //
    PrintingModuleInitialized = FALSE;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:UMRDPPRN_Shutdown succeeded.\n"));
    return TRUE;
}

VOID
CloseWaitablePrintingObjects()
/*++

Routine Description:

    Close out all waitable objects for this module.

Arguments:

    NA

Return Value:

    NA

--*/
{
    DWORD ofs;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:CloseWaitablePrintingObjects begin.\n"));

    //
    //  Scan the device list, looking for printing devices with registered
    //  change notifications.
    //
    if (DeviceList != NULL) {
        for (ofs=0; ofs<DeviceList->deviceCount; ofs++) {

            if ((DeviceList->devices[ofs].deviceType == RDPDR_DTYP_PRINT) &&
                (DeviceList->devices[ofs].deviceSpecificData != NULL)) {

                PPRINTNOTIFYREC notifyRec = (PPRINTNOTIFYREC)
                                            DeviceList->devices[ofs].deviceSpecificData;
                ASSERT(notifyRec->notificationObject != NULL);
                ASSERT(notifyRec->printerHandle != NULL);

                if (UMRDPPRN_WaitableObjMgr != NULL) {
                    WTBLOBJ_RemoveWaitableObject(
                                UMRDPPRN_WaitableObjMgr,
                                notifyRec->notificationObject
                                );
                }

                FindClosePrinterChangeNotification(
                    notifyRec->notificationObject
                    );
                FREEMEM(notifyRec);
                DeviceList->devices[ofs].deviceSpecificData = NULL;
            }

        }
    }

    //
    //  Close the waitable timer.
    //
    if (WaitableTimer != NULL) {
        if (UMRDPPRN_WaitableObjMgr != NULL) {
            WTBLOBJ_RemoveWaitableObject(
                    UMRDPPRN_WaitableObjMgr,
                    WaitableTimer
                    );
        }
        CloseHandle(WaitableTimer);
        WaitableTimer = NULL;
    }

    //
    //  Close the handle to the printer notification event.
    //
    if (PrintNotificationEvent != INVALID_HANDLE_VALUE) {
        if (UMRDPPRN_WaitableObjMgr != NULL) {
            WTBLOBJ_RemoveWaitableObject(
                    UMRDPPRN_WaitableObjMgr,
                    PrintNotificationEvent
                    );
        }
        FindClosePrinterChangeNotification(PrintNotificationEvent);
        PrintNotificationEvent = INVALID_HANDLE_VALUE;
    }

    //
    //  Close the handle to the printer preference change notification event.
    //
    if (PrintPreferenceChangeEvent != NULL) {
        if (UMRDPPRN_WaitableObjMgr != NULL) {
            WTBLOBJ_RemoveWaitableObject(
                    UMRDPPRN_WaitableObjMgr,
                    PrintPreferenceChangeEvent
                    );
        }
        CloseHandle(PrintPreferenceChangeEvent);
        PrintPreferenceChangeEvent = NULL;
    }

    DBGMSG(DBG_TRACE, ("UMRDPPRN:CloseWaitablePrintingObjects end.\n"));
}

BOOL
UMRDPPRN_HandlePrinterAnnounceEvent(
    IN PRDPDR_PRINTERDEVICE_SUB pPrintAnnounce
    )
/*++

Routine Description:

    Handle a printing device announce event from the "dr" by installing a
    local print queue and adding a record for the device to the list of
    installed devices.

Arguments:

    hTokenForLoggedOnUser - Logged on user token.
    pPrintAnnounce -  Printer device announce event.

Return Value:

    Return TRUE on success.  FALSE, otherwise.

--*/
{
    PWSTR driverName;
    PWSTR printerName;
    PBYTE pDataFollowingEvent;
    UINT codePage;
    int numChars;
    PWSTR drvNameStringConvertBuf=NULL;
    PWSTR prnNameStringConvertBuf=NULL;
    BOOL result = FALSE;
    PBYTE pPrinterCacheData=NULL;
    DWORD PrinterCacheDataLen=0;
    BOOL bSetDefault = FALSE;

#if DBG
    HANDLE hPrinter = NULL;
    PRINTER_DEFAULTS defaults = {NULL, NULL, PRINTER_ALL_ACCESS};
#endif

    if (!PrintingModuleInitialized) {
        return FALSE;
    }

    DBGMSG(DBG_TRACE, ("UMRDPPRN:HandlePrinterAnnounceEvent.\n"));

    // Sanity check the incoming event.
    ASSERT(pPrintAnnounce->deviceFields.DeviceType == RDPDR_DTYP_PRINT);
    ASSERT(pPrintAnnounce->deviceFields.DeviceDataLength >=
           sizeof(PRDPDR_PRINTERDEVICE_ANNOUNCE));

    // Get a pointer to the data that follows the event.
    pDataFollowingEvent = ((PBYTE)pPrintAnnounce) +
                        sizeof(RDPDR_PRINTERDEVICE_SUB);

    // The driver name is the second field.
    driverName = (PWSTR)(pDataFollowingEvent +
                          pPrintAnnounce->clientPrinterFields.PnPNameLen
                          );

    // The printer name is the third field.
    printerName = (PWSTR)(pDataFollowingEvent +
                          pPrintAnnounce->clientPrinterFields.PnPNameLen +
                          pPrintAnnounce->clientPrinterFields.DriverLen
                          );
    // NULL-terminate the names.
    // Length (in bytes) from client includes the null.
    // So, we need to subtract 1 and then NULL-terminate.
    if (pPrintAnnounce->clientPrinterFields.DriverLen > 0) {
        driverName[pPrintAnnounce->clientPrinterFields.DriverLen/sizeof(WCHAR) - 1] = L'\0';
    }

    if (pPrintAnnounce->clientPrinterFields.PrinterNameLen > 0) {
        printerName[pPrintAnnounce->clientPrinterFields.PrinterNameLen/sizeof(WCHAR) - 1] = L'\0';
    }

    // Cache data is the last field
    if (pPrintAnnounce->clientPrinterFields.CachedFieldsLen > 0) {
        PrinterCacheDataLen = pPrintAnnounce->clientPrinterFields.CachedFieldsLen;
        pPrinterCacheData = (PBYTE)(pDataFollowingEvent +
                                  pPrintAnnounce->clientPrinterFields.PnPNameLen +
                                  pPrintAnnounce->clientPrinterFields.DriverLen +
                                  pPrintAnnounce->clientPrinterFields.PrinterNameLen
                                  );
        DBGMSG(DBG_TRACE, ("PrinterNameLen - %ld\n", pPrintAnnounce->clientPrinterFields.PrinterNameLen));
    }

    //
    //  See if we need to convert the name from ANSI to UNICODE.
    //
    if (pPrintAnnounce->clientPrinterFields.Flags & RDPDR_PRINTER_ANNOUNCE_FLAG_ANSI) {

        DBGMSG(DBG_TRACE, ("UMRDPPRN:HandlePrinterAnnounceEvent ansi flag is set.\n"));
        DBGMSG(DBG_TRACE, ("UMRDPPRN:HandlePrinterAnnounceEvent converting to unicode.\n"));

        //
        //  Convert the driver name.
        //
        drvNameStringConvertBuf = ANSIToUnicode(
                                    (LPCSTR)driverName,
                                    pPrintAnnounce->clientPrinterFields.CodePage
                                    );
        if (drvNameStringConvertBuf != NULL) {
            driverName = drvNameStringConvertBuf;
        }
        else {
            return FALSE;
        }

        //
        //  Convert the printer name.
        //
        prnNameStringConvertBuf = ANSIToUnicode(
                                    (LPCSTR)printerName,
                                    pPrintAnnounce->clientPrinterFields.CodePage
                                    );
        if (prnNameStringConvertBuf != NULL) {
            printerName = prnNameStringConvertBuf;
        }
        else {
            FREEMEM(drvNameStringConvertBuf);
            return FALSE;
        }
    }

    if (pPrintAnnounce->clientPrinterFields.Flags &
                        RDPDR_PRINTER_ANNOUNCE_FLAG_DEFAULTPRINTER) {
        bSetDefault = TRUE;
        g_fDefPrinterEncountered = TRUE;
    }
    else {
        bSetDefault = (!g_fDefPrinterEncountered) ? TRUE : FALSE;
    }

    DBGMSG(DBG_TRACE, ("UMRDPPRN:HandlePrinterAnnounceEvent driver name is %ws.\n",
            driverName));
    DBGMSG(DBG_TRACE, ("UMRDPPRN:HandlePrinterAnnounceEvent printer name is %ws.\n",
            printerName));

    // We will install the printer using the driver name only for now.
    // Later, we can take advantage of the rest of the fields.
    if (UMRDPDR_fAutoInstallPrinters()) {

        result =  InstallPrinterWithPortName(
                                    pPrintAnnounce->deviceFields.DeviceId,
                                    UMRPDPPRN_TokenForLoggedOnUser,
                                    bSetDefault,
                                    pPrintAnnounce->clientPrinterFields.Flags,
                                    pPrintAnnounce->portName,
                                    driverName,
                                    printerName,
                                    pPrintAnnounce->clientName,
                                    pPrinterCacheData,
                                    PrinterCacheDataLen
                                    );
    }
    else {
            result = TRUE;
    }


    // Release any buffers allocated for string conversion.
    if (drvNameStringConvertBuf != NULL) {
        FREEMEM(drvNameStringConvertBuf);
    }

    if (prnNameStringConvertBuf != NULL) {
        FREEMEM(prnNameStringConvertBuf);
    }

    return result;
}

void
PrintPreferenceChangeEventSignaled(
    HANDLE eventHandle,
    PVOID clientData
    )
/*++

Routine Description:

    This function handles when the user changes one of this session's printers'
    Printing Preferences settings.

Arguments:

    eventHandle - Signaled event.
    clientData  - Client data associated with callback registration.

Return Value:

    NA

--*/

{
    time_t timeDelta;
    ULONG ofs;
    ULONG ret;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:PrintPreferenceChangeEventSignaled entered.\n"));

    //
    //  Reregister the change notification.
    //
    ASSERT(DevModeHKey != INVALID_HANDLE_VALUE);
    ret = RegNotifyChangeKeyValue(
                          DevModeHKey,
                          TRUE,
                          REG_NOTIFY_CHANGE_NAME | REG_NOTIFY_CHANGE_LAST_SET,
                          eventHandle,
                          TRUE
                          );

    //
    //  On failure, remove the notification registration.
    //
    if (ret != ERROR_SUCCESS) {

        //
        //  Catch this with an assert so we can know how often this happens.
        //
        ASSERT(FALSE);

        if (PrintPreferenceChangeEvent != NULL) {
            if (UMRDPPRN_WaitableObjMgr != NULL) {
                WTBLOBJ_RemoveWaitableObject(
                        UMRDPPRN_WaitableObjMgr,
                        PrintPreferenceChangeEvent
                        );
            }
            CloseHandle(PrintPreferenceChangeEvent);
            PrintPreferenceChangeEvent = NULL;
        }

        DBGMSG(DBG_ERROR,
            ("UMRDPPRN: can't register for registry key change event:  %ld.\n",
            ret));
    }

    //
    //  Since we have no way of knowing which printer changed, we need to
    //  handle this change for all printing devices.
    //
    for (ofs=0; ofs<DeviceList->deviceCount; ofs++)  {

        if (DeviceList->devices[ofs].deviceType == RDPDR_DTYP_PRINT) {

            //
            //  Get the delta between the current time and when this device was
            //  installed.  It outside the configurable threshhold, then the
            //  updated configuration should be sent to the client.
            //
            timeDelta = time(NULL) - DeviceList->devices[ofs].installTime;
            if ((DWORD)timeDelta > ConfigSendThreshold) {

                DBGMSG(DBG_TRACE,
                    ("UMRDPPRN:Processing config change because outside time delta.\n")
                    );

                //
                //  Need to record that the configuration has changed and set a
                //  timer on forwarding to the client in order to compress changes into
                //  a single message to the client.
                //
                DeviceList->devices[ofs].fConfigInfoChanged = TRUE;
                TriggerConfigChangeTimer();
            }
        }
    }

    DBGMSG(DBG_TRACE, ("UMRDPPRN:PrintPreferenceChangeEventSignaled done.\n"));
}

void
GlobalPrintNotifyObjectSignaled(
    HANDLE waitableObject,
    PVOID clientData
    )
/*++

Routine Description:

    This function is called when the notification object for the local
    print server is signaled.  This is how we catch "global" changes to
    the server printer configuration.

    Changes detected here allow us to detect manually added TS printers
    as well as a subset of possible configuration changes to existing
    printers for this session.

Arguments:

    waitableObject  -   Associated waitable object.
    clientData      -   Client data associated with callback registration.

Return Value:

    NA

--*/
{
    DWORD changeValue;
    PPRINTER_NOTIFY_INFO notifyInfo=NULL;
    UINT32 i;
    BOOL result;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:GlobalPrintNotifyObjectSignaled entered.\n"));

    //
    //  Return immediately if the DLL is trying to shut down.  This
    //  is to help prevent us from getting stuck in a system call.
    //
    if (ShutdownFlag) {
        return;
    }

    //
    //  These two objects should be on in the same.
    //
    ASSERT(PrintNotificationEvent == waitableObject);

    //
    //  Find out what changed.
    //
    PrinterNotifyOptions.Flags &= ~PRINTER_NOTIFY_OPTIONS_REFRESH;
    result = FindNextPrinterChangeNotification(
            PrintNotificationEvent, &changeValue,
            &PrinterNotifyOptions, &notifyInfo
            );

    if (result && (notifyInfo != NULL)) {

        //
        //  If this is not a refresh, then just handle individual notification
        //  events.
        //
        if (!(notifyInfo->Flags & PRINTER_NOTIFY_INFO_DISCARDED)) {

            for (i=0; i<notifyInfo->Count; i++) {

                // Notification Type must be PRINTER_NOTIFY_TYPE.
                ASSERT(notifyInfo->aData[i].Type == PRINTER_NOTIFY_TYPE);

                //
                //  If we have a printer name change event.  This is what we use to
                //  detect new printers and renamed printers.
                //
                if (notifyInfo->aData[i].Field == PRINTER_NOTIFY_FIELD_PRINTER_NAME) {

                    HandlePrinterNameChangeNotification(
                                            notifyInfo->aData[i].Id,
                                            (LPWSTR)notifyInfo->aData[i].NotifyData.Data.pBuf
                                            );
                }
                //
                // If the Configuration Information changed.
                //
                else if (IS_CONFIG_INFO_FIELD(notifyInfo->aData[i].Field)) {

                    HandlePrinterConfigChangeNotification(
                                            notifyInfo->aData[i].Id
                                            );
                }
            }
        }
        //
        //  Otherwise, we need to refresh.  This is an unusual case.
        //
        else {
            DBGMSG(DBG_TRACE,
                  ("UMRDPPRN:!!!!FindNextPrinterChangeNotification refresh required.!!!!\n"));

            //
            //  This refreshes the complete list of printers.
            //
            FreePrinterNotifyInfo(notifyInfo);
            notifyInfo = NULL;
            PrinterNotifyOptions.Flags |= PRINTER_NOTIFY_OPTIONS_REFRESH;
            result = FindNextPrinterChangeNotification(
                    PrintNotificationEvent, &changeValue,
                    &PrinterNotifyOptions, &notifyInfo
                    );

            //
            //  Make sure our view of the list of available printers
            //  is accurate.
            //
            if (result) {
                HandlePrinterRefreshNotification(
                                            notifyInfo
                                            );
            }
            else {
                DBGMSG(DBG_ERROR, ("UMRDPPRN:FindNextPrinterChangeNotification failed:  %ld.\n",
                        GetLastError()));
            }
        }

    }

    //
    //  On failure, we need to remove the printer change notification object so we don't
    //  get into an infinite loop caused by the notification object never entering a
    //  non-signaled state.  This can happen on a stressed machine and is an unusual
    //  case.
    //
    if (!result) {
        
        DBGMSG(DBG_ERROR, ("UMRDPPRN:FindNextPrinterChangeNotification failed:  %ld.\n",
                GetLastError()));
        DBGMSG(DBG_ERROR, ("UMRDPPRN:Disabling print change notification.\n"));

        if (PrintNotificationEvent != INVALID_HANDLE_VALUE) {
            WTBLOBJ_RemoveWaitableObject(
                    UMRDPPRN_WaitableObjMgr,
                    PrintNotificationEvent
                    );
            FindClosePrinterChangeNotification(PrintNotificationEvent);
            PrintNotificationEvent = INVALID_HANDLE_VALUE;
        }
    }

    //
    //  Release the notification buffer.
    //
    if (notifyInfo != NULL) {
        FreePrinterNotifyInfo(notifyInfo);
    }
}

VOID
SinglePrinterNotifyObjectSignaled(
    HANDLE waitableObject,
    PPRINTNOTIFYREC notifyRec
    )
/*++

Routine Description:

    This function is called when the notification object for a single
    printer is signaled.  This function indicates that we need to forward
    configuration information for a specific printer to the client for
    persistent storage.

Arguments:

    waitableObject  -   Associated waitable object.
    serverDeviceID  -   Device list identifier for printing device being
                        signaled.

Return Value:

    NA

--*/
{
    DWORD ofs;
    BOOL result;
    DWORD changeValue;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:SinglePrinterNotifyObjectSignaled entered.\n"));

    //
    //  Return immediately if the DLL is trying to shut down.  This
    //  is to help prevent us from getting stuck in a system call.
    //
    if (ShutdownFlag) {
        return;
    }

    result = DRDEVLST_FindByServerDeviceID(
                                    DeviceList,
                                    notifyRec->serverDeviceID,
                                    &ofs);
    ASSERT(result);

    //
    //  Re-register the change notification.
    //
    if (result) {

        ASSERT(notifyRec ==
                (PPRINTNOTIFYREC)DeviceList->devices[ofs].deviceSpecificData)
        ASSERT(notifyRec->notificationObject != NULL);
        ASSERT(notifyRec->printerHandle != NULL);
        ASSERT(notifyRec->notificationObject == waitableObject);

        result = FindNextPrinterChangeNotification(
                        notifyRec->notificationObject,
                        &changeValue,
                        NULL, NULL
                        );
    }

    //
    //  If this failed, we need to release the change notification
    //  object to prevent infinitely looping on a signaled object.
    //
    if (!result) {
        //
        //  Catch this with an assert so we can know how often this happens.
        //
        ASSERT(FALSE);

        WTBLOBJ_RemoveWaitableObject(
                            UMRDPPRN_WaitableObjMgr,
                            notifyRec->notificationObject
                            );

        FindClosePrinterChangeNotification(
                            notifyRec->notificationObject
                            );
        ClosePrinter(notifyRec->printerHandle);
        FREEMEM(notifyRec);
        DeviceList->devices[ofs].deviceSpecificData = NULL;

    }


    //
    //  Handle the change.
    //
    if (result) {

        //
        //  If it's a printer deletion.
        //
        if (changeValue & PRINTER_CHANGE_DELETE_PRINTER) {

            HandlePrinterDeleteNotification(notifyRec->serverDeviceID);
        }
        //
        //  If it's a configuration change.
        //
        else if (changeValue &
                 (PRINTER_CHANGE_ADD_PRINTER_DRIVER |
                  PRINTER_CHANGE_SET_PRINTER_DRIVER |
                  PRINTER_CHANGE_DELETE_PRINTER_DRIVER)) {

            HandlePrinterConfigChangeNotification(notifyRec->serverDeviceID);
        }
    }

    DBGMSG(DBG_TRACE,
        ("UMRDPPRN:SinglePrinterNotifyObjectSignaled exit.\n")
        );
}

void
HandlePrinterRefreshNotification(
    IN PPRINTER_NOTIFY_INFO notifyInfo
    )
/*++

Routine Description:

    Handle a print notification refresh from the spooler.

Arguments:

    notifyInfo          - Notify info pointer returned by
                          FindNextPrinterChangeNotification.

Return Value:

    NA

--*/
{
    DWORD deviceListOfs;
    DWORD notifyOfs;
    LPWSTR printerName;
    DWORD i;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:HandlePrinterRefreshNotification entered.\n"));

    //
    //  Return immediately if the DLL is trying to shut down.  This
    //  is to help prevent us from getting stuck in a system call.
    //
    if (ShutdownFlag) {
        return;
    }

    //
    //  Handle printer additions, renames, etc.
    //
    for (i=0; i<notifyInfo->Count; i++) {

        // Notification Type must be PRINTER_NOTIFY_TYPE.
        ASSERT(notifyInfo->aData[i].Type == PRINTER_NOTIFY_TYPE);

        //
        //  If we have a printer name change event.  This is what we use to
        //  detect new printers and renamed printers.
        //
        if (notifyInfo->aData[i].Field == PRINTER_NOTIFY_FIELD_PRINTER_NAME) {

            printerName = (LPWSTR)notifyInfo->aData[i].NotifyData.Data.pBuf;
            HandlePrinterNameChangeNotification(
                                    notifyInfo->aData[i].Id,
                                    printerName
                                    );
        }
    }
}

BOOL
HandlePrinterDeleteNotification(
    IN DWORD serverDeviceID
    )
/*++

Routine Description:

    Handle notification from the spooler that a printer has been deleted.hanged.

Arguments:

    serverDeviceID      - Server-assigned device ID for printer being deleted.

Return Value:

    Return TRUE on success.  FALSE, otherwise.

--*/
{
    DWORD ofs;
    BOOL result;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:HandlePrinterDeleteNotification with server ID %ld.\n",
        serverDeviceID));

    //
    //  Return immediately if the DLL is trying to shut down.  This
    //  is to help prevent us from getting stuck in a system call.
    //
    if (ShutdownFlag) {
        return FALSE;
    }

    //
    //  If this is for one of our printers.
    //
    if (DRDEVLST_FindByServerDeviceID(DeviceList,
                                    serverDeviceID, &ofs)) {
        DBGMSG(DBG_TRACE, ("UMRDPPRN:****Printer %ws has been removed.****\n",
            DeviceList->devices[ofs].serverDeviceName));

        //
        //  Send a message to the client to let it know that a printer has been
        //  deleted.
        //
        result = SendDeletePrinterMsgToClient(
                            DeviceList->devices[ofs].clientDeviceName);

        //
        //  Clean up the notification object if one is registered.
        //
        if (DeviceList->devices[ofs].deviceSpecificData != NULL) {

            PPRINTNOTIFYREC notifyRec =
                (PPRINTNOTIFYREC)DeviceList->devices[ofs].deviceSpecificData;
            ASSERT(notifyRec->notificationObject != NULL);
            ASSERT(notifyRec->printerHandle != NULL);

            WTBLOBJ_RemoveWaitableObject(
                        UMRDPPRN_WaitableObjMgr,
                        notifyRec->notificationObject
                        );
            FindClosePrinterChangeNotification(
                        notifyRec->notificationObject
                        );

            ClosePrinter(notifyRec->printerHandle);
            FREEMEM(notifyRec);
            DeviceList->devices[ofs].deviceSpecificData = NULL;
        }

        //
        //  Remove it from the list of managed devices.
        //
        DRDEVLST_Remove(DeviceList, ofs);
    }
    else {
        result = TRUE;
    }
    return result;
}

BOOL
HandlePrinterNameChangeNotification(
    IN DWORD serverDeviceID,
    IN LPWSTR printerName
    )
/*++

Routine Description:

    Handle notification from the spooler that the name of a printer has changed.
    This allows us to track these significant events:

    -A printer automatically created by us has been assigned a device ID by the
     spooler.
    -A new printer has been manually added to the system and attached to one
     of our redirected ports.
    -A printer attached to one of our redirected ports has had its name changed.

Arguments:

    serverDeviceID      - Server-assigned device ID associated with the printer
                          name change.
    printerName         - New printer name.

Return Value:

    Return TRUE on success.  FALSE, otherwise.

--*/
{
    HANDLE hPrinter = NULL;
    BOOL result = TRUE;
    PRINTER_DEFAULTS defaults = {NULL, NULL, PRINTER_ALL_ACCESS};
    BOOL printerInList;
    BOOL isNewPrinter;
    DWORD ofs;
    BOOL printerNameExists;
    PWSTR portName;
    DWORD printerNameOfs;
    DWORD len;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:HandlePrinterNameChangeNotification printer %ws.\n",
            printerName));

    //
    //  Return immediately if the DLL is trying to shut down.  This
    //  is to help prevent us from getting stuck in a system call.
    //
    if (ShutdownFlag) {
        return FALSE;
    }

    //
    //  See if we already have a matching printer name.
    //
    printerNameExists =
        (DRDEVLST_FindByServerDeviceName(DeviceList, printerName,
                                        &printerNameOfs)
            && (DeviceList->devices[printerNameOfs].deviceType ==
                RDPDR_DTYP_PRINT));

    //
    //  If a printer automatically created by us has been assigned a
    //  device ID by the spooler.  In some cases, we may get a repeat
    //  printer name.  That is okay because the ID should be the same.
    //
    if (printerNameExists) {

        DBGMSG(DBG_TRACE,
            ("UMRDPPRN:****Printer %ws has had its ID assigned to  %ld.****\n",
            DeviceList->devices[printerNameOfs].serverDeviceName,
            serverDeviceID));
        DeviceList->devices[printerNameOfs].serverDeviceID = serverDeviceID;

        //
        //  Register a notification object with the printer, so we can
        //  be notified when its configuration changes.  This change notification
        //  is registered for events that are not picked up by the global
        //  change notification object.
        //
        result = RegisterPrinterConfigChangeNotification(
                                        serverDeviceID
                                        );
    }
    //
    //  If a printer attached to one of our redirected ports has had
    //  its name changed.
    //
    else if (DRDEVLST_FindByServerDeviceID(
                            DeviceList,
                            serverDeviceID, &ofs
                            )) {
        WCHAR *pBuf;

        DBGMSG(DBG_TRACE,
            ("UMRDPPRN:****Printer %ws has had its name changed to %ws.****\n",
            DeviceList->devices[ofs].serverDeviceName,
            printerName));

        //
        //  Reallocate the server name field.
        //
        len = wcslen(printerName) + 1;
        pBuf = REALLOCMEM(DeviceList->devices[ofs].serverDeviceName,
                        len * sizeof(WCHAR));
        if (pBuf != NULL) {
            DeviceList->devices[ofs].serverDeviceName = pBuf;
        } else {
            FREEMEM(DeviceList->devices[ofs].serverDeviceName);
            DeviceList->devices[ofs].serverDeviceName = NULL;
        }
            
        if (DeviceList->devices[ofs].serverDeviceName != NULL) {
            wcscpy(DeviceList->devices[ofs].serverDeviceName,
                    printerName);

            //
            // Send this information (printer name change) across to the client
            //
            DBGMSG(DBG_TRACE,("UMRDPPRN:clientDeviceID is %ld.\n",
                DeviceList->devices[ofs].clientDeviceID ));

            if (SendPrinterRenameToClient(
                        DeviceList->devices[ofs].clientDeviceName,
                        printerName
                        )) {

                //
                //  Update the client name
                //
                pBuf = REALLOCMEM(DeviceList->devices[ofs].clientDeviceName,
                    len * sizeof(WCHAR));
                if (pBuf != NULL) {
                    DeviceList->devices[ofs].clientDeviceName = pBuf;
                } else {
                    FREEMEM(DeviceList->devices[ofs].clientDeviceName);
                    DeviceList->devices[ofs].clientDeviceName = NULL;
                }
                    
                if (DeviceList->devices[ofs].clientDeviceName != NULL) {
                    wcscpy(DeviceList->devices[ofs].clientDeviceName,
                        printerName);
                }
            }

            result = TRUE;
        }
        else {
            DBGMSG(DBG_ERROR,("UMRDPPRN:Unable to allocate %ld bytes.\n",
                    len * sizeof(WCHAR)));

            TsLogError(EVENT_NOTIFY_INSUFFICIENTRESOURCES, EVENTLOG_ERROR_TYPE,
                        0, NULL, __LINE__);

            result = FALSE;
        }
    }
    else {

        //
        //  Return immediately if the DLL is trying to shut down.  This
        //  is to help prevent us from getting stuck in a system call.
        //
        if (ShutdownFlag) {
            result = FALSE;
        }

        //
        //  Open the printer to get the associated port name.
        //
        if (result) {
            result = OpenPrinter(printerName, &hPrinter, &defaults);
        }
        if (!result && !ShutdownFlag) {
            //
            //  If the error is a result of a non-existent printer, the printer has
            //  probably been renamed and is pending delete, so this is ok.
            //
            if (GetLastError() == ERROR_INVALID_PRINTER_NAME) {
                DBGMSG(DBG_WARN,
                            ("UMRDPDPRN:Error opening %ws in refresh. Error: %ld.  Probably ok.\n",
                            printerName, GetLastError()));
                result = TRUE;
            }
            else {
                DBGMSG(DBG_ERROR,
                            ("UMRDPDPRN:Error opening %ws in refresh. Error: %ld.\n",
                            printerName, GetLastError()));
            }
            goto CleanupAndExit;
        }

        //
        //  Get the port name for the printer.
        //
        if (result) {
            result = GetPrinterPortName(hPrinter, &portName);
            if (!result) {
                DBGMSG(DBG_ERROR,
                    ("UMRDPDPRN:GetPrinterPortName Failed. Error: %ld.\n",
                    GetLastError()));
            }
        }

        //
        //  If a new printer has been manually added to the system and
        //  attached to one of our redirected ports.
        //
        if (result) {
            if (DRDEVLST_FindByServerDeviceName(DeviceList, portName, &ofs) &&
                ISPRINTPORT(DeviceList->devices[ofs].deviceType)) {

                DBGMSG(DBG_TRACE,
                    ("UMRDPPRN:****New printer %ws manually attached to %ws.****\n",
                    printerName, portName));

                //
                //  Send the add printer message to the client.  We don't care about
                //  the return status, since we can't do anything to recover from
                //  a failure to send the message to the client.
                //
                SendAddPrinterMsgToClient(
                                printerName,
                                PrinterInfo2Buf->pDriverName,
                                DeviceList->devices[ofs].preferredDosName
                                );

                //
                //  Add the session number to the printer queue data to identify the printer
                //  as a TS printer.  Don't care about the return value here, because its
                //  failure for a manually installed printer is not a critical error.
                //
                AddSessionIDToPrinterQueue(hPrinter, GETTHESESSIONID());

                //
                //  Add the new printer to our list of managed printers.
                //
                result = DRDEVLST_Add(
                            DeviceList, RDPDR_INVALIDDEVICEID,
                            serverDeviceID,
                            RDPDR_DTYP_PRINT, printerName, printerName, "UNKNOWN"
                            );

                //
                //  Register a notification object with the printer, so we can
                //  be notified when its configuration changes.  This change notification
                //  is registered for events that are not picked up by the global
                //  change notification object.
                //
                if (result) {
                    RegisterPrinterConfigChangeNotification(
                                                serverDeviceID
                                                );
                }
            }
        }
    }

CleanupAndExit:
    //
    //  Close the printer.
    //
    if (hPrinter != NULL) {
        ClosePrinter(hPrinter);
    }
    return result;
}

BOOL
RegisterPrinterConfigChangeNotification(
    IN DWORD serverDeviceID
    )
/*++

Routine Description:

    Register a change notification event with the spooler so that we are
    notified when the configuration for a specific printer has been changed.

Arguments:

    serverDeviceID  -   Server-side ID for the device that is used to
                        track the device in the device list.

Return Value:

    TRUE on success.  Otherwise, FALSE is returned.

--*/
{
    DWORD offset;
    BOOL result;
    PRINTER_DEFAULTS printerDefaults;
    PPRINTNOTIFYREC notifyRec;

    DBGMSG(DBG_TRACE,
        ("UMRDPPRN:RegisterPrinterConfigChangeNotification id %ld.\n",
        serverDeviceID)
        );

    //
    //  Find the printer in the device list.
    //
    result = DRDEVLST_FindByServerDeviceID(
                    DeviceList, serverDeviceID, &offset
                    );

    //
    //  Register a notification object with the printer, so we can
    //  be notified when its configuration changes.  This change notification
    //  is registered for events that are not picked up by the global
    //  change notification object.
    //
    if (result && (DeviceList->devices[offset].deviceSpecificData == NULL)) {
        LPWSTR name = DeviceList->devices[offset].serverDeviceName;

        printerDefaults.pDatatype     = NULL;
        printerDefaults.pDevMode      = NULL;
        printerDefaults.DesiredAccess = PRINTER_ALL_ACCESS;

        //
        //  Allocate a new notification record.
        //
        notifyRec = ALLOCMEM(sizeof(PRINTNOTIFYREC));
        result = (notifyRec != NULL);
        if (result) {
            notifyRec->printerHandle = NULL;
            notifyRec->notificationObject = NULL;
            notifyRec->serverDeviceID = serverDeviceID;
            result = OpenPrinter(name, &notifyRec->printerHandle,
                                &printerDefaults);
        }

        //
        //  Register the notification.
        //
        if (result) {
            notifyRec->notificationObject =
                FindFirstPrinterChangeNotification(
                                    notifyRec->printerHandle,
                                    PRINTER_CHANGE_PRINTER_DRIVER |
                                    PRINTER_CHANGE_DELETE_PRINTER, 0,
                                    NULL
                                    );
            if (notifyRec->notificationObject != NULL) {
                result =
                    WTBLOBJ_AddWaitableObject(
                            UMRDPPRN_WaitableObjMgr,
                            notifyRec,
                            notifyRec->notificationObject,
                            SinglePrinterNotifyObjectSignaled
                            ) == ERROR_SUCCESS;
            }
            else {
                DBGMSG(
                    DBG_ERROR,
                    ("UMRDPPRN:FindFirstPrinterChangeNotification failed for %ws:  %ld.\n",
                    name, GetLastError())
                    );
                result = FALSE;
            }
        }
        else {
            DBGMSG(DBG_ERROR, ("UMRDPPRN:  Can't open printer %ws:  %ld.\n",
                    name, GetLastError()));
        }

        //
        //  Record the notification record or clean up.
        //
        if (result) {
            DeviceList->devices[offset].deviceSpecificData = notifyRec;
        }
        else if (notifyRec != NULL) {
            if (notifyRec->notificationObject != NULL) {
                WTBLOBJ_RemoveWaitableObject(
                            UMRDPPRN_WaitableObjMgr,
                            notifyRec->notificationObject
                            );
                FindClosePrinterChangeNotification(
                        notifyRec->notificationObject
                        );
            }

            if (notifyRec->printerHandle != NULL) {
                ClosePrinter(notifyRec->printerHandle);
            }

            FREEMEM(notifyRec);
        }
    }
    DBGMSG(DBG_TRACE, ("UMRDPPRN:RegisterPrinterConfigChangeNotification done.\n"));

    return result;
}

BOOL
SendAddPrinterMsgToClient(
    IN PCWSTR   printerName,
    IN PCWSTR   driverName,
    IN PCSTR    dosDevicePort
    )
/*++

Routine Description:

    Send an add printer message to the client.

Arguments:

    printerName -   Name of new printer.
    driverName  -   Name of printer driver.
    portName    -   Client-side dos device port name.


Return Value:

    Return TRUE on success.  FALSE, otherwise.

--*/
{
    PRDPDR_PRINTER_CACHEDATA_PACKET cachedDataPacket;
    DWORD cachedDataPacketSize;
    PRDPDR_PRINTER_ADD_CACHEDATA cachedData;
    BOOL result;
    DWORD driverSz, printerSz;
    PWSTR str;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:SendAddPrinterMsgToClient.\n"));
    DBGMSG(DBG_TRACE, ("UMRDPPRN:SendAddPrinterMsgToClient printer name is %ws.\n",
            printerName));
    DBGMSG(DBG_TRACE, ("UMRDPPRN:SendAddPrinterMsgToClient driver name is %ws.\n",
            driverName));
    DBGMSG(DBG_TRACE, ("UMRDPPRN:SendAddPrinterMsgToClient dos device port is %s.\n",
            dosDevicePort));

    //
    //  Calculate the message size.
    //
    driverSz  = ((wcslen(driverName) + 1) * sizeof(WCHAR));
    printerSz = ((wcslen(printerName) + 1) * sizeof(WCHAR));
    cachedDataPacketSize =  sizeof(RDPDR_PRINTER_CACHEDATA_PACKET) +
                            sizeof(RDPDR_PRINTER_ADD_CACHEDATA) +
                            driverSz + printerSz;

    //
    //  Allocate the message.
    //
    cachedDataPacket = (PRDPDR_PRINTER_CACHEDATA_PACKET)ALLOCMEM(
                                                    cachedDataPacketSize
                                                    );
    result = (cachedDataPacket != NULL);

    if (result) {
        //
        //  Set up the packet.
        //
        cachedDataPacket->Header.PacketId = DR_PRN_CACHE_DATA;
        cachedDataPacket->Header.Component = RDPDR_CTYP_PRN;
        cachedDataPacket->EventId = RDPDR_ADD_PRINTER_EVENT;

        //
        //  Set up the cached data.
        //
        cachedData = (PRDPDR_PRINTER_ADD_CACHEDATA)(
                            (PBYTE)cachedDataPacket +
                            sizeof(RDPDR_PRINTER_CACHEDATA_PACKET)
                            );
        strcpy(cachedData->PortDosName, dosDevicePort);
        cachedData->PnPNameLen = 0;
        cachedData->DriverLen = driverSz;
        cachedData->PrinterNameLen = printerSz;
        cachedData->CachedFieldsLen = 0;

        //
        //  Add the driver name.
        //
        str = (PWSTR)((PBYTE)cachedData + sizeof(RDPDR_PRINTER_ADD_CACHEDATA));
        wcscpy(str, driverName);

        //
        //  Add the printer name.
        //
        str = str + driverSz/2;
        wcscpy(str, printerName);

        //
        //  Send the message to the client.
        //
        result = UMRDPDR_SendMessageToClient(
                                    cachedDataPacket,
                                    cachedDataPacketSize
                                    );

        // Release the buffer.
        FREEMEM(cachedDataPacket);
    }

    return result;
}

BOOL
SendDeletePrinterMsgToClient(
    IN PCWSTR   printerName
    )
/*++

Routine Description:

    Send a delete printer message to the client.

Arguments:

    printerName -   Client-recognized name of printer to delete.


Return Value:

    Return TRUE on success.  FALSE, otherwise.

--*/
{
    PRDPDR_PRINTER_CACHEDATA_PACKET cachedDataPacket;
    DWORD cachedDataPacketSize;
    PRDPDR_PRINTER_DELETE_CACHEDATA cachedData;
    BOOL result;
    DWORD printerSz;
    PWSTR str;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:SendDeletePrinterMsgToClient printer name is %ws.\n",
            printerName));

    //
    //  Calculate the message size.
    //
    printerSz = ((wcslen(printerName) + 1) * sizeof(WCHAR));
    cachedDataPacketSize =  sizeof(RDPDR_PRINTER_CACHEDATA_PACKET) +
                            sizeof(RDPDR_PRINTER_DELETE_CACHEDATA) +
                            printerSz;

    //
    //  Allocate the message.
    //
    cachedDataPacket = (PRDPDR_PRINTER_CACHEDATA_PACKET)ALLOCMEM(
                                                    cachedDataPacketSize
                                                    );
    result = (cachedDataPacket != NULL);
    if (result) {
        //
        //  Set up the packet.
        //
        cachedDataPacket->Header.PacketId = DR_PRN_CACHE_DATA;
        cachedDataPacket->Header.Component = RDPDR_CTYP_PRN;
        cachedDataPacket->EventId = RDPDR_DELETE_PRINTER_EVENT;

        //
        //  Set up the cached data.
        //
        cachedData = (PRDPDR_PRINTER_DELETE_CACHEDATA)(
                            (PBYTE)cachedDataPacket +
                            sizeof(RDPDR_PRINTER_CACHEDATA_PACKET)
                            );
        cachedData->PrinterNameLen = printerSz;

        //
        //  Add the printer name.
        //
        str = (PWSTR)((PBYTE)cachedData + sizeof(RDPDR_PRINTER_DELETE_CACHEDATA));
        wcscpy(str, printerName);

        //
        //  Send the message to the client.
        //
        result = UMRDPDR_SendMessageToClient(
                                    cachedDataPacket,
                                    cachedDataPacketSize
                                    );

        // Release the buffer.
        FREEMEM(cachedDataPacket);
    }

    return result;
}

BOOL
RegisterSerialPort(
    IN PCWSTR portName,
    IN PCWSTR devicePath
    )
/*++

Routine Description:

    Register a serial port device by creating the symbolic link

Arguments:

    portName -     Port name for the serial device
    devicePath -   NT device path for the symbolic link

Return Value:

    Return TRUE on success.  FALSE, otherwise.

--*/

{
    DWORD SymLinkNameLen;
    size_t RemainingCharCount;
    PWSTR pNtSymLinkName, buffer;
    UNICODE_STRING SymLinkName, SymLinkValue;
    HANDLE SymLinkHandle;
    OBJECT_ATTRIBUTES ObjectAttributes;
    NTSTATUS Status;
    ULONG dwErrorCode, LUIDDeviceMapsEnabled;
    BOOL  fImpersonated = FALSE, fLUIDDeviceMapsEnabled;
    BOOL  result = TRUE;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:RegisterSerialPort with port %ws.\n", portName));
    DBGMSG(DBG_TRACE, 
           ("UMRDPPRN:RegisterSerialPort with device path %ws.\n", devicePath));

    buffer = NULL;

    //
    // Check if LUID DosDevices maps are enabled
    //
    Status = NtQueryInformationProcess( NtCurrentProcess(),
                                        ProcessLUIDDeviceMapsEnabled,
                                        &LUIDDeviceMapsEnabled,
                                        sizeof(LUIDDeviceMapsEnabled),
                                        NULL
                                      );

    if (NT_SUCCESS(Status)) {
        fLUIDDeviceMapsEnabled = (LUIDDeviceMapsEnabled != 0);
    }
    else {
        fLUIDDeviceMapsEnabled = FALSE;
    }

    //
    // If LUID Device Maps are enabled,
    // We need to impersonate the logged on user in order to create
    // the symbolic links in the correct device map
    // If LUID Device Maps are disabled,
    // we should not impersonate the logged on user in order to delete
    // any existing symbolic links
    //
    if (fLUIDDeviceMapsEnabled == TRUE) {
        fImpersonated = ImpersonateLoggedOnUser(UMRPDPPRN_TokenForLoggedOnUser);

        if (!fImpersonated) {
            DBGMSG(DBG_ERROR,
                ("UMRDPPRN:Error impersonate user in function RegisterSerialPort. Error: %ld\n",
                GetLastError()));
            return FALSE;
        }
    }
    
    // length of ( portName ) + Length of("\\??\\") + UNICODE NULL
    RemainingCharCount = wcslen(portName) + DEVICE_MAP_NAME_COUNT + 1;

    SymLinkNameLen = RemainingCharCount * sizeof( WCHAR );

    pNtSymLinkName = (PWSTR) ALLOCMEM( SymLinkNameLen );

    if (pNtSymLinkName == NULL) {
        DBGMSG(DBG_ERROR,
            ("UMRDPPRN:Error allocating memory in function RegisterSerialPort. Error: %ld\n",
            GetLastError()));
        return( FALSE );
    }

    //
    // Copy \??\ to the symbolic link name
    //
    wcsncpy( pNtSymLinkName, DEVICE_MAP_NAME, RemainingCharCount );

    RemainingCharCount = RemainingCharCount - DEVICE_MAP_NAME_COUNT;

    //
    // Append the portname to the symbolic link name
    //
    wcsncat( pNtSymLinkName, portName, RemainingCharCount );

    RtlInitUnicodeString(&SymLinkName, (PCWSTR)pNtSymLinkName);

    RtlInitUnicodeString(&SymLinkValue, devicePath);

    InitializeObjectAttributes( &ObjectAttributes,
                                &SymLinkName,
                                OBJ_CASE_INSENSITIVE,
                                NULL,
                                NULL );

    Status = NtCreateSymbolicLinkObject( &SymLinkHandle,
                                         SYMBOLIC_LINK_ALL_ACCESS,
                                         &ObjectAttributes,
                                         &SymLinkValue
                                       );

    //
    // If LUID device maps are disabled, then CsrPopulateDosDevices() would
    // have copied the global symbolic link into this TS device map, which
    // would cause the create to fail, so we need to delete the copy before
    // creating our symbolic link
    //
    if (Status == STATUS_OBJECT_NAME_COLLISION) {
        Status = NtOpenSymbolicLinkObject( &SymLinkHandle,
                                           SYMBOLIC_LINK_QUERY | DELETE,
                                           &ObjectAttributes
                                         );

        if (NT_SUCCESS ( Status)) {
            UNICODE_STRING SymLinkString;
            unsigned SymLinkValueLen, ReturnedLength, bufLen;

            SymLinkValueLen = wcslen(devicePath);

            // Find how much buffer is required for the symlink value
            SymLinkString.Buffer = NULL;
            SymLinkString.Length = 0;
            SymLinkString.MaximumLength = 0;
            ReturnedLength = 0;
            Status = NtQuerySymbolicLinkObject( SymLinkHandle,
                                                &SymLinkString,
                                                &ReturnedLength
                                               );

            if (Status != STATUS_BUFFER_TOO_SMALL) {
                ReturnedLength = 0;
            }

            bufLen = SymLinkValueLen * sizeof(WCHAR) + sizeof(UNICODE_NULL) * 2 + ReturnedLength;
            buffer = (PWSTR) ALLOCMEM( bufLen );

            if (buffer == NULL) {
                NtClose(SymLinkHandle);
                DBGMSG(DBG_ERROR,
                        ("UMRDPPRN:Error allocating memory in function RegisterSerialPort. Error: %ld\n",
                        GetLastError()));
                return( FALSE );
            }

            // Setup the devicepath as the first entry
            wcscpy(buffer, devicePath);
            buffer[SymLinkValueLen] = UNICODE_NULL;

            if (ReturnedLength > 0) {
                // Get the existing symlink
                SymLinkString.Buffer = buffer + SymLinkValueLen + 1;
                SymLinkString.Buffer[0] = UNICODE_NULL;
                SymLinkString.MaximumLength = (USHORT)(bufLen - (SymLinkValueLen + 1) * sizeof(WCHAR));
                SymLinkString.Length = 0;
                ReturnedLength = 0;
    
                Status = NtQuerySymbolicLinkObject( SymLinkHandle,
                                                    &SymLinkString,
                                                    &ReturnedLength
                                                   );

                if (Status == STATUS_SUCCESS) {
                    if (ReturnedLength > 2 && (SymLinkString.Buffer[ReturnedLength/sizeof(WCHAR) - 2] != UNICODE_NULL) ) {
                        // Make sure we always end with an UNICODE_NULL
                        SymLinkString.Buffer[ReturnedLength/sizeof(WCHAR)] = UNICODE_NULL;                                                        
                        ReturnedLength += sizeof(UNICODE_NULL);
                    }
                }
                else {
                    ReturnedLength = 0;
                }
            }
            
            // Setup the symlink string
            SymLinkString.Buffer = buffer;
            SymLinkString.Length = (USHORT)(SymLinkValueLen * sizeof(WCHAR));
            SymLinkString.MaximumLength = (USHORT)((SymLinkValueLen + 1) * sizeof(WCHAR) + ReturnedLength);

            Status = NtMakeTemporaryObject( SymLinkHandle );
            NtClose( SymLinkHandle );
            SymLinkHandle = NULL;

            if (NT_SUCCESS ( Status)) {

                Status = NtCreateSymbolicLinkObject( &SymLinkHandle,
                                                     SYMBOLIC_LINK_ALL_ACCESS,
                                                     &ObjectAttributes,
                                                     &SymLinkString
                                                   );
            }            
        }
    }

    // Revert the thread token to self
    if (fImpersonated) {
        RevertToSelf();
    }

    //
    // After the revert to Local System
    //
    if (NT_SUCCESS(Status)) {
        Status = NtMakePermanentObject( SymLinkHandle );   // must be Local System
        NtClose ( SymLinkHandle );
    }

    if (NT_SUCCESS(Status)) {
        result = TRUE;
        DBGMSG(DBG_TRACE, ("UMRDPPRN:RegisterSerialPort with port %ws succeeded.\n", portName));
    }
    else {
        dwErrorCode = RtlNtStatusToDosError( Status );
        SetLastError( dwErrorCode );

        result = FALSE;
        DBGMSG(DBG_ERROR, ("UMRDPPRN:RegisterSerialPort with port %ws failed: %x.\n",
                           portName, GetLastError()));
    }


    //
    // Cleanup the memory that we allocated
    //
    if (pNtSymLinkName != NULL) {
        FREEMEM(pNtSymLinkName);
    }

    if (buffer != NULL) {
        FREEMEM(buffer);
    }
    return result;
}

BOOL
UMRDPPRN_HandlePrintPortAnnounceEvent(
    IN PRDPDR_PORTDEVICE_SUB pPortAnnounce
    )
/*++

Routine Description:

    Handle a printer port device announce event from the "dr" by
    adding a record for the device to the list of installed devices.

Arguments:

    pPortAnnounce -     Port device announce event.

Return Value:

    Return TRUE on success.  FALSE, otherwise.

--*/
{

    DBGMSG(DBG_TRACE, ("UMRDPPRN:UMRDPPRN_HandlePrintPortAnnounceEvent with port %ws.\n",
                        pPortAnnounce->portName));
    DBGMSG(DBG_TRACE, ("UMRDPPDRN:Preferred DOS name is %s.\n",
                        pPortAnnounce->deviceFields.PreferredDosName));

    ASSERT( ISPRINTPORT(pPortAnnounce->deviceFields.DeviceType) );

    if (pPortAnnounce->deviceFields.DeviceType == RDPDR_DTYP_SERIAL ||
            pPortAnnounce->deviceFields.DeviceType == RDPDR_DTYP_PARALLEL) {

        WCHAR serverDevicePath[MAX_PATH];

        // Query the original symbolic link for the serial port and save it for restore
        // later
        serverDevicePath[0] = L'\0';
        if (QueryDosDevice(pPortAnnounce->portName, serverDevicePath, MAX_PATH) != 0) {
            DBGMSG(DBG_TRACE, ("UMRDPPRN:QueryDosDevice on port: %ws, returns path: %ws.\n",
                               pPortAnnounce->portName, serverDevicePath));
        }
        else {
            DBGMSG(DBG_ERROR, ("UMRDPPRN:QueryDosDevice on port: %ws returns error: %x.\n",
                               pPortAnnounce->portName, GetLastError()));
        }

        // Register the new symbolic link name
        RegisterSerialPort(pPortAnnounce->portName, pPortAnnounce->devicePath);

        // Just record the port so we can remember it for later.
        // We save the new serial symbolic link name in client device name and
        // the original symbolic link in server device name
        return DRDEVLST_Add(
                DeviceList,
                pPortAnnounce->deviceFields.DeviceId,
                UMRDPDR_INVALIDSERVERDEVICEID,
                pPortAnnounce->deviceFields.DeviceType,
                serverDevicePath,
                pPortAnnounce->devicePath,
                pPortAnnounce->deviceFields.PreferredDosName
                );
    }
    else {
        if (!PrintingModuleInitialized) {
            return FALSE;
        }

        // Just record the port so we can remember it for later.
        return DRDEVLST_Add(
                DeviceList,
                pPortAnnounce->deviceFields.DeviceId,
                UMRDPDR_INVALIDSERVERDEVICEID,
                pPortAnnounce->deviceFields.DeviceType,
                pPortAnnounce->portName,
                pPortAnnounce->portName,
                pPortAnnounce->deviceFields.PreferredDosName
                );

    }
}

BOOL
UMRDPPRN_DeleteSerialLink(
    UCHAR *preferredDosName,
    WCHAR *ServerDeviceName,
    WCHAR *ClientDeviceName
    )
/*++

Routine Description:

    Delete the new symbolic link on disconnect/logoff and restore the old one
    as necessary

Arguments:

    preferredDosName - the port name in ANSI char
    ServerDeviceName - the original serial link symbolic path
    ClientDeviceName - the new serial link symbolic path

Return Value:

    Return TRUE on success.  FALSE, otherwise.

--*/
{
    ULONG LUIDDeviceMapsEnabled;
    BOOL fImpersonated = FALSE, fLUIDDeviceMapsEnabled;
    WCHAR PortNameBuff[PREFERRED_DOS_NAME_SIZE];
    NTSTATUS Status;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:UMRDPPRN_DeleteSerialLink\n"));

    // Assemble the port name from preferred dos name
    PortNameBuff[0] = L'\0';
    MultiByteToWideChar(CP_ACP, 0, preferredDosName, -1, PortNameBuff, PREFERRED_DOS_NAME_SIZE);

    //
    // Check if LUID DosDevices maps are enabled
    //
    Status = NtQueryInformationProcess( NtCurrentProcess(),
                                        ProcessLUIDDeviceMapsEnabled,
                                        &LUIDDeviceMapsEnabled,
                                        sizeof(LUIDDeviceMapsEnabled),
                                        NULL
                                      );

    if (NT_SUCCESS(Status)) {
        fLUIDDeviceMapsEnabled = (LUIDDeviceMapsEnabled != 0);
    }
    else {
        fLUIDDeviceMapsEnabled = FALSE;
    }

    //
    // If LUID Device Maps are enabled,
    // We need to impersonate the logged on user in order to delete
    // the symbolic links from the correct device map
    // If LUID Device Maps are disabled,
    // we should not impersonate the logged on user in order to delete
    // any existing symbolic links
    //
    if (fLUIDDeviceMapsEnabled == TRUE) {
        fImpersonated = ImpersonateLoggedOnUser(UMRPDPPRN_TokenForLoggedOnUser);

        if (!fImpersonated) {
            DBGMSG(DBG_ERROR,
                ("UMRDPPRN:Error impersonate user in function UMRDPPRN_DeleteSerialLink. Error: %ld\n",
                GetLastError()));
            return FALSE;
        }
    }

    if (PortNameBuff[0] != L'\0') {
        // Just need to delete the new symbolic link for this session
        if (DefineDosDevice(DDD_RAW_TARGET_PATH | DDD_REMOVE_DEFINITION | DDD_EXACT_MATCH_ON_REMOVE,
                PortNameBuff,
                ClientDeviceName) != 0) {
            DBGMSG(DBG_TRACE, ("UMRDPPRN:Delete port %ws with link %ws succeeded.\n",
                                PortNameBuff, ClientDeviceName));
        }
        else {
            DBGMSG(DBG_ERROR, ("UMRDPPRN:Delete port: %ws with link %ws failed: %x\n",
                               PortNameBuff, ClientDeviceName, GetLastError()));
        }        
    }
    else {
        DBGMSG(DBG_ERROR, ("UMRDPPRN:UMRDPPRN_DeleteSerialLink failed to get the port name\n"));
    }

    // Delete the serial registry entry if on PTS box
    
    if (fRunningOnPTS) {
        DWORD rc;
        HKEY regKey;
        
        rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE, TSSERIALDEVICEMAP, 0,
                KEY_ALL_ACCESS, &regKey);
        if (rc == ERROR_SUCCESS) {
            RegDeleteValue(regKey, PortNameBuff);
            RegCloseKey(regKey);
        }
    }

    // Revert the thread token to self
    if (fImpersonated) {
        RevertToSelf();
    }

    return TRUE;
}

WCHAR *ANSIToUnicode(
    IN LPCSTR   ansiString,
    IN UINT     codePage
    )
/*++

Routine Description:

  Convert an ANSI string to Unicode.

Arguments:


Return Value:

    Returns the converted string or NULL on error..  It is up to the caller to
    release this string.

--*/

{
    int numChars;
    PWSTR buf=NULL;

    //
    //  Convert the driver name.
    //
    // First, get the required buffer size.
    numChars = MultiByteToWideChar(
                    codePage, 0, ansiString,
                    -1, NULL, 0
                    );

    // Allocate the buffer.
    buf = (PWSTR)ALLOCMEM((numChars + 1) * sizeof(WCHAR));
    if (buf != NULL) {
        buf[0] = L'\0';
        numChars = MultiByteToWideChar(
                                codePage, 0, ansiString,
                                -1, buf, numChars
                                );
        // Find out if the conversion succeeded.

        if ((numChars != 0) || !ansiString[0]) {
            return buf;
        }
        else {
            DBGMSG(DBG_ERROR,
                ("UMRDPPRN:Error converting to Unicode. Error: %ld\n",
                GetLastError()));
            FREEMEM(buf);
            return NULL;
        }
    }
    else {
        DBGMSG(DBG_ERROR,
            ("UMRDPPRN:Error allocating memory in function AnsiToUNICODE. Error: %ld\n",
            GetLastError()));
        return NULL;
    }
}

DWORD
InstallPrinter(
    IN PCWSTR portName,
    IN PCWSTR driverName,
    IN PWSTR printerNameBuf,
    IN DWORD cchPrintNameBuf,
    IN BOOL cachedDataExists,
    OUT BOOL *triggerConfigChangeEvent
    )
/*++


--*/
{
    INT_PTR status = ERROR_SUCCESS; // PnpInterfaceFunc() returns INT_PTR
    TAdvInfInstall tii;
    TParameterBlock tpb;
    PSECURITY_DESCRIPTOR psd;
    PSID pSid = NULL;
    BOOL  daclPresent;
    PACL dacl;
    BOOL daclDefaulted;

    DBGMSG(DBG_WARN,
            ("UMRDPPRN:InstallPrinter portName %ws, driverName %ws, printerName %ws\n",
            portName, driverName, printerNameBuf));

    *triggerConfigChangeEvent = FALSE;

    //
    //  Get the user sid.
    //
    if ((pSid = TSNUTL_GetUserSid(UMRPDPPRN_TokenForLoggedOnUser)) == NULL) {
        status = GetLastError();
        DBGMSG(DBG_ERROR, ("UMRDPPRN: Failed to get user SID:  %ld\n",
                status));
        goto CLEANUPANDEXIT;
    }

    //
    //  Get the default printer security descriptor.
    //
    psd = RDPDRUTL_CreateDefaultPrinterSecuritySD(pSid);
    if (psd == NULL) {
        status = GetLastError();
        goto CLEANUPANDEXIT;
    }

    tii.cbSize = sizeof(tii);
    tii.pszModelName = driverName;              
    tii.pszServerName = NULL;                   
    tii.pszInfName = PrinterInfPath;
    tii.pszPortName = portName;
    tii.pszPrinterNameBuffer = printerNameBuf;
    tii.cchPrinterName = cchPrintNameBuf;
    tii.pszSourcePath = NULL;
    tii.dwFlags = kPnPInterface_Quiet |
                    kPnPInterface_NoShare |
                    kPnpInterface_UseExisting |
                    kPnpInterface_HydraSpecific;
    tii.dwAttributes = PRINTER_ATTRIBUTE_TS;
    tii.pSecurityDescriptor = psd;


    //
    //  If cached data does not exist, then OR in the flag that
    //  enables printui to set a default ICM color profile, for 
    //  color printers.  Note that there is no additional overhead
    //  for non-color printers.
    //
    if (!cachedDataExists) {
        tii.dwFlags |= kPnPInterface_InstallColorProfiles;
    }

    memset(&tpb, 0, sizeof(tpb));
    tpb.pAdvInfInstall = &tii;

    status = PnpInterfaceFunc(kAdvInfInstall, &tpb);

    //
    //  The configuration info needs to be cached on the client if
    //  the printer is color and we didn't have any cached data to begin 
    //  with.  This is a performance optimization so we don't need to 
    //  create a color profile for the remote printer each time we log in.
    //
    if (status == ERROR_SUCCESS) {
        *triggerConfigChangeEvent = !cachedDataExists && 
                                    (tii.dwOutFlags & kAdvInf_ColorPrinter); 
    }

    //
    //  Release the Security Descriptor.
    //
    LocalFree(psd);

CLEANUPANDEXIT:

    if (pSid != NULL) FREEMEM(pSid);

    DBGMSG(DBG_WARN,("UMRDPPRN:InstallPrinter returns %ld\n", status));

    return (DWORD)status;
}

VOID
TriggerConfigChangeTimer()
/*++

Routine Description:
    
    Set the config change timer callback to fire 1 time.       

Arguments:

Return Value:

--*/
{
    LARGE_INTEGER li;

    if (g_fTimerSet == FALSE) {
        
        li.QuadPart = Int32x32To64(CONFIG_WAIT_PERIOD, -10000);      // 30 seconds (in nano second units)
        if (SetWaitableTimer(WaitableTimer,
                                &li,
                                0,
                                NULL,
                                NULL,
                                FALSE)) {
            g_fTimerSet = TRUE;
        }
        else {
            DBGMSG(DBG_TRACE, ("UMRDPPRN:SetWaitableTimer Failed. Error: %ld.\n", GetLastError()));
        }
    }
}


BOOL
InstallPrinterWithPortName(
    IN DWORD  deviceID,
    IN HANDLE hTokenForLoggedOnUser,
    IN BOOL   bSetDefault,
    IN ULONG  ulFlags,
    IN PCWSTR portName,
    IN PCWSTR driverName,
    IN PCWSTR printerName,
    IN PCWSTR clientComputerName,
    IN PBYTE  cacheData,
    IN DWORD  cacheDataLen
    )
/*++

Routine Description:

  Install the printing device.

Arguments:

    deviceID -          Device identifier assigned by kernel mode component and client.
    hTokenForLoggedOnUser - Logged on user token.
    portName    -       Name of printer port.
    driverName  -       Printer driver name. (eg. AGFA-AccuSet v52.3)
    printerName -       Printer name.  This function appends "/Session X/Computer Name"
    clientComputerName -        Name of client computer.

Return Value:

    Return TRUE on success.  FALSE, otherwise.

--*/
{
    WCHAR   printerNameBuf[MAX_PATH+1];
    size_t  printerNameLen;
    DWORD status = ERROR_SUCCESS;
    WCHAR   errorBuf[256];
    HANDLE  hPrinter;
    TS_PRINTER_NAMES printerNames;
    PRINTER_DEFAULTS defaults = {NULL, NULL, PRINTER_ALL_ACCESS};
    BOOL    queueCreated = FALSE;
    DWORD   requiredSize;
    BOOL    clientDriverMapped;
    WCHAR  *parms[2];
    BOOL    triggerConfigChangeEvent;
    DWORD   ofs;
    BOOL printerNameExists;

#if DBG
    DWORD i;
#endif

    DBGMSG(DBG_TRACE, ("UMRDPPRN:InstallPrinterWithPortName.\n"));

    DBGMSG(DBG_TRACE, ("UMRDPPRN:Port name is %ws driver name is %ws\n", portName, driverName));

#ifndef UNICODE
    ASSERT(0);
#endif

    //
    // format printer name
    //
    printerNames.ulTempLen = sizeof(printerNames.szTemp)/sizeof(printerNames.szTemp[0]);
    printerNames.pszFullName = printerName;
    printerNames.pszCurrentClient = clientComputerName;
    printerNames.pszServer = NULL;
    printerNames.pszClient = NULL;
    printerNames.pszPrinter = NULL;

    FormatPrinterName(printerNameBuf,
                      sizeof(printerNameBuf)/sizeof(printerNameBuf[0]),
                      ulFlags,
                      &printerNames);

    printerNameLen = wcslen(printerNameBuf);

    //
    //  Delete the printer if it already exists.
    //
    if (OpenPrinter(printerNameBuf, &hPrinter, &defaults)) {

        DBGMSG(DBG_WARN,
            ("UMRDPPRN:Deleting existing printer %ws in InstallPrinterWithPortName!\n",
             printerNameBuf));

        if (!SetPrinter(hPrinter, 0, NULL, PRINTER_CONTROL_PURGE) ||
            !DeletePrinter(hPrinter)) {

            DBGMSG(DBG_ERROR,
                ("UMRDPPRN:Error deleting existing printer %ws:  %08X!\n",
                 printerNameBuf,GetLastError()));

            ClosePrinter(hPrinter);
            return FALSE;
        }
        else {
            ClosePrinter(hPrinter);
            hPrinter = INVALID_HANDLE_VALUE;
        }
    }
    else {
        hPrinter = INVALID_HANDLE_VALUE;
    }

    //
    //  Return immediately if the DLL is trying to shut down.  This
    //  is to help prevent us from getting stuck in a system call.
    //
    if (ShutdownFlag) {
        status = ERROR_SHUTDOWN_IN_PROGRESS;
        goto Cleanup;
    }

    //
    // We want to check if driver already install first because
    // if we simply dump installation of a nt4 or win9x driver
    // to print UI, it will takes a long time for it to find out
    // that driver does not exist, on other case, if a OEM driver
    // already install, we also want to use it.
    //

    //
    // MapClientPrintDriverName() will try out with upgrade infs file
    // first, so if NT4/Win9x driver (not in ntprintf.inf), we will
    // pick up mapping first.
    //
    status = PrinterDriverInstalled( driverName );

    if( ERROR_SHUTDOWN_IN_PROGRESS == status ) {
        goto Cleanup;
    }

    if( ERROR_SUCCESS == status ) {

        //
        // Driver already install.  Try installing the printer.  If this fails,
        // driver must be blocked.
        //
        status = InstallPrinter(
                        portName,
                        driverName,
                        printerNameBuf,
                        sizeof(printerNameBuf) / sizeof(printerNameBuf[0]),
                        cacheDataLen > 0,
                        &triggerConfigChangeEvent
                        );

        if( ERROR_SUCCESS == status ) {
            queueCreated = TRUE;
        }

        if( ShutdownFlag ) {
            // overwrite last error since we are shutting down
            status = ERROR_SHUTDOWN_IN_PROGRESS;
            goto Cleanup;
        }
    }

    if( ERROR_SUCCESS != status ) {

        //
        // Driver not installed or failed to installed printer with
        // driver already exist on system, go thru mapping process
        //
        clientDriverMapped = MapClientPrintDriverName(
                                                driverName,
                                                &MappedDriverNameBuf,
                                                &MappedDriverNameBufSize
                                            );

        status = InstallPrinter(
                        portName,
                        (clientDriverMapped) ? MappedDriverNameBuf : driverName,
                        printerNameBuf,
                        sizeof(printerNameBuf) / sizeof(printerNameBuf[0]),
                        cacheDataLen > 0,
                        &triggerConfigChangeEvent
                    );

        if( ERROR_SUCCESS == status ) {
            queueCreated = TRUE;
        }
    }

    if( ShutdownFlag ) {
        // overwrite last error since we are shutting down
        status = ERROR_SHUTDOWN_IN_PROGRESS;
        goto Cleanup;
    }

    //
    // Log an error message if the driver wasn't found
    //
    if (!queueCreated) {
        ASSERT( status != ERROR_SUCCESS );
        if ((status == ERROR_FILE_NOT_FOUND) || (status == ERROR_PATH_NOT_FOUND)) {
            ASSERT((sizeof(parms)/sizeof(WCHAR *)) >= 2);
            parms[0] = (WCHAR *)driverName;
            parms[1] = (WCHAR *)printerName;
            TsLogError(EVENT_NOTIFY_DRIVER_NOT_FOUND, EVENTLOG_ERROR_TYPE, 2,
                        parms, __LINE__);
        }
        else if (status == ERROR_UNKNOWN_PRINTER_DRIVER) {
            ASSERT((sizeof(parms)/sizeof(WCHAR *)) >= 2);
            parms[0] = (WCHAR *)driverName;
            parms[1] = (WCHAR *)printerName;
            TsLogError(EVENT_NOTIFY_UNKNOWN_PRINTER_DRIVER, EVENTLOG_ERROR_TYPE, 2,
                        parms, __LINE__);
        }
        DBGMSG(DBG_TRACE, ("UMRDPPRN:Printui func failed with status %08x.\n", status));
    }

    //
    //  Set the new printer as the default printer, after saving the
    //  current printer context, if so configured.
    //
    if (ERROR_SUCCESS == status && UMRDPDR_fSetClientPrinterDefault() && bSetDefault) {

        DWORD statusSave = ERROR_SUCCESS;
        BOOL fImpersonated = FALSE;
        SaveDefaultPrinterContext(printerNameBuf);

        //
        //impersonate before setting the default printer as the api
        //accesses hkcu. If the impersonation fails, the api will fail
        //and we will log an error. But, before logging an error, we will
        //need to revert to self.
        //
        if (!(fImpersonated = ImpersonateLoggedOnUser(hTokenForLoggedOnUser))) {
            DBGMSG(DBG_TRACE, ("UMRDPDR:ImpersonateLoggedOnUser failed. Error:%ld.\n", GetLastError()));
        }

        if (!SetDefaultPrinter(printerNameBuf)) {
            statusSave = GetLastError();
        }

        //
        //if revert to self fails, consider it fatal
        //
        if (fImpersonated && !RevertToSelf()) {
            status = GetLastError();
            DBGMSG(DBG_TRACE, ("UMRDPDR:RevertToSelf failed. Error:%ld.\n", status));
            goto Cleanup;
        }
        
        if (statusSave != ERROR_SUCCESS) {
            WCHAR * param = printerNameBuf;

            DBGMSG(DBG_ERROR, ("UMRDPPRN: SetDefaultPrinter failed. Error: %ld\n",
                statusSave));

            TsLogError(EVENT_NOTIFY_SETDEFAULTPRINTER_FAILED,
                EVENTLOG_ERROR_TYPE,
                1,
                &param,
                __LINE__);
        }
    }

    //
    //  Return immediately if the DLL is trying to shut down.  This
    //  is to help prevent us from getting stuck in a system call.
    //
    if (ShutdownFlag) {
        status = ERROR_SHUTDOWN_IN_PROGRESS;
        goto Cleanup;
    }

    //
    //  Restore cached data for the new printer.
    //
    if (ERROR_SUCCESS == status && cacheDataLen) {

        status = SetPrinterConfigInfo(
                            printerNameBuf,
                            cacheData,
                            cacheDataLen
                            );

        if (status != ERROR_SUCCESS) {

            WCHAR * param = printerNameBuf;

            DBGMSG(DBG_TRACE, ("UMRDPPRN:SetPrinterConfigInfo failed: %ld.\n", status));

            SetLastError(status);
            TsLogError(EVENT_NOTIFY_RESTORE_PRINTER_CONFIG_FAILED,
                EVENTLOG_WARNING_TYPE,
                1,
                &param,
                __LINE__);

            //
            //  We will go ahead and leave the queue created, but assume the config 
            //  settings are bad on the client and cause them to be overwritten with
            //  the default config settings.
            //
            status = ERROR_SUCCESS;
            triggerConfigChangeEvent = TRUE;
        }

    }

    //
    //  Return immediately if the DLL is trying to shut down.  This
    //  is to help prevent us from getting stuck in a system call.
    //
    if (ShutdownFlag) {
        status = ERROR_SHUTDOWN_IN_PROGRESS;
        goto Cleanup;
    }

    //
    //  Open the printer to make some modifications
    //
    if (queueCreated && (status == ERROR_SUCCESS)) {

        ASSERT(hPrinter == INVALID_HANDLE_VALUE);
        DBGMSG(DBG_TRACE, ("UMRDPPRN:InstallPrinterWithPortName installing printer queue succeeded.\n"));
        if( OpenPrinter(printerNameBuf, &hPrinter, &defaults) == FALSE ) {
            hPrinter = INVALID_HANDLE_VALUE;
            status = GetLastError();
            DBGMSG(DBG_TRACE, ("UMRDPPRN:OpenPrinter() %ws failed with %ld.\n", printerNameBuf, status));
        }

        //
        //  Add the session number to the printer queue data.
        //
        if (ERROR_SUCCESS == status) {
            status = AddSessionIDToPrinterQueue(hPrinter, GETTHESESSIONID());
            if( ERROR_SUCCESS != status ) {
                DBGMSG(DBG_ERROR,
                    ("UMRDPPRN:AddSessionIDToPrinterQueue failed for %ws.\n",
                    printerNameBuf)
                    );
            }
        }

        //
        //  Add the different names to the printer queue data.
        //  They will be used if we need to redirect (again!) the printer.
        //
        if (ERROR_SUCCESS == status) {
            status = AddNamesToPrinterQueue(hPrinter, &printerNames);
            if (status != ERROR_SUCCESS) {
                DBGMSG(DBG_ERROR,
                    ("UMRDPPRN:AddNamesToPrinterQueue failed for %ws with status %08x.\n",
                    printerNameBuf, status)
                    );
            }
        }
    }

    //
    //  Return immediately if the DLL is trying to shut down.  This
    //  is to help prevent us from getting stuck in a system call.
    //
    if (ShutdownFlag) {
        status = ERROR_SHUTDOWN_IN_PROGRESS;
        goto Cleanup;
    }

    //
    //  Check to make sure the printer doesn't already exist in the device list
    //
    printerNameExists =
        (DRDEVLST_FindByServerDeviceName(DeviceList, printerNameBuf,
                                        &ofs)
            && (DeviceList->devices[ofs].deviceType ==
                RDPDR_DTYP_PRINT));
    
    if (!printerNameExists) {
        //
        //  Add the printer to the list of installed devices.
        //
        if (ERROR_SUCCESS == status) {
            if( !DRDEVLST_Add(DeviceList, deviceID,
                              UMRDPDR_INVALIDSERVERDEVICEID,
                              RDPDR_DTYP_PRINT,
                              printerNameBuf,
                              printerName,
                              "UNKNOWN") ) {

                // DRDEVLST_Add
                status = ERROR_OUTOFMEMORY;
            }
        }

        //
        //  Trigger a config change event if the install function
        //  indicated that we need to push config data out to the client.
        //
        if (triggerConfigChangeEvent && (status == ERROR_SUCCESS)) {

            DRDEVLST_FindByClientDeviceID(DeviceList, deviceID, &ofs);
            DeviceList->devices[ofs].fConfigInfoChanged = TRUE;
            TriggerConfigChangeTimer();
        }
    }

Cleanup:

    //
    //  Close the printer handle if it was left open.
    //
    if (hPrinter != INVALID_HANDLE_VALUE) {
        ClosePrinter(hPrinter);
    }

    //
    //  Delete the queue on failure.
    //
    if (status != ERROR_SUCCESS && queueCreated) {
        UMRDPPRN_DeleteNamedPrinterQueue(printerNameBuf);
    }

    SetLastError(status);

    return (status == ERROR_SUCCESS);
}

DWORD
AddSessionIDToPrinterQueue(
    IN  HANDLE  hPrinter,
    IN  DWORD   sessionID
    )
/*++

Routine Description:

    Add the session ID to printer queue associated with the specified
    handle.

Arguments:

    hPrinter    -   Handle for printer returned by OpenPrinter.
    sessionID   -   Session ID.

Return Value:

    Returns ERROR_SUCCESS on success.  Error code, otherwise.

--*/
{
    DWORD result;

    result = SetPrinterData(
                hPrinter, DEVICERDR_SESSIONID, REG_DWORD,
                (PBYTE)&sessionID, sizeof(sessionID)
                );
    if (result != ERROR_SUCCESS) {
        DBGMSG(DBG_ERROR, ("UMRDPPRN:SetPrinterData failed with status %08x.\n", result));
    }
    return result;
}

DWORD
AddNamesToPrinterQueue(
    IN  HANDLE  hPrinter,
    IN  PTS_PRINTER_NAMES pPrinterNames
    )
/*++

Routine Description:

    Add the Server\Client\Printer names to printer queue
    associated with the specified handle.

Arguments:

    hPrinter    -   Handle for printer returned by OpenPrinter.
    pPrinterNames - struct conataining the names.

Return Value:

    Returns ERROR_SUCCESS on success.  Error code, otherwise.

--*/
{
    DWORD result = ERROR_SUCCESS;

    if(pPrinterNames->pszServer) {
        result = SetPrinterData(
                    hPrinter, DEVICERDR_PRINT_SERVER_NAME, REG_SZ,
                    (PBYTE)pPrinterNames->pszServer, (wcslen(pPrinterNames->pszServer) + 1)*sizeof(WCHAR)
                    );
        if (result != ERROR_SUCCESS) {
            DBGMSG(DBG_ERROR, ("UMRDPPRN:SetPrinterData failed to set %ws with status %08x.\n",
                   pPrinterNames->pszServer, result));
        }
    }
    if((result == ERROR_SUCCESS) && pPrinterNames->pszClient) {
        result = SetPrinterData(
                    hPrinter, DEVICERDR_CLIENT_NAME, REG_SZ,
                    (PBYTE)pPrinterNames->pszClient, (wcslen(pPrinterNames->pszClient) + 1)*sizeof(WCHAR)
                    );
        if (result != ERROR_SUCCESS) {
            DBGMSG(DBG_ERROR, ("UMRDPPRN:SetPrinterData failed to set %ws with status %08x.\n",
                   pPrinterNames->pszClient, result));
        }
    }
    if((result == ERROR_SUCCESS) && pPrinterNames->pszPrinter) {
        result = SetPrinterData(
                    hPrinter, DEVICERDR_PRINTER_NAME, REG_SZ,
                    (PBYTE)pPrinterNames->pszPrinter, (wcslen(pPrinterNames->pszPrinter) + 1)*sizeof(WCHAR)
                    );
        if (result != ERROR_SUCCESS) {
            DBGMSG(DBG_ERROR, ("UMRDPPRN:SetPrinterData failed to set %ws with status %08x.\n",
                   pPrinterNames->pszPrinter, result));
        }
    }
    return result;
}

BOOL
UMRDPPRN_DeleteNamedPrinterQueue(
    IN PWSTR printerName
    )
/*++

Routine Description:

    Delete the named printer.  This function does not remove the printer
    from the comprehensive device management list.

Arguments:

    printerName  -  Name of printer to delete.

Return Value:

    Returns TRUE on success.  FALSE, otherwise.

--*/
{
    HANDLE hPrinter;
    PRINTER_DEFAULTS defaults = {NULL, NULL, PRINTER_ALL_ACCESS};
    DWORD ofs;
    BOOL result;

    WCHAR defaultPrinterNameBuffer[MAX_PATH+1];
    DWORD bufSize = sizeof(defaultPrinterNameBuffer) / sizeof(defaultPrinterNameBuffer[0]);

    BOOL fPrinterIsDefault;
    BOOL fDefaultPrinterSet = FALSE;
    BOOL fImpersonated = FALSE;

    defaultPrinterNameBuffer[0] = L'\0';

    if (!PrintingModuleInitialized) {
        return FALSE;
    }

    //
    //  If the printer is one of the devices we are tracking, then
    //  we need to remove the notification object associated with the
    //  printer.
    //
    if (DRDEVLST_FindByServerDeviceName(DeviceList, printerName, &ofs) &&
        (DeviceList->devices[ofs].deviceSpecificData != NULL)) {

        PPRINTNOTIFYREC notifyRec = (PPRINTNOTIFYREC)
                                    DeviceList->devices[ofs].deviceSpecificData;
        ASSERT(notifyRec->notificationObject != NULL);
        ASSERT(notifyRec->printerHandle != NULL);

        WTBLOBJ_RemoveWaitableObject(
                    UMRDPPRN_WaitableObjMgr,
                    notifyRec->notificationObject
                    );

        FindClosePrinterChangeNotification(
            notifyRec->notificationObject
            );

        ClosePrinter(notifyRec->printerHandle);

        FREEMEM(notifyRec);

        DeviceList->devices[ofs].deviceSpecificData = NULL;
    }

    //
    // Check to see if the printer we are deleting is a default printer
    //

    if (!(fImpersonated = ImpersonateLoggedOnUser(UMRPDPPRN_TokenForLoggedOnUser))) {
            DBGMSG(DBG_TRACE, ("UMRDPDR:ImpersonateLoggedOnUser failed. Error:%ld.\n", GetLastError()));
    }


    fPrinterIsDefault = (GetDefaultPrinter(defaultPrinterNameBuffer, &bufSize) &&
                      (wcscmp(defaultPrinterNameBuffer, printerName) == 0));

    DBGMSG(DBG_TRACE, ("UMRDPPRN:DeleteNamedPrinter deleting %ws.\n",
            printerName));

    if (fImpersonated&& !RevertToSelf()) {
        DBGMSG(DBG_TRACE, ("UMRDPDR:RevertToSelf failed. Error:%ld.\n", GetLastError()));
    }


    //
    //  Open the printer.
    //
    result = OpenPrinter(printerName, &hPrinter, &defaults);

    //
    //  Purge and delete the printer.
    //
    if (result) {

        result = SetPrinter(hPrinter, 0, NULL, PRINTER_CONTROL_PURGE) &&
                 DeletePrinter(hPrinter);

    }
    else {
        hPrinter = NULL;
    }

    //
    //  If the printer is the default, then restore the previously stored
    //  printer context.
    //
    if (fPrinterIsDefault) {
        RestoreDefaultPrinterContext();
    }

    //
    //  Log an event on failure.
    //
    if (!result) {
        WCHAR * param = printerName;
        TsLogError(EVENT_NOTIFY_DELETE_PRINTER_FAILED,
                EVENTLOG_ERROR_TYPE,
                1,
                &param,
                __LINE__);

        DBGMSG(DBG_ERROR,
            ("UMRDPPRN:Unable to delete redirected printer - %ws. Error: %ld\n",
            printerName, GetLastError()));
    }
    else
    {
        DBGMSG(DBG_TRACE, ("UMRDPPRN:Printer successfully deleted.\n"));
    }

    //
    //  Close the printer if we successfully opened it.
    //
    if (hPrinter != NULL) {
        ClosePrinter(hPrinter);
     }

     return result;
}

BOOL
SetDefaultPrinterToFirstFound(
    BOOL impersonate
    )
/*++

Routine Description:

    Enumerate all printers visible to the user and try to set the
    first one we "can" to default.

Arguments:

    impersonate -   TRUE if this function should impersonate the user
                    prior to setting the default printer.

Return Value:

    Returns TRUE on success.  FALSE, otherwise.

--*/
{
    BOOL fSuccess = FALSE;
    BOOL fImpersonated = FALSE;
    PRINTER_INFO_4 * pPrinterInfo = NULL;
    DWORD cbBuf = 0;
    DWORD cReturnedStructs = 0;
    DWORD i;

    DBGMSG(DBG_TRACE, ("UMRDPDR:SetDefaultPrinterToFirstFound Entered.\n"));

    if (impersonate) {

        //
        // Impersonate Client
        //

        if ((UMRPDPPRN_TokenForLoggedOnUser == INVALID_HANDLE_VALUE) ||
            !(fImpersonated = ImpersonateLoggedOnUser(UMRPDPPRN_TokenForLoggedOnUser))) {

            if (UMRPDPPRN_TokenForLoggedOnUser == INVALID_HANDLE_VALUE) {
                DBGMSG(DBG_TRACE, ("UMRDPDR:UMRPDPPRN_TokenForLoggedOnUser is INVALID_HANDLE_VALUE.\n"));
            }
            else {
                DBGMSG(DBG_TRACE, ("UMRDPDR:ImpersonateLoggedOnUser failed. Error:%ld.\n", GetLastError()));
            }
            goto Cleanup;
        }

    }

    //
    // Enumerate Printers
    //

    if (!EnumPrinters(
            PRINTER_ENUM_LOCAL,     // Flags
            NULL,                   // Name
            4,                      // Print Info Type
            (PBYTE)pPrinterInfo,    // buffer
            0,                      // Size of buffer
            &cbBuf,                 // Required
            &cReturnedStructs)) {

        if(GetLastError() != ERROR_INSUFFICIENT_BUFFER ) {
            DBGMSG(DBG_ERROR, ("UMRDPPRN: EnumPrinters failed. Error: %ld.\n", GetLastError()));
            goto Cleanup;
        }
    }

    if (cbBuf == 0) {
        goto Cleanup;
    }

    pPrinterInfo = (PRINTER_INFO_4 *)ALLOCMEM(cbBuf);

    if (pPrinterInfo == NULL) {
        DBGMSG(DBG_ERROR, ("UMRDPPRN: ALLOCMEM failed. Error: %ld.\n", GetLastError()));
        goto Cleanup;
    }

    if (!EnumPrinters(
            PRINTER_ENUM_LOCAL,
            NULL,
            4,
            (PBYTE)pPrinterInfo,
            cbBuf,
            &cbBuf,
            &cReturnedStructs)) {

        DBGMSG(DBG_ERROR, ("UMRDPPRN: EnumPrinters failed. Error: %ld.\n", GetLastError()));
        goto Cleanup;
    }

    DBGMSG(DBG_TRACE, ("UMRDPPRN: Found %ld Local printers on Session %ld.\n",
            cReturnedStructs, GETTHESESSIONID()));

    if (fImpersonated) {
        RevertToSelf();
        fImpersonated = FALSE;
    }

    //
    // Try to set one of the available printers as the default printer
    //

    for (i = 0; i < cReturnedStructs; i++) {

        if (pPrinterInfo[i].pPrinterName) {
            
            DWORD status = ERROR_SUCCESS;

            DBGMSG(DBG_TRACE, ("UMRDPPRN: EnumPrinters - #%ld; Printer Name - %ws.\n",
                i, pPrinterInfo[i].pPrinterName));

            //
            //impersonate before setting the default printer as the api
            //accesses hkcu. If the impersonation fails, the api will fail
            //and we will log an error. But, before logging an error, we will
            //need to revert to self.
            //

            if (!(fImpersonated = ImpersonateLoggedOnUser(UMRPDPPRN_TokenForLoggedOnUser))) {
                DBGMSG(DBG_TRACE, ("UMRDPDR:ImpersonateLoggedOnUser failed. Error:%ld.\n", GetLastError()));
            }
                
            if (!SetDefaultPrinter(pPrinterInfo[i].pPrinterName)) {
                //
                //save the last error
                //
                status = GetLastError();
            }

            //
            //if revert to self fails, consider it fatal
            //

            if (fImpersonated && !RevertToSelf()) {
                DBGMSG(DBG_TRACE, ("UMRDPDR:RevertToSelf failed. Error:%ld.\n", GetLastError()));
                fSuccess = FALSE;
                break;
            }
            
            fImpersonated = FALSE;

            if (status == ERROR_SUCCESS) {
                fSuccess = TRUE;
                DBGMSG(DBG_TRACE, ("UMRDPPRN: The printer %ws was set as the Default Printer.\n",
                    pPrinterInfo[i].pPrinterName));

                break;
            }
            else {
                WCHAR * param = pPrinterInfo[i].pPrinterName;

                DBGMSG(DBG_ERROR, ("UMRDPPRN: SetDefaultPrinter failed. Error: %ld\n",
                    status));

                TsLogError(EVENT_NOTIFY_SETDEFAULTPRINTER_FAILED,
                    EVENTLOG_ERROR_TYPE,
                    1,
                    &param,
                    __LINE__);
            }
        }
    }

Cleanup:

    if (fImpersonated) {
        RevertToSelf();
    }

    if (pPrinterInfo != NULL) {
        FREEMEM(pPrinterInfo);
    }

    DBGMSG(DBG_TRACE, ("UMRDPDR:SetDefaultPrinterToFirstFound Leaving. fSuccess is %d.\n", fSuccess));
    return fSuccess;
}

BOOL
HandlePrinterConfigChangeNotification(
    IN DWORD serverDeviceID
    )
/*++

Routine Description:

    Handle notification from the spooler that the config info of a printer has changed.

Arguments:

    serverDeviceID      - Server-assigned device ID associated with the printer

Return Value:

    Returns TRUE.

--*/
{
    DWORD ofs;
    time_t timeDelta;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:HandlePrinterConfigChangeNotification entered.\n"));
    //
    //  If this is for one of our printers.
    //
    if (DRDEVLST_FindByServerDeviceID(DeviceList,
                                    serverDeviceID, &ofs)) {

        DBGMSG(DBG_TRACE, ("UMRDPPRN:Config Info for Printer %ws has changed.\n",
            DeviceList->devices[ofs].serverDeviceName));

        //
        //  The install time for the device needs to be beyond a configurable threshold
        //  before we will do anything about the change.  This eliminates forwarding
        //  unnecessary (non-user initiated) configuration changes to the client.
        //
        timeDelta = time(NULL) - DeviceList->devices[ofs].installTime;
        if ((DWORD)timeDelta > ConfigSendThreshold) {

            DBGMSG(DBG_TRACE,
                ("UMRDPPRN:Processing config change because outside change time delta.\n")
                );

            //
            //  Need to record that the configuration has changed and set a
            //  timer on forwarding to the client in order to compress changes into
            //  a single message to the client.
            //
            DeviceList->devices[ofs].fConfigInfoChanged = TRUE;
            TriggerConfigChangeTimer();
        }
        else {
            DBGMSG(DBG_TRACE,
                ("UMRDPPRN:Skipping config change because inside change time delta.\n")
                );
        }

    }
    return TRUE;
}

BOOL
SendPrinterConfigInfoToClient(
    IN PCWSTR printerName,
    IN LPBYTE pConfigInfo,
    IN DWORD  ConfigInfoSize
    )
/*++

Routine Description:

    Send a printer update cache data message to the client.

Arguments:

    printerName -   Name of printer.
    pConfigInfo -   Configuration Information.
    ConfigInfoSize -   size of config info.

Return Value:

    Return TRUE on success.  FALSE, otherwise.

--*/
{
    PRDPDR_PRINTER_CACHEDATA_PACKET cachedDataPacket;
    DWORD cachedDataPacketSize;
    PRDPDR_PRINTER_UPDATE_CACHEDATA cachedData;
    BOOL result;
    DWORD printerSz;
    PWSTR str;

    DBGMSG(DBG_TRACE, ("UMRDPPRN: SendPrinterConfigInfoToClient entered.\n"));
    DBGMSG(DBG_TRACE, ("UMRDPPRN:SendPrinterConfigInfoToClient printer name is %ws.\n",
            printerName));

    //
    //  Calculate the message size.
    //
    printerSz = ((wcslen(printerName) + 1) * sizeof(WCHAR));
    cachedDataPacketSize =  sizeof(RDPDR_PRINTER_CACHEDATA_PACKET) +
                            sizeof(RDPDR_PRINTER_UPDATE_CACHEDATA) +
                            printerSz +
                            ConfigInfoSize;

    //
    //  Allocate the message.
    //
    cachedDataPacket = (PRDPDR_PRINTER_CACHEDATA_PACKET)ALLOCMEM(
                                                    cachedDataPacketSize
                                                    );
    result = (cachedDataPacket != NULL);
    if (result) {

        PBYTE pData = NULL;
        //
        //  Set up the packet.
        //
        cachedDataPacket->Header.PacketId = DR_PRN_CACHE_DATA;
        cachedDataPacket->Header.Component = RDPDR_CTYP_PRN;
        cachedDataPacket->EventId = RDPDR_UPDATE_PRINTER_EVENT;

        //
        //  Set up the cached data.
        //
        cachedData = (PRDPDR_PRINTER_UPDATE_CACHEDATA)(
                            (PBYTE)cachedDataPacket +
                            sizeof(RDPDR_PRINTER_CACHEDATA_PACKET)
                            );
        cachedData->PrinterNameLen = printerSz;
        cachedData->ConfigDataLen = ConfigInfoSize;

        //
        //  Add the printer name.
        //
        str = (PWSTR)((PBYTE)cachedData + sizeof(RDPDR_PRINTER_UPDATE_CACHEDATA));
        wcscpy(str, printerName);

        //
        //  Add the config info.
        //
        pData = (PBYTE)str + printerSz;
        memcpy(pData, pConfigInfo, ConfigInfoSize);

        //
        //  Send the message to the client.
        //
        result = UMRDPDR_SendMessageToClient(
                                    cachedDataPacket,
                                    cachedDataPacketSize
                                    );

        // Release the buffer.
        FREEMEM(cachedDataPacket);
    }
    else {
        DBGMSG(DBG_ERROR, ("UMRDPPRN: Can't allocate cached data packet.\n"));
    }

    return result;
}

DWORD
GetPrinterConfigInfo(
    LPCWSTR printerName,
    LPBYTE * ppBuffer,
    LPDWORD pdwBufSize
    )
/*++

Routine Description:

    Gets the Printer configuration Information from PrintUI.

Arguments:

    printerName         - Name of the printer.
    ppBuffer            - A place holder for a buffer pointer.
                          This functions allocates memory and sends it out through this argument
                          The caller should free this memory.
    pdwBufSize          - size of allocated memory.

Return Value:

    Returns ERROR_SUCCESS if successful.

--*/
{
    WCHAR fileName[MAX_PATH];
    WCHAR tempPath[MAX_PATH];

    HANDLE hFile = INVALID_HANDLE_VALUE;

    DWORD dwResult;
    DWORD dwBytes;
    DWORD dwBytesRead;
    BOOL fImpersonated = FALSE;

    ASSERT(ppBuffer && pdwBufSize);
    *pdwBufSize = 0;

    //
    // Get Temp Folder
    // Impersonate first, so the file has the proper acls on it
    // Ignore the error, the worst case is caching will not be possible, as we create it with system acls
    // No security hole here
    //
    DBGMSG(DBG_TRACE, ("UMRDPPRN:GetPrinterConfigInfo entered.\n"));

    fImpersonated = ImpersonateLoggedOnUser(UMRPDPPRN_TokenForLoggedOnUser);
    
    dwResult = GetTempPathW(MAX_PATH, tempPath);
    if (dwResult > 0 && dwResult <= MAX_PATH) {
        GetTempFileNameW(tempPath, TEMP_FILE_PREFIX, 0, fileName);
    }
    else {
        GetTempFileNameW(L".", TEMP_FILE_PREFIX, 0, fileName);
    }

    DBGMSG(DBG_TRACE, ("UMRDPPRN:Temp File Name is %ws.\n", fileName));

    //
    //  While impersonating the logged on user, fetch the settings.
    //
    if (fImpersonated) {

        dwResult = CallPrintUiPersistFunc(printerName, fileName, 
                                          CMDLINE_FOR_STORING_CONFIGINFO_IMPERSONATE);
        RevertToSelf();

        if (dwResult != ERROR_SUCCESS) {
            DBGMSG(DBG_TRACE, ("UMRDPPRN:CallPrintUiPersistFunc failed with code: %ld\n", dwResult));
            goto Cleanup;
        }
    }
    else {
        dwResult = GetLastError();
        DBGMSG(DBG_TRACE, ("UMRDPPRN:ImpersonateLoggedOnUser: %ld\n", dwResult));
        goto Cleanup;
    }

    //
    // Open the file and read the contents to the buffer
    //

    hFile = CreateFileW(
        fileName,
        GENERIC_READ,
        FILE_SHARE_READ,
        NULL,
        OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,
        NULL
        );

    if (hFile == INVALID_HANDLE_VALUE) {
        dwResult = GetLastError();
        DBGMSG(DBG_TRACE, ("UMRDPPRN:CreateFileW failed with code: %ld\n", dwResult));
        goto Cleanup;
    }

    dwBytes = GetFileSize(hFile, NULL);

    *ppBuffer = (LPBYTE) ALLOCMEM(dwBytes);
    if (*ppBuffer == NULL) {
        dwResult = GetLastError();
        DBGMSG(DBG_TRACE, ("UMRDPPRN:AllocMem failed with code: %ld\n", dwResult));
        goto Cleanup;
    }

    if (!ReadFile(
            hFile,
            *ppBuffer,
            dwBytes,
            &dwBytesRead,
            NULL
            )) {
        dwResult = GetLastError();
        DBGMSG(DBG_TRACE, ("UMRDPPRN:ReadFile failed with code: %ld\n", dwResult));
        goto Cleanup;
    }

    * pdwBufSize = dwBytesRead;
    dwResult = ERROR_SUCCESS;

Cleanup:

    //
    // Close the file and delete it
    //

    if (hFile != INVALID_HANDLE_VALUE) {
        CloseHandle(hFile);

        DeleteFileW(fileName);
    }

    return dwResult;

}
DWORD
SetPrinterConfigInfo(
    LPCWSTR printerName,
    LPVOID lpBuffer,
    DWORD dwBufSize
    )
/*++

Routine Description:

    Sets the Printer configuration Information from the cache data.

Arguments:

    printerName         - Name of the printer.
    lpBuffer            - Cache data.
    pdwBufSize          - Size of Cache data.

Return Value:

    Returns ERROR_SUCCESS if successful.

--*/
{
    WCHAR fileName[MAX_PATH] = L"";
    WCHAR tempPath[MAX_PATH] = L"";

    HANDLE hFile = INVALID_HANDLE_VALUE;

    DWORD dwResult;
    DWORD dwBytes;
    BOOL fImpersonated = FALSE;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:SetPrinterConfigInfo entered.\n"));
    DBGMSG(DBG_TRACE, ("UMRDPPRN:printerName is %ws.\n", printerName));
    DBGMSG(DBG_TRACE, ("UMRDPPRN:bufsize is %ld.\n", dwBufSize));

    //
    // Get Temp Folder
    // Impersonate first, so the file has the proper acls on it
    // Ignore the error, the worst case is caching will not be possible, as we create it with system acls
    // No security hole here
    //
    fImpersonated = ImpersonateLoggedOnUser(UMRPDPPRN_TokenForLoggedOnUser);

    if (!fImpersonated) {
        DBGMSG(DBG_TRACE, ("UMRDPPRN:SetPrinterConfigInfo Impersonation failed. Creating temp file in the context of system\n"));
    }

    dwResult = GetTempPathW(MAX_PATH, tempPath);
    if (dwResult > 0 && dwResult <= MAX_PATH) {
        dwResult = GetTempFileNameW(tempPath, TEMP_FILE_PREFIX, 0, fileName);
    }
    else {
        dwResult = GetTempFileNameW(L".", TEMP_FILE_PREFIX, 0, fileName);
    }

    if( dwResult == 0 ) {
        dwResult = GetLastError();
        DBGMSG(DBG_TRACE, ("UMRDPPRN:GetTempFileNameW failed with code: %ld\n", dwResult));
        goto Cleanup;
    }

    //
    // Save the contents to the file
    //

    hFile = CreateFileW(
        fileName,
        GENERIC_WRITE,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        NULL,
        CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL,
        NULL
        );

    if (hFile == INVALID_HANDLE_VALUE) {
        dwResult = GetLastError();
        DBGMSG(DBG_TRACE, ("UMRDPPRN:CreateFileW failed with code: %ld\n", dwResult));
        goto Cleanup;
    }

    if ((!WriteFile(
            hFile,
            lpBuffer,
            dwBufSize,
            &dwBytes,
            NULL
            )) ||
        (dwBytes < dwBufSize)) {
        dwResult = GetLastError();
        CloseHandle(hFile);
        DBGMSG(DBG_TRACE, ("UMRDPPRN:WriteFile failed with code: %ld\n", dwResult));
        goto Cleanup;
    }

    if (hFile != INVALID_HANDLE_VALUE) {
        CloseHandle(hFile);
    }

    DBGMSG(DBG_TRACE, ("UMRDPPRN:fileName is %ws.\n", fileName));
    
    if (fImpersonated) {
        fImpersonated = !(RevertToSelf());
        DBGMSG(DBG_TRACE, ("UMRDPPRN:RevertToSelf %s\n", fImpersonated?"Failed":"Passed"));
    }

    //
    //  Call printui the first time as system.  We do this twice because
    //  some settings require that we be running as system vs. user.
    //
    dwResult = CallPrintUiPersistFunc(printerName, fileName, 
                                    CMDLINE_FOR_RESTORING_CONFIGINFO_NOIMPERSONATE);
    if (dwResult != ERROR_SUCCESS) {
        goto Cleanup;
    }

    //
    //  Call printui the second time as the logged on user.  
    //
    if (ImpersonateLoggedOnUser(UMRPDPPRN_TokenForLoggedOnUser)) {
        dwResult = CallPrintUiPersistFunc(printerName, fileName, 
                                    CMDLINE_FOR_RESTORING_CONFIGINFO_IMPERSONATE);
        RevertToSelf();
        if (dwResult != ERROR_SUCCESS) {
            goto Cleanup;
        }
    }
    else {
        dwResult = GetLastError();
        DBGMSG(DBG_ERROR, ("UMRDPPRN:  ImpersonateLoggedOnUser:  %08X\n", 
                dwResult));
    }

Cleanup:
    if (fImpersonated) {
        RevertToSelf();
    }

    if (hFile != INVALID_HANDLE_VALUE) {
        DeleteFileW(fileName);
    }

    return dwResult;
}

DWORD
CallPrintUiPersistFunc(
    LPCWSTR printerName,
    LPCWSTR fileName,
    LPCWSTR formatString
    )
/*++

Routine Description:

    Calls the PrintUI function for storing or restoring printer config info.

Arguments:

    printerName         - Name of the printer.
    fileName            - Name of the temp file.
    formatString        - PrintUI save/restore format string.

Return Value:

    Returns ERROR_SUCCESS if successful.

--*/
{
    WCHAR cmdLine[3 * MAX_PATH + (sizeof(CMDLINE_FOR_RESTORING_CONFIGINFO_NOIMPERSONATE)/sizeof(WCHAR)) + 2];
    WCHAR formattedPrinterName[(MAX_PATH+1)*2];
    WCHAR * pSource, * pDest;

    DWORD dwResult = ERROR_SUCCESS;

    DBGMSG(DBG_TRACE, ("UMRDPPRN:CallPrintUiPersistFunc Entered.\n"));

    ASSERT(PrintUIEntryFunc != NULL);
    ASSERT(printerName != NULL);
    ASSERT(fileName != NULL);

    //
    // Format the printer name
    //

    pSource = (WCHAR *)printerName;
    pDest = formattedPrinterName;

    while (*pSource) {
            if (*pSource == L'\"' || *pSource == L'@') {
                    *pDest++ = L'\\';
            }
            *pDest++ = *pSource++;
            //
            // pDest may have buffer overflow. Check for it.
            //
            if ((pDest - formattedPrinterName) >= 
                (sizeof(formattedPrinterName)/sizeof(formattedPrinterName[0]) - 1)) {
                return STATUS_BUFFER_OVERFLOW;
            }
    }
    *pDest = L'\0';

    //
    // Format the command line to be passed to PrintUI function
    //

    swprintf(cmdLine, formatString, formattedPrinterName, fileName);

    DBGMSG(DBG_TRACE, ("UMRDPPRN:cmdLine is: %ws\n", cmdLine));

    dwResult = (DWORD)PrintUIEntryFunc(
                NULL,           // Window handle
                PrintUILibHndl, // Handle to DLL instance.
                cmdLine,        // Command Line
                TRUE
                );

    DBGMSG(DBG_TRACE, ("UMRDPPRN:PrintUiEntryFunc returned: %ld\n", dwResult));

    return dwResult;
}

void
WaitableTimerSignaled(
    HANDLE waitableObject,
    PVOID clientData
    )
/*++

Routine Description:

    Goes through the device list checking if the config info has changed
    for any of the printers. If so, sends the config info to the client.

Arguments:

    waitableObject  -   Associated waitable object.
    clientData      -   Ignored.

Return Value:

    NONE.

--*/
{
    DWORD dwResult = ERROR_SUCCESS;
    DWORD i;
    BOOL fImpersonated;
    LARGE_INTEGER li;
    DBGMSG(DBG_TRACE, ("UMRDPPRN: WaitableTimerSignaled Entered.\n"));

    //
    // Compute as large number as possible, but do not overflow.
    //
    li.QuadPart = Int32x32To64(INFINITE_WAIT_PERIOD, INFINITE_WAIT_PERIOD);
    li.QuadPart *= -1; //relative time
    //
    // Reset the waitable timer to a non-signaled state.
    // We don't want it signaled until we do a TriggerConfigChangeTimer.
    // So, set the time interval to a very large number.
    //
    ASSERT(g_fTimerSet);
    ASSERT(waitableObject == WaitableTimer);
    
    if (!SetWaitableTimer(waitableObject,
                          &li,
                          0,
                          NULL,
                          NULL,
                          FALSE)) {
        DBGMSG(DBG_TRACE, ("UMRDPPRN:SetWaitableTimer Failed."
                "Error: %ld.\n", GetLastError()));
    }
    //
    // Now, kill the timer
    // TODO: Do we really need this?
    //
    if (!CancelWaitableTimer(waitableObject)) {
        DBGMSG(DBG_ERROR, ("UMRDPPRN: CancelWaitableTimer failed."
                "Error: %ld\n", GetLastError()));
    }
    g_fTimerSet = FALSE;
    //
    // Iterate the Devices List to see if config Info has changed for any
    //

    for (i = 0; i < DeviceList->deviceCount; i++) {
        if (DeviceList->devices[i].fConfigInfoChanged) {

            LPBYTE pConfigData = NULL;
            DWORD size = 0;

            //
            // reset error code in order to process next item
            //
            dwResult = ERROR_SUCCESS;

            // Reset the flag
            DeviceList->devices[i].fConfigInfoChanged = FALSE;

            DBGMSG(DBG_INFO, ("UMRDPPRN: Trying to Get ConfigInfo for the printer %ws\n",
                DeviceList->devices[i].serverDeviceName));

            //
            // Get the printer config info.
            //
            if (dwResult == ERROR_SUCCESS) {
                dwResult = GetPrinterConfigInfo(
                    DeviceList->devices[i].serverDeviceName,
                    &pConfigData, &size);
            }

            if (dwResult == ERROR_SUCCESS) {

                // Send this info to the client
                SendPrinterConfigInfoToClient(
                    DeviceList->devices[i].clientDeviceName,
                    pConfigData,
                    size
                    );
            }

            if (pConfigData) {
                FREEMEM(pConfigData);
            }
        }
    }

    DBGMSG(DBG_TRACE, ("UMRDPPRN: Leaving WaitableTimerSignaled.\n"));
}

BOOL
SendPrinterRenameToClient(
    IN PCWSTR oldprinterName,
    IN PCWSTR newprinterName
    )
/*++

Routine Description:

    Send a printer update cache data message to the client.

Arguments:

    oldprinterName -   Old Name of printer.
    newprinterName -   New Name of printer.

Return Value:

    Return TRUE on success.  FALSE, otherwise.

--*/
{
    PRDPDR_PRINTER_CACHEDATA_PACKET cachedDataPacket;
    DWORD cachedDataPacketSize;
    PRDPDR_PRINTER_RENAME_CACHEDATA cachedData;
    BOOL result;
    DWORD oldNameLen, newNameLen;
    PWSTR str;

    DBGMSG(DBG_TRACE, ("UMRDPPRN: SendPrinterRenameToClient entered.\n"));
    DBGMSG(DBG_TRACE, ("UMRDPPRN:SendPrinterRenameToClient Old printer name is %ws.\n",
            oldprinterName));
    DBGMSG(DBG_TRACE, ("UMRDPPRN:SendPrinterRenameToClient New printer name is %ws.\n",
            newprinterName));

    //
    //  Calculate the message size.
    //
    oldNameLen = (oldprinterName) ? ((wcslen(oldprinterName) + 1) * sizeof(WCHAR)) : 0;
    newNameLen = (newprinterName) ? ((wcslen(newprinterName) + 1) * sizeof(WCHAR)) : 0;

    if (!(oldNameLen && newNameLen)) {
        DBGMSG(DBG_TRACE, ("UMRDPPRN: Printer name is empty. Returning FALSE\n"));
        return FALSE;
    }

    cachedDataPacketSize =  sizeof(RDPDR_PRINTER_CACHEDATA_PACKET) +
                            sizeof(RDPDR_PRINTER_RENAME_CACHEDATA) +
                            oldNameLen + newNameLen;

    //
    //  Allocate the message.
    //
    cachedDataPacket = (PRDPDR_PRINTER_CACHEDATA_PACKET)ALLOCMEM(
                                                    cachedDataPacketSize
                                                    );
    result = (cachedDataPacket != NULL);
    if (result) {
        //
        //  Set up the packet.
        //
        cachedDataPacket->Header.PacketId = DR_PRN_CACHE_DATA;
        cachedDataPacket->Header.Component = RDPDR_CTYP_PRN;
        cachedDataPacket->EventId = RDPDR_RENAME_PRINTER_EVENT;

        //
        //  Set up the cached data.
        //
        cachedData = (PRDPDR_PRINTER_RENAME_CACHEDATA)(
                            (PBYTE)cachedDataPacket +
                            sizeof(RDPDR_PRINTER_CACHEDATA_PACKET)
                            );
        cachedData->OldPrinterNameLen = oldNameLen;
        cachedData->NewPrinterNameLen = newNameLen;

        //
        //  Add the printer names.
        //
        str = (PWSTR)((PBYTE)cachedData + sizeof(RDPDR_PRINTER_RENAME_CACHEDATA));
        wcscpy(str, oldprinterName);

        str = (PWSTR)((PBYTE)str + oldNameLen);
        wcscpy(str, newprinterName);

        //
        //  Send the message to the client.
        //
        result = UMRDPDR_SendMessageToClient(
                                    cachedDataPacket,
                                    cachedDataPacketSize
                                    );

        // Release the buffer.
        FREEMEM(cachedDataPacket);
    }

    DBGMSG(DBG_TRACE, ("UMRDPPRN: SendPrinterRenameToClient Leaving.\n"));

    return result;
}

VOID LoadConfigurableValues()
/*++

Routine Description:

    Load configurable values out of the registry.

Arguments:

Return Value:

--*/
{
    LONG status;
    HKEY regKey;
    LONG sz;
    BOOL fetchResult;
    LONG s;

    DBGMSG(DBG_TRACE, ("UMRDPPRN: LoadConfigurableValues entered.\n"));

    //
    //  Open the top level reg key for configurable resources.
    //
    status = RegOpenKeyEx(HKEY_LOCAL_MACHINE, CONFIGREGKEY, 0,
                          KEY_READ, &regKey);

    //
    //  Read the configurable threshold for delta between printer installation
    //  time and forwarding of first user-initiated configuration change data
    //  to the client.  The units for this value is in seconds.
    //
    if (status == ERROR_SUCCESS) {
        sz = sizeof(ConfigSendThreshold);
        s = RegQueryValueEx(regKey, CONFIGTHRESHOLDREGVALUE, NULL,
                                NULL, (PBYTE)&ConfigSendThreshold, &sz);
        if (s != ERROR_SUCCESS) {
            ConfigSendThreshold = CONFIGTHRESHOLDDEFAULT;
            DBGMSG(DBG_WARN,
                ("UMRDPPRN: LoadConfigurableValues can't read config threshold:  %ld.\n", s));
        }
    }
    else {
        regKey = NULL;
    }

    DBGMSG(DBG_TRACE,
        ("UMRDPPRN:Config. change threshold is %ld.\n",
        ConfigSendThreshold)
        );

    //
    //  Read the location of the user-configurable Client Driver Name Mapping INF.
    //
    ASSERT(UserDefinedMappingINFName == NULL);
    ASSERT(UserDefinedMappingINFSection == NULL);
    fetchResult = FALSE;
    if (status == ERROR_SUCCESS) {
        fetchResult = TSNUTL_FetchRegistryValue(
                                            regKey,
                                            CONFIGUSERDEFINEDMAPPINGINFNAMEVALUE,
                                            (PBYTE *)&UserDefinedMappingINFName
                                            );
    }

    //
    //  Read the section name of the user-configurable Client Driver Name Mapping INF.
    //
    if ((status == ERROR_SUCCESS) && fetchResult) {
        fetchResult = TSNUTL_FetchRegistryValue(
                                regKey,
                                CONFIGUSERDEFINEDMAPPINGINFSECTIONVALUE,
                                (PBYTE *)&UserDefinedMappingINFSection
                                );
        if (!fetchResult) {
            ASSERT(UserDefinedMappingINFSection == NULL);
            FREEMEM(UserDefinedMappingINFName);
            UserDefinedMappingINFName = NULL;
        }
    }


    //
    //  Close the parent reg key.
    //
    if (regKey != NULL) {
        RegCloseKey(regKey);
    }

    DBGMSG(DBG_TRACE, ("UMRDPPRN: LoadConfigurableValues exiting.\n"));
}

HANDLE
RegisterForPrinterPrefNotify()
/*++

Routine Description:

    Register for changes to one of this session's printers' Printing
    Preferences.

Arguments:

Return Value:

    Handle to an event that will be signaled when the printing preferences
    change for one of this session's printers.  NULL is returned on error.

--*/
{
    LONG ret;
    HANDLE hEvent;
    BOOL impersonated=FALSE;
    NTSTATUS status;
    HANDLE hKeyCurrentUser=INVALID_HANDLE_VALUE;

    DBGMSG(DBG_TRACE, ("UMRDPPRN: RegisterForPrinterPrefNotify entered.\n"));

    //
    //  Open the event.
    //
    hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (hEvent == NULL) {
        DBGMSG(DBG_ERROR,
            ("UMRDPPRN: can't create event:  %ld.\n",
            GetLastError()));
    }

    //
    //  Need to impersonate the logged in user so we can get to the right
    //  dev mode.
    //
    if (hEvent != NULL) {
        if ((UMRPDPPRN_TokenForLoggedOnUser == INVALID_HANDLE_VALUE) ||
            !ImpersonateLoggedOnUser(UMRPDPPRN_TokenForLoggedOnUser)) {
                DBGMSG(DBG_ERROR, ("UMRDPPRN: can't impersonate user %ld.\n",
                    GetLastError()));
            CloseHandle(hEvent);
            hEvent = NULL;
            impersonated = FALSE;
        }
        else {
            impersonated = TRUE;
        }
    }

    //
    //  Attempt to open the the HKEY_CURRENT_USER predefined handle.
    //
    if (hEvent != NULL) {
        status = RtlOpenCurrentUser(KEY_ALL_ACCESS, &hKeyCurrentUser);
        if (!NT_SUCCESS(status)) {
            DBGMSG(DBG_ERROR, ("UMRDPPRN: can't open HKCU:  %08X.\n",status));
            CloseHandle(hEvent);
            hEvent = NULL;
        }
    }

    //
    //  Open the printing system dev mode for this user.  If it doesn't exist,
    //  it will be created. This key is changed when a user modifies their printing
    //  preferences.
    //
    if (hEvent != NULL) {
        ASSERT(DevModeHKey == INVALID_HANDLE_VALUE);
        ret = RegCreateKeyEx(
                        hKeyCurrentUser,                    // handle to an open key
                        TEXT("Printers\\DevModePerUser"),   // address of subkey name
                        0,                                  // reserved
                        NULL,                               // address of class string
                        REG_OPTION_NON_VOLATILE,            // special options flag
                        KEY_ALL_ACCESS,                     // desired security access
                        NULL,                               // key security structure
                        &DevModeHKey,                       // buffer for opened handle
                        NULL                                // disposition value buffer
                        );

        if (ret != ERROR_SUCCESS) {
            DBGMSG(DBG_ERROR,
                ("UMRDPPRN: can't open printing dev mode:  %ld.\n", ret)
                );
            CloseHandle(hEvent);
            hEvent = NULL;
            DevModeHKey = INVALID_HANDLE_VALUE;
        }
    }

    //
    //  Revert back to the system user.
    //
    if (impersonated) {
        RevertToSelf();
    }

    //
    //  Register for notification on this key.
    //
    if (hEvent != NULL) {
        ret = RegNotifyChangeKeyValue(
                              DevModeHKey,
                              TRUE,
                              REG_NOTIFY_CHANGE_NAME | REG_NOTIFY_CHANGE_LAST_SET,
                              hEvent,
                              TRUE
                              );
        if (ret != ERROR_SUCCESS) {
            DBGMSG(DBG_ERROR,
                ("UMRDPPRN: can't register for registry key change event:  %ld.\n",
                ret));
            CloseHandle(hEvent);
            hEvent = NULL;
        }
    }

    //
    //  Close the handle to HKCU.
    //
    if (hKeyCurrentUser != INVALID_HANDLE_VALUE) {
        RegCloseKey(hKeyCurrentUser);
    }

    //
    //  Log an event on error.
    //
    if (hEvent == NULL) {
        TsLogError(
            EVENT_NOTIFY_FAILEDTOREGFOR_SETTING_NOTIFY,
            EVENTLOG_ERROR_TYPE,
            0,
            NULL,
            __LINE__
            );
    }

    DBGMSG(DBG_TRACE, ("UMRDPPRN: RegisterForPrinterPrefNotify done.\n"));

    return hEvent;
}

/*++

Routine Description:

    Check if a specific printer driver already installed.

Arguments:

    clientDriver            -   Client Driver Name.

Return Values:

    ERROR_SUCCESS if driver already installed.
    ERROR_FILE_NOT_FOUND if driver is not installed.
    or other error code

--*/
DWORD PrinterDriverInstalled(
    IN PCWSTR clientDriver
    )
{
    PDRIVER_INFO_1 pDrivers = NULL;
    DWORD cbNeeded;
    DWORD cbAllocated;
    DWORD cbReturned;
    DWORD dwStatus = ERROR_FILE_NOT_FOUND;
    BOOL bSuccess;
    DWORD i;

    DBGMSG(DBG_TRACE, ("UMRDPPRN: PrinterDriverInstalled looking for %ws.\n", clientDriver));

    //
    //  Return immediately if the DLL is trying to shut down.  This
    //  is to help prevent us from getting stuck in a system call.
    //
    if( ShutdownFlag ) {
        return ERROR_SHUTDOWN_IN_PROGRESS;
    }

    bSuccess = EnumPrinterDrivers(
                            NULL,
                            NULL,
                            1,          // we only need a list of driver name
                            (LPBYTE) pDrivers,
                            0,
                            &cbNeeded,
                            &cbReturned
                        );

    if( TRUE == bSuccess || ( dwStatus = GetLastError() ) == ERROR_INSUFFICIENT_BUFFER ) {

        //
        //  Return immediately if the DLL is trying to shut down.  This
        //  is to help prevent us from getting stuck in a system call.
        //
        if( ShutdownFlag ) {
            dwStatus = ERROR_SHUTDOWN_IN_PROGRESS;
        }
        else {

            pDrivers = (PDRIVER_INFO_1)ALLOCMEM( cbAllocated = cbNeeded );

            if( NULL != pDrivers ) {
                bSuccess = EnumPrinterDrivers(
                                    NULL,
                                    NULL,
                                    1,          // we only need a list of driver name
                                    (LPBYTE)pDrivers,
                                    cbAllocated,
                                    &cbNeeded,
                                    &cbReturned
                                );

                if( TRUE == bSuccess ) {
                    //
                    // loop thru entire list to find out if interested driver
                    // exists on local machine.
                    // Return immediately if the DLL is trying to shut down.  This
                    // is to help prevent us from getting stuck in a system call.
                    //
                    dwStatus = ERROR_FILE_NOT_FOUND;

                    for( i=0; FALSE == ShutdownFlag && i < cbReturned; i++ ) {
                        if( 0 == _wcsicmp( pDrivers[i].pName, clientDriver ) ) {
                            dwStatus = ERROR_SUCCESS;
                            break;
                        }
                    }

                    if( ShutdownFlag ) {
                        dwStatus = ERROR_SHUTDOWN_IN_PROGRESS;
                    }
                }
                else {
                    dwStatus = GetLastError();
                }

                FREEMEM( pDrivers );

            }
            else {
                dwStatus = GetLastError();
            }
        }
    }

    DBGMSG(DBG_TRACE, ("UMRDPPRN: PrinterDriverInstalled done with %ld.\n", dwStatus));

    return dwStatus;
}

/*++

Routine Description:

    Map a client printer driver name to a server printer driver name,
    if a mapping is defined in ntprint.inf or the inf that is available
    to the end-user.

Arguments:

    clientDriver            -   Client driver name.
    mappedName              -   Pointer to mapped driver name buffer.  Should
                                be released if the mapping is successful.
    mappedNameBufSize       -   Returned size of mapped driver name buffer.

Return Value:

    TRUE if the client driver name was mapped.

--*/
BOOL MapClientPrintDriverName(
    IN  PCWSTR clientDriver,
    IN OUT PWSTR *mappedName,
    IN OUT DWORD *mappedNameBufSize
    )
{
    BOOL clientDriverMapped = FALSE;
    ULONG requiredSize;
    USHORT nNumPrintSections;

    DBGMSG(DBG_TRACE, ("UMRDPPRN: MapClientPrintDriverName with %ws.\n", clientDriver));


    //
    //  First, check the user-defined INF section if it is so configured.
    //
    if ((UserDefinedMappingINFName != NULL) &&
        (UserDefinedMappingINFSection != NULL)) {
        while (!(clientDriverMapped =
            RDPDRUTL_MapPrintDriverName(
                    clientDriver, UserDefinedMappingINFName,
                    UserDefinedMappingINFSection, 0, 1,
                    *mappedName,
                    (*mappedNameBufSize) / sizeof(WCHAR),
                    &requiredSize
                    )) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
            if (!UMRDPDR_ResizeBuffer(&MappedDriverNameBuf, requiredSize * sizeof(WCHAR),
                                &MappedDriverNameBufSize)) {
                break;
            }
        }
    }

    if( clientDriverMapped ) {
        goto Done;
    }

    //
    // Client does not send over platform info (NT4, Win9x...) so try both
    // upgrade file
    //

    //
    // printupg.inf contain block driver and its mapping to inbox driver which
    // is not in ntprint.inf.
    //
    
    nNumPrintSections = 0;
    
    while( (NULL != prgwszPrinterSectionNames[nNumPrintSections]) &&
           !(clientDriverMapped =
            RDPDRUTL_MapPrintDriverName(
                    clientDriver,
                    L"printupg.inf",
                    prgwszPrinterSectionNames[nNumPrintSections++], 
                    0, 
                    1,
                    *mappedName,
                    (*mappedNameBufSize) / sizeof(WCHAR),
                    &requiredSize
                    ))&& 
           (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
        if (!UMRDPDR_ResizeBuffer(&MappedDriverNameBuf, requiredSize * sizeof(WCHAR),
                            &MappedDriverNameBufSize)) {
            break;
        }
    }




    if( clientDriverMapped ) {
        goto Done;
    }

    //
    // if still can't find a mapping, try using prtupg9x.inf
    //

    while( !(clientDriverMapped =
            RDPDRUTL_MapPrintDriverName(
                    clientDriver,
                    L"prtupg9x.inf",
                    L"Printer Driver Mapping", 0, 1,
                    *mappedName,
                    (*mappedNameBufSize) / sizeof(WCHAR),
                    &requiredSize
                    )) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER) ) {
        if (!UMRDPDR_ResizeBuffer(&MappedDriverNameBuf, requiredSize * sizeof(WCHAR),
                            &MappedDriverNameBufSize)) {
            break;
        }
    }

    if( clientDriverMapped ) {
        goto Done;
    }

    //
    //  If we didn't get a match, then check the "Previous Names" section
    //  of ntprint.inf.  Source and destination fields are kind of backwards
    //  in ntprint.inf.
    //
    if (!clientDriverMapped) {
        while (!(clientDriverMapped =
            RDPDRUTL_MapPrintDriverName(
                    clientDriver, L"ntprint.inf",
                    L"Previous Names", 1, 0,
                    *mappedName,
                    (*mappedNameBufSize) / sizeof(WCHAR),
                    &requiredSize
                    )) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
            if (!UMRDPDR_ResizeBuffer(&MappedDriverNameBuf, requiredSize * sizeof(WCHAR),
                                &MappedDriverNameBufSize)) {
                break;
            }
        }
    }

Done:

    if(clientDriverMapped) {
        DBGMSG(DBG_TRACE, ("UMRDPPRN: MapClientPrintDriverName returns %ws.\n", *mappedName));
    }

    return clientDriverMapped;
}

BOOL
GetPrinterPortName(
    IN  HANDLE hPrinter,
    OUT PWSTR *portName
    )
/*++

Routine Description:

    Get the port name for an open printer.

Arguments:

    hPrinter    -   Open printer handle.
    portName    -   Port name

Return Value:

    Return TRUE on success.  FALSE, otherwise.

--*/
{
    BOOL result;
    DWORD sz;

    //
    //  Size our printer info level 2 buffer.
    //
    result = !GetPrinter(hPrinter, 2, NULL, 0, &sz) &&
                    (GetLastError() == ERROR_INSUFFICIENT_BUFFER);
    if (result) {
        result = UMRDPDR_ResizeBuffer(
                            &PrinterInfo2Buf,
                            sz, &PrinterInfo2BufSize
                            );
    }

    //
    //  Get printer info level 2 for the new printer.
    //
    if (result) {
        result = GetPrinter(hPrinter, 2, (char *)PrinterInfo2Buf,
                            PrinterInfo2BufSize, &sz);
    }

    if (result) {
        *portName = &PrinterInfo2Buf->pPortName[0];
    }
    else {
        DBGMSG(DBG_ERROR, ("UMRDPDR:Error fetching printer port name."));
    }
    return result;
}

BOOL
SaveDefaultPrinterContext(PCWSTR currentlyInstallingPrinterName)
/*++

Routine Description:

    Save current contextual information for the active user's default
    printer, so it can be restored on printer deletion.

Arguments:

Return Value:

    TRUE is returned on success.  Otherwise, FALSE is returned and
    GetLastError() can be used for retrieving extended error information.

--*/
{
    BOOL result;
    DWORD bufSize;
    DWORD status = ERROR_SUCCESS;
    BOOL fImpersonated = FALSE;


    DBGMSG(DBG_TRACE, ("UMRDPPRN: SaveDefaultPrinterContext entered.\n"));

    //
    //  Save the name of the current default printer, in RAM.
    //
    bufSize = sizeof(SavedDefaultPrinterName) / sizeof(SavedDefaultPrinterName[0]);

    //
    //impersonate first
    //

    if (!(fImpersonated = ImpersonateLoggedOnUser(UMRPDPPRN_TokenForLoggedOnUser))) {
            DBGMSG(DBG_TRACE, ("UMRDPDR:ImpersonateLoggedOnUser failed. Error:%ld.\n", GetLastError()));
    }

    if (!(result = GetDefaultPrinter(SavedDefaultPrinterName, &bufSize))) {
        status = GetLastError();
    }

    if (fImpersonated && !RevertToSelf()) {
        DBGMSG(DBG_TRACE, ("UMRDPDR:RevertToSelf failed. Error:%ld.\n", GetLastError()));
        result = FALSE;
    }
    //
    // 645988:Check if the just installed TS printer is the default printer.
    // Since we haven't set it as a TS printer yet, the RDPDRUTL_PrinterIsTs()
    // function will return false and we save this as global default.
    // That will cause problems later when we try to
    // restore the default printer context.
    //
    if (_wcsicmp(currentlyInstallingPrinterName, SavedDefaultPrinterName) == 0) {
        //
        // Clear the default printer name to 
        // indicate we haven't found any yet.
        //
        wcscpy(SavedDefaultPrinterName, L"");
        result = FALSE;
        goto Exit;
    }
    
    //
    //  If the current default printer is a non-TS printer, store its
    //  name in a global reg. key for this user.  That way, it can be
    //  saved when this session or some other session for this user
    //  disconnects/logs out.
    //
    if (result) {
        if (!RDPDRUTL_PrinterIsTS(SavedDefaultPrinterName)) {
            result = SavePrinterNameAsGlobalDefault(SavedDefaultPrinterName);
        }
    }
    else {
        DBGMSG(DBG_ERROR, ("UMRDPPRN: Error fetching def printer:  %ld.\n",
            status));
    }

    DBGMSG(DBG_TRACE, ("UMRDPPRN: SaveDefaultPrinterContext exiting.\n"));
Exit:
    return result;
}

BOOL
SavePrinterNameAsGlobalDefault(
    IN PCWSTR printerName
 )
/*++

Routine Description:

    Save the specified printer in the registry so it is visible to all
    other sessions for this user as the last known default printer.

Arguments:

    printerName -   Printer name.

Return Value:

    TRUE is returned on success.  Otherwise, FALSE is returned and
    GetLastError() can be used for retrieving extended error information.

--*/
{
    BOOL result;
    WCHAR *sidAsText = NULL;
    HKEY regKey = NULL;
    DWORD sz;
    PSID pSid;
    DWORD status;

    DBGMSG(DBG_TRACE, ("UMRDPPRN: SavePrinterNameAsGlobalDefault entered.\n"));

    //
    //  Get the user's SID.  This is how we uniquely identify the user.
    //
    pSid = TSNUTL_GetUserSid(UMRPDPPRN_TokenForLoggedOnUser);
    result = pSid != NULL;

    //
    //  Get a textual representation of the session user's SID.
    //
    if (result) {
        sz = 0;
        result = TSNUTL_GetTextualSid(pSid, NULL, &sz);
        ASSERT(!result);
        if (!result && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
            sidAsText = (WCHAR *)ALLOCMEM(sz);
            if (sidAsText != NULL) {
                result = TSNUTL_GetTextualSid(pSid, sidAsText, &sz);
            }
        }
    }

    //
    //  Open the reg key.
    //
    if (result) {
        status = RegCreateKey(
                            HKEY_LOCAL_MACHINE, USERDEFAULTPRNREGKEY,
                            &regKey
                            );
        result = status == ERROR_SUCCESS;
        if (!result) {
            DBGMSG(DBG_ERROR, ("UMRDPPRN:  RegCreateKey failed for %s:  %ld.\n",
                    USERDEFAULTPRNREGKEY, status));
        }
    }

    //
    //  Write the value for the default printer.
    //
    if (result) {
        sz = (wcslen(printerName) + 1) * sizeof(WCHAR);
        status = RegSetValueEx(regKey, sidAsText, 0, REG_SZ, (PBYTE)printerName, sz);
        result = status == ERROR_SUCCESS;
        if (!result) {
            DBGMSG(DBG_ERROR, ("UMRDPPRN:  RegSetValueEx failed for %s:  %ld.\n",
                    sidAsText, status));
        }
    }

    //
    //  Clean up.
    //
    if (sidAsText != NULL)  FREEMEM(sidAsText);
    if (regKey != NULL)     RegCloseKey(regKey);
    if (pSid != NULL)       FREEMEM(pSid);

    DBGMSG(DBG_TRACE, ("UMRDPPRN: SavePrinterNameAsGlobalDefault exiting.\n"));

    return result;
}

BOOL
RestoreDefaultPrinterContext()
/*++

Routine Description:

    Restore the most recent default printer context, as saved via a call to
    SaveDefaultPrinterContext.

Arguments:

Return Value:

    TRUE is returned on success.  Otherwise, FALSE is returned and
    GetLastError() can be used for retrieving extended error information.

--*/
{
    BOOL result;
    HANDLE hPrinter;
    PRINTER_DEFAULTS printerDefaults = {NULL, NULL, PRINTER_ACCESS_USE};

    WCHAR *sidAsText = NULL;
    HKEY regKey = NULL;
    DWORD sz;
    PSID pSid = NULL;
    DWORD status;

    WCHAR savedDefaultPrinter[MAX_PATH];

    WCHAR *nameToRestore = NULL;

    DBGMSG(DBG_TRACE, ("UMRDPPRN: RestoreDefaultPrinterContext entered.\n"));

    //
    //  Assume that we will succeed.
    //
    result = TRUE;

    //
    //  Restore the default printer name stored in RAM, if it exists.
    //
    if (wcscmp(SavedDefaultPrinterName, L"") &&
            OpenPrinter(SavedDefaultPrinterName, &hPrinter, &printerDefaults)) {
        ClosePrinter(hPrinter);
        nameToRestore = &SavedDefaultPrinterName[0];
    }

    //
    //  If the default printer name saved in RAM does not exist, then we need
    //  to save the one that is saved in the registry, if it exists.
    //
    if (nameToRestore == NULL) {

        BOOL intermediateResult;

        //
        //  Get the user's SID.  This is how we uniquely identify the user.
        //
        pSid = TSNUTL_GetUserSid(UMRPDPPRN_TokenForLoggedOnUser);
        intermediateResult = pSid != NULL;

        //
        //  Get a textual representation of the session user's SID.
        //
        if (intermediateResult) {
            sz = 0;
            intermediateResult = TSNUTL_GetTextualSid(pSid, NULL, &sz);
            ASSERT(!intermediateResult);
            if (!intermediateResult && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
                sidAsText = (WCHAR *)ALLOCMEM(sz);
                if (sidAsText != NULL) {
                    intermediateResult = TSNUTL_GetTextualSid(pSid, sidAsText, &sz);
                }
            }
        }

        //
        //  Open the reg key.
        //
        if (intermediateResult) {
            status = RegCreateKey(
                                HKEY_LOCAL_MACHINE, USERDEFAULTPRNREGKEY,
                                &regKey
                                );
            intermediateResult = status == ERROR_SUCCESS;
            if (!intermediateResult) {
                DBGMSG(DBG_ERROR, ("UMRDPPRN:  RegCreateKey failed for %s:  %ld.\n",
                        USERDEFAULTPRNREGKEY, status));
            }
        }

        //
        //  Read the value.
        //
        if (intermediateResult) {
            DWORD type;
            DWORD sz = sizeof(savedDefaultPrinter);
            status = RegQueryValueEx(
                            regKey, sidAsText, 0,
                            &type, (PBYTE)savedDefaultPrinter, &sz
                            );
            if (status == ERROR_SUCCESS) {
                intermediateResult = TRUE;
                ASSERT(type == REG_SZ);
                nameToRestore = savedDefaultPrinter;
            }
        }

        //
        //  If we got a value, then that means we will be restoring the
        //  one from the registry.  That also means that we should whack the
        //  registry value to be a good citizen.
        //
        if (intermediateResult) {
            status = RegDeleteValue(regKey, sidAsText);
            if (status != ERROR_SUCCESS) {
                DBGMSG(DBG_ERROR, ("UMRDPPRN:  Can't delete reg value %s:  %ld\n",
                        sidAsText, status));
            }
        }
    }

    //
    //  If we have a name to restore, then do so.
    //
    if (nameToRestore != NULL) {
        
        BOOL fImpersonated = FALSE;
        
        //
        //impersonate before setting the default printer as the api
        //accesses hkcu. If the impersonation fails, the api will fail
        //and we will log an error. But, before logging an error, we will
        //need to revert to self.
        //
        if (!(fImpersonated = ImpersonateLoggedOnUser(UMRPDPPRN_TokenForLoggedOnUser))) {
            DBGMSG(DBG_TRACE, ("UMRDPDR:ImpersonateLoggedOnUser failed. Error:%ld.\n", GetLastError()));
        }

        result = SetDefaultPrinter(nameToRestore);

        //
        //if revert to self fails, consider it fatal
        //
        if (fImpersonated && !RevertToSelf()) {
            DBGMSG(DBG_TRACE, ("UMRDPDR:RevertToSelf failed. Error:%ld.\n", GetLastError()));
            result = FALSE;
        }


        if (!result) {
            WCHAR * param = nameToRestore;
            TsLogError(EVENT_NOTIFY_SETDEFAULTPRINTER_FAILED,
                EVENTLOG_ERROR_TYPE,
                1,
                &param,
                __LINE__);
        }
    }

    //
    //  If we don't have a name to restore of the restore failed, then
    //  just restore the first printer we find.
    //
    if (nameToRestore == NULL) {

        //
        //  If we still don't have a printer name to restore, then we should
        //  just restore the first printer we find.
        //
        result = SetDefaultPrinterToFirstFound(TRUE);
    }

    //
    //  Clean up.
    //
    if (sidAsText != NULL) FREEMEM(sidAsText);
    if (regKey != NULL)    RegCloseKey(regKey);
    if (pSid != NULL)      FREEMEM(pSid);

    DBGMSG(DBG_TRACE, ("UMRDPPRN: RestoreDefaultPrinterContext exiting.\n"));

    return result;
}


BOOL SplitName(
    IN OUT LPTSTR pszFullName,
       OUT LPCTSTR *ppszServer,
       OUT LPCTSTR *ppszPrinter,
    IN     BOOL    bCheckDoubleSlash)

/*++

    Splits a fully qualified printer connection name into server and
    printer name parts. If the function fails then none of the OUT
    parameters are modified.

Arguments:

    pszFullName - Input name of a printer.  If it is a printer
        connection (\\server\printer), then we will split it.

    ppszServer - Receives pointer to the server string.

    ppszPrinter - Receives a pointer to the printer string.

    bCheckDoubleSlash - if TRUE check that the name begins with "\\".
        If FALSE, the first character is the first character of the server.

Return Value: TRUE if everything is found as expected. FALSE otherwise.

--*/

{
    LPTSTR pszPrinter;
    LPTSTR pszTmp;

    if (bCheckDoubleSlash) {

        if (pszFullName[0] == TEXT('!') && pszFullName[1] == TEXT('!')) {

            pszTmp = pszFullName + 2;

        } else {

            return FALSE;
        }

    } else {

        pszTmp = pszFullName;
    }

    pszPrinter = wcschr(pszTmp, TEXT('!'));

    if (pszPrinter)
    {
        //
        // We found the backslash; null terminate the previous
        // name.
        //
        *pszPrinter++ = 0;

        *ppszServer = pszTmp;
        *ppszPrinter = pszPrinter;

        return TRUE;
    }

    return FALSE;
}

void FormatPrinterName(
    PWSTR pszNewNameBuf,
    ULONG ulBufLen,
    ULONG ulFlags,
    PTS_PRINTER_NAMES pPrinterNames)
{

    WCHAR   szSessionId[MAXSESSIONIDCHARS];
    PWSTR   pszRet  = NULL;
    PWSTR   pszFormat;
    DWORD   dwBytes = 0;
    const WCHAR * pStrings[4];

    lstrcpyn(pPrinterNames->szTemp, pPrinterNames->pszFullName, pPrinterNames->ulTempLen);

    // TS and network printer: \\Server\Client\Printer
    // non TS network printer: \\Server\Printer
    // TS non network printer: \\Client\Printer

    if (ulFlags & RDPDR_PRINTER_ANNOUNCE_FLAG_NETWORKPRINTER) {

        if (SplitName(pPrinterNames->szTemp,
                      &(pPrinterNames->pszServer),
                      &(pPrinterNames->pszPrinter),
                      TRUE)) {

            // We found a Server name, in any case we'll have
            // something like "Printer on Server (from...)".
            pszFormat = g_szOnFromFormat;

            if (ulFlags & RDPDR_PRINTER_ANNOUNCE_FLAG_TSPRINTER ) {

                if(!SplitName((PWSTR)(pPrinterNames->pszPrinter),
                              &(pPrinterNames->pszClient),
                              &(pPrinterNames->pszPrinter),
                              FALSE)) {

                    // The original client name could not be found,
                    // use the curent one.
                    pPrinterNames->pszClient = pPrinterNames->pszCurrentClient;
                }

            } else {

                pPrinterNames->pszClient = pPrinterNames->pszCurrentClient;
            }

        } else {

            // The name of the server could not be found!
            // Use the original name.
            pszFormat = g_szFromFormat;
            pPrinterNames->pszPrinter = pPrinterNames->pszFullName;
            pPrinterNames->pszClient = pPrinterNames->pszCurrentClient;
        }

    } else {

        // It's not a network printer, so we'll have
        // something like "Printer (from Client)".
        pszFormat = g_szFromFormat;

        if (ulFlags & RDPDR_PRINTER_ANNOUNCE_FLAG_TSPRINTER ) {

            if(!SplitName(pPrinterNames->szTemp,
                          &(pPrinterNames->pszClient),
                          &(pPrinterNames->pszPrinter),
                          TRUE)) {

                pPrinterNames->pszPrinter = pPrinterNames->pszFullName;
                pPrinterNames->pszClient = pPrinterNames->pszCurrentClient;
            }

        } else {

            pPrinterNames->pszPrinter = pPrinterNames->pszFullName;
            pPrinterNames->pszClient = pPrinterNames->pszCurrentClient;
        }
    }


    pStrings[0] = pPrinterNames->pszPrinter;
    pStrings[1] = pPrinterNames->pszServer;
    pStrings[2] = pPrinterNames->pszClient;

    if (g_fIsPTS) {
        pStrings[3] = NULL;
    } else {
        wsprintf(szSessionId, L"%ld", GETTHESESSIONID());
        pStrings[3] = szSessionId;
    }


    if (*pszFormat) {
        DBGMSG(DBG_TRACE, ("UMRDPPRN:formating %ws, %ws and %ws\n", pStrings[0], pStrings[1],
            pStrings[2]?pStrings[2]:L""));

        dwBytes = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                                FORMAT_MESSAGE_FROM_STRING |
                                FORMAT_MESSAGE_ARGUMENT_ARRAY,
                                pszFormat,
                                0,
                                0,
                                (LPTSTR)&pszRet,
                                0,
                                (va_list*)pStrings);

        DBGMSG(DBG_TRACE, ("UMRDPPRN:formated %ws\n", pszRet));
    }

    //
    // Copy the new name.
    //
    if ( dwBytes && pszRet ) {
        wcsncpy(pszNewNameBuf, pszRet, ulBufLen);
    } else {
        wcsncpy(pszNewNameBuf, pPrinterNames->pszFullName, ulBufLen);
    }

    pszNewNameBuf[ulBufLen] = L'\0';

    //
    // Release the formated string.
    //
    if( pszRet ) {
        LocalFree(pszRet);
    }
}