windows-server-2003/printscan/print/spooler/spoolss/dll/printer.c

/*++

Copyright (c) 1990-1994  Microsoft Corporation
All rights reserved

Module Name:

    printer.c

Abstract:


Author:

Environment:

    User Mode -Win32

Revision History:
    KhaledS - 03/05/02 - New Validate Printer Name

--*/

#include "precomp.h"
#pragma hdrstop

#include "local.h"
#include "clusrout.h"
#include <offsets.h>


WCHAR szNoCache[] = L",NoCache";
WCHAR szProvidorValue[] = L"Provider";
WCHAR szRegistryConnections[] = L"Printers\\Connections";
WCHAR szServerValue[] = L"Server";

WCHAR szWin32spl[] = L"win32spl.dll";


//
// Router Cache Table
//
DWORD RouterCacheSize;

PROUTERCACHE RouterCacheTable;
CRITICAL_SECTION RouterCriticalSection;


//
// Forward prototypes
//

BOOL
EnumerateConnectedPrinters(
    LPBYTE  pPrinter,
    DWORD   cbBuf,
    LPDWORD pcbNeeded,
    LPDWORD pcReturned,
    HKEY hKeyUser);

PPRINTER_INFO_2
pGetPrinterInfo2(
    HANDLE hPrinter
    );

BOOL
SavePrinterConnectionInRegistry(
    PPRINTER_INFO_2 pPrinterInfo2,
    LPPROVIDOR pProvidor
    );

BOOL
RemovePrinterConnectionInRegistry(
    LPWSTR pName);

DWORD
FindClosePrinterChangeNotificationWorker(
    HANDLE hPrinter);

VOID
RundownPrinterNotify(
    HANDLE hNotify);



BOOL
EnumPrintersW(
    DWORD   Flags,
    LPWSTR  Name,
    DWORD   Level,
    LPBYTE  pPrinterEnum,
    DWORD   cbBuf,
    LPDWORD pcbNeeded,
    LPDWORD pcReturned)
{
    DWORD   cReturned, cbStruct, cbNeeded;
    DWORD   TotalcbNeeded = 0;
    DWORD   cTotalReturned = 0;
    DWORD   Error = ERROR_SUCCESS;
    PROVIDOR *pProvidor;
    DWORD   BufferSize=cbBuf;
    HKEY    hKeyUser;
    BOOL    bPartialSuccess = FALSE;

    if (pPrinterEnum==NULL && cbBuf!=0) 
    {
        SetLastError(ERROR_INVALID_USER_BUFFER);
        return FALSE;
    }

    WaitForSpoolerInitialization();

    switch (Level)
    {
    case STRESSINFOLEVEL:
        cbStruct = sizeof(PRINTER_INFO_STRESS);
        break;

    case 1:
        cbStruct = sizeof(PRINTER_INFO_1);
        break;

    case 2:
        cbStruct = sizeof(PRINTER_INFO_2);
        break;

    case 4:
        cbStruct = sizeof(PRINTER_INFO_4);
        break;

    case 5:
        cbStruct = sizeof(PRINTER_INFO_5);
        break;

    default:
        SetLastError(ERROR_INVALID_LEVEL);
        return FALSE;
    }

    if (Level==4 && (Flags & PRINTER_ENUM_CONNECTIONS)) 
    {
        //
        // The router will handle info level_4 for connected printers.
        //
        Flags &= ~PRINTER_ENUM_CONNECTIONS;

        if (hKeyUser = GetClientUserHandle(KEY_READ)) 
        {
            if (!EnumerateConnectedPrinters(pPrinterEnum,
                                            BufferSize,
                                            &TotalcbNeeded,
                                            &cTotalReturned,
                                            hKeyUser)) 
            {
                Error = GetLastError();
            } 
            else 
            {
                bPartialSuccess = TRUE;
            }

            RegCloseKey(hKeyUser);

        } 
        else 
        {
            Error = GetLastError();
        }

        pPrinterEnum += cTotalReturned * cbStruct;

        if (TotalcbNeeded <= BufferSize)
            BufferSize -= TotalcbNeeded;
        else
            BufferSize = 0;
    }
    
    for (pProvidor = pLocalProvidor; pProvidor; ) 
    {
        cReturned = 0;
        cbNeeded  = 0;

        if (!(*pProvidor->PrintProvidor.fpEnumPrinters) (Flags, Name, Level,
                                                         pPrinterEnum,
                                                         BufferSize,
                                                         &cbNeeded,
                                                         &cReturned)) 
        {
            Error = GetLastError();

            if (Error==ERROR_INSUFFICIENT_BUFFER) 
            {
                TotalcbNeeded += cbNeeded;
                BufferSize     = 0;
            }            
        } 
        else 
        {
            bPartialSuccess  = TRUE;
            TotalcbNeeded   += cbNeeded;
            cTotalReturned  += cReturned;
            pPrinterEnum    += cReturned * cbStruct;
            BufferSize      -= cbNeeded;
        }
        
        if ((Flags & PRINTER_ENUM_NAME) && Name && (Error!=ERROR_INVALID_NAME))
            pProvidor = NULL;
        else
            pProvidor = pProvidor->pNext;
    }

    *pcbNeeded  = TotalcbNeeded;
    *pcReturned = cTotalReturned;

    //
    // Allow partial returns
    //
    if (bPartialSuccess)
        Error = ERROR_SUCCESS;

    if (TotalcbNeeded > cbBuf)
        Error = ERROR_INSUFFICIENT_BUFFER;

    SetLastError(Error);

    return Error==ERROR_SUCCESS;   
}

BOOL
EnumerateConnectedPrinters(
    LPBYTE  pPrinter,
    DWORD   cbBuf,
    LPDWORD pcbNeeded,
    LPDWORD pcReturned,
    HKEY hClientKey
    )

/*++

Routine Description:

    Handles info level four enumeration.

Arguments:

Return Value:

--*/

{
    HKEY    hKey1=NULL;
    HKEY    hKeyPrinter;
    DWORD   cPrinters, cchData;
    WCHAR   PrinterName[MAX_UNC_PRINTER_NAME];
    WCHAR   ServerName[MAX_UNC_PRINTER_NAME];
    DWORD   cReturned, cbRequired, cbNeeded, cTotalReturned;
    DWORD   Error=0;
    PWCHAR  p;
    LPBYTE  pEnd;

    DWORD cbSize;
    BOOL  bInsufficientBuffer = FALSE;

    if((Error = RegOpenKeyEx(hClientKey, szRegistryConnections, 0,
                 KEY_READ, &hKey1))!=ERROR_SUCCESS)
    {
        SetLastError(Error);
        return(FALSE);
    }

    cPrinters=0;

    cchData = COUNTOF(PrinterName);

    cTotalReturned = 0;

    cReturned = cbNeeded = 0;

    cbRequired = 0;

    pEnd = pPrinter + cbBuf;
    while (RegEnumKeyEx(hKey1, cPrinters, PrinterName, &cchData,
                        NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {

        //
        // Fetch server name.  Open the key and read it
        // from the "Server" field.
        //
        Error = RegOpenKeyEx(hKey1,
                             PrinterName,
                             0,
                             KEY_READ,
                             &hKeyPrinter);

        if( Error == ERROR_SUCCESS ){

            cbSize = sizeof(ServerName);

            Error = RegQueryValueEx(hKeyPrinter,
                                    szServerValue,
                                    NULL,
                                    NULL,
                                    (LPBYTE)ServerName,
                                    &cbSize);

            RegCloseKey(hKeyPrinter);

        }

        if( Error == ERROR_SUCCESS ){

            //
            // Force NULL termination of ServerName.
            //
            ServerName[COUNTOF(ServerName)-1] = 0;

        } else {

            //
            // On error condition, try and extract the server name
            // based on the printer name.  Pretty ugly...
            //

            StringCchCopy(ServerName, COUNTOF(ServerName), PrinterName);

            p = wcschr(ServerName+2, ',');
            if (p)
                *p = 0;
        }

        FormatRegistryKeyForPrinter(PrinterName, PrinterName, COUNTOF(PrinterName));

        if (MyUNCName(PrinterName))     // don't enumerate local printers!
        {
            cPrinters++;
            cchData = COUNTOF(PrinterName);
            continue;
        }

        //
        // At this stage we don't care about opening the printers
        // We just want to enumerate the names; in effect we're
        // just reading HKEY_CURRENT_USER and returning the
        // contents; we will copy the name of the printer and we will
        // set its attributes to NETWORK and !LOCAL
        //
        cbRequired = sizeof(PRINTER_INFO_4) +
                     wcslen(PrinterName)*sizeof(WCHAR) + sizeof(WCHAR) +
                     wcslen(ServerName)*sizeof(WCHAR) + sizeof(WCHAR);

        if (cbBuf >= cbRequired) {

            //
            // copy it in
            //
            DBGMSG(DBG_TRACE,
                   ("cbBuf %d cbRequired %d PrinterName %ws\n", cbBuf, cbRequired, PrinterName));

            pEnd = CopyPrinterNameToPrinterInfo4(ServerName,
                                                 PrinterName,
                                                 pPrinter,
                                                 pEnd);
            //
            // Fill in any in structure contents
            //
            pPrinter += sizeof(PRINTER_INFO_4);

            //
            // Increment the count of structures copied
            //
            cTotalReturned++;

            //
            // Reduce the size of the buffer by amount required
            //
            cbBuf -= cbRequired;

            //
            // Keep track of the total ammount required.
            //
        } else {

            cbBuf = 0;
            bInsufficientBuffer = TRUE;
        }

        cbNeeded += cbRequired;
        cPrinters++;
        cchData = COUNTOF(PrinterName);
    }

    RegCloseKey(hKey1);

    *pcbNeeded = cbNeeded;
    *pcReturned = cTotalReturned;

    if (bInsufficientBuffer) {

        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }

    return TRUE;
}

LPBYTE
CopyPrinterNameToPrinterInfo4(
    LPWSTR pServerName,
    LPWSTR pPrinterName,
    LPBYTE  pPrinter,
    LPBYTE  pEnd)
{
    LPWSTR   SourceStrings[sizeof(PRINTER_INFO_4)/sizeof(LPWSTR)];
    LPWSTR   *pSourceStrings=SourceStrings;
    LPPRINTER_INFO_4 pPrinterInfo=(LPPRINTER_INFO_4)pPrinter;
    DWORD   *pOffsets;

    pOffsets = PrinterInfo4Strings;

    *pSourceStrings++=pPrinterName;
    *pSourceStrings++=pServerName;

    pEnd = PackStrings(SourceStrings,
                       (LPBYTE) pPrinterInfo,
                       pOffsets,
                       pEnd);

    pPrinterInfo->Attributes = PRINTER_ATTRIBUTE_NETWORK;

    return pEnd;
}

LPPROVIDOR
FindProvidorFromConnection(
    LPWSTR pszPrinter
    )

/*++

Routine Description:

    Looks in the current user's Printer\Connections to see if a printer
    is there, and returns which provider that owns it.

    Note: this will always fail if the pszPrinter is a share name.

Arguments:

    pszPrinter - Printer to search.

Return Value:

    pProvidor - Provider that own's it.
    NULL - none found.

--*/

{
    PWCHAR pszKey = NULL;
    DWORD  cchSize = MAX_UNC_PRINTER_NAME + COUNTOF( szRegistryConnections );

    WCHAR szProvidor[MAX_PATH];
    DWORD cbProvidor;
    LPWSTR pszKeyPrinter;
    LONG Status;

    LPPROVIDOR pProvidor = NULL;

    HKEY hKeyClient = NULL;
    HKEY hKeyPrinter = NULL;

    SPLASSERT(pszPrinter);

    if ( pszPrinter && wcslen(pszPrinter) + 1 < MAX_UNC_PRINTER_NAME ) {
        
        if(pszKey = AllocSplMem(cchSize * sizeof(WCHAR))) {

            //
            // Prepare to read in
            // HKEY_CURRENT_USER:\Printer\Connections\,,server,printer
            //

            StringCchCopy( pszKey, cchSize, szRegistryConnections );

            //
            // Find the end of this key so we can append the registry-formatted
            // printer name to it.
            //
            pszKeyPrinter = &pszKey[ COUNTOF( szRegistryConnections ) - 1 ];
            *pszKeyPrinter++ = L'\\';

            FormatPrinterForRegistryKey( pszPrinter, 
                                         pszKeyPrinter, 
                                         cchSize - COUNTOF( szRegistryConnections ) - 1 - 1);

            if( hKeyClient = GetClientUserHandle(KEY_READ)){

                Status = RegOpenKeyEx( hKeyClient,
                                       pszKey,
                                       0,
                                       KEY_READ,
                                       &hKeyPrinter );

                if( Status == ERROR_SUCCESS ){
                    
                    cbProvidor = sizeof( szProvidor );

                    Status = RegQueryValueEx( hKeyPrinter,
                                              szProvidorValue,
                                              NULL,
                                              NULL,
                                              (LPBYTE)szProvidor,
                                              &cbProvidor );

                    if( Status == ERROR_SUCCESS ){                        
                        //
                        // Scan through all providers, trying to match dll string.
                        //
                        for( pProvidor = pLocalProvidor; pProvidor; pProvidor = pProvidor->pNext ){

                            if( !_wcsicmp( pProvidor->lpName, szProvidor )){
                                break;
                            }
                        } 
                    }

                    RegCloseKey( hKeyPrinter );
                }
                
                RegCloseKey( hKeyClient );

            }
            FreeSplMem(pszKey);
        }        
    }

    return pProvidor;
}


VOID
UpdateSignificantError(
    DWORD dwNewError,
    PDWORD pdwOldError
    )
/*++

Routine Description:

    Determines whether the new error code is more "important"
    than the previous one in cases where we continue routing.

Arguments:

    dwNewError - New error code that occurred.

    pdwOldError - Pointer to previous significant error.
                  This is updated if a significant error occurs

Return Value:

--*/

{
    //
    // Error code must be non-zero or else it will look
    // like success.
    //
    SPLASSERT(dwNewError);

    //
    // If we have no significant error yet and we have one now,
    // keep it.
    //
    if (*pdwOldError == ERROR_INVALID_NAME    &&
        dwNewError                            &&
        dwNewError != WN_BAD_NETNAME          &&
        dwNewError != ERROR_BAD_NETPATH       &&
        dwNewError != ERROR_NOT_SUPPORTED     &&
        dwNewError != ERROR_REM_NOT_LIST      &&
        dwNewError != ERROR_INVALID_LEVEL     &&
        dwNewError != ERROR_INVALID_PARAMETER &&
        dwNewError != ERROR_INVALID_NAME      &&
        dwNewError != WN_BAD_LOCALNAME) {

        *pdwOldError = dwNewError;
    }

    return;
}


BOOL
OpenPrinterPortW(
    LPWSTR  pPrinterName,
    HANDLE *pHandle,
    LPPRINTER_DEFAULTS pDefault
    )
/*++

Routine Description:

    This routine is exactly the same as OpenPrinterW,
    except that it doesn't call the local provider.
    This is so that the local provider can open a network printer
    with the same name as the local printer without getting
    into a loop.

Arguments:

Return Value:

--*/

{
    //
    // We will set bLocalPrintProvidor = FALSE here
    //
    return(RouterOpenPrinterW(pPrinterName,
                              pHandle,
                              pDefault,
                              NULL,
                              0,
                              FALSE));
}

BOOL
OpenPrinterW(
    LPWSTR              pPrinterName,
    HANDLE             *pHandle,
    LPPRINTER_DEFAULTS  pDefault
    )
{

    //
    // We will set bLocalPrintProvidor = TRUE here
    //
    return(RouterOpenPrinterW(pPrinterName,
                              pHandle,
                              pDefault,
                              NULL,
                              0,
                              TRUE));
}


BOOL
OpenPrinterExW(
    LPWSTR                  pPrinterName,
    HANDLE                 *pHandle,
    LPPRINTER_DEFAULTS      pDefault,
    PSPLCLIENT_CONTAINER    pSplClientContainer
    )
{
    BOOL   bReturn = FALSE;
    DWORD  dwLevel = 0;

    if (pSplClientContainer) {
        dwLevel = pSplClientContainer->Level;
    }

    //
    // We will set bLocalPrintProvidor = TRUE here
    //

    switch (dwLevel) {

    case 1:
             bReturn = RouterOpenPrinterW(pPrinterName,
                                          pHandle,
                                          pDefault,
                                          (LPBYTE) (pSplClientContainer->ClientInfo.pClientInfo1),
                                          1,
                                          TRUE);
             break;

    case 2:
             bReturn = RouterOpenPrinterW(pPrinterName,
                                          pHandle,
                                          pDefault,
                                          NULL,
                                          0,
                                          TRUE);

             if (pSplClientContainer) {
                 if (bReturn) {
                     pSplClientContainer->ClientInfo.pClientInfo2->hSplPrinter = (ULONG_PTR) *pHandle;
                 } else {
                     pSplClientContainer->ClientInfo.pClientInfo2->hSplPrinter = 0;
                 }
             }

             break;

    default:
             break;
    }

    return bReturn;
}


DWORD
TryOpenPrinterAndCache(
    LPPROVIDOR          pProvidor,
    LPWSTR              pszPrinterName,
    PHANDLE             phPrinter,
    LPPRINTER_DEFAULTS  pDefault,
    PDWORD              pdwFirstSignificantError,
    LPBYTE              pSplClientInfo,
    DWORD               dwLevel
    )

/*++

Routine Description:

    Attempt to open the printer using the providor.  If there is
    an error, update the dwFirstSignificantError variable.  If the
    providor "knows" the printer (either a success, or ROUTER_STOP_ROUTING),
    then update the cache.

Arguments:

    pProvidor - Providor to try

    pszPrinterName - Name of printer that will be sent to the providor

    phPrinter - Receives printer handle on ROUTER_SUCCESS

    pDefault - Defaults used to open printer

    pdwFirstSignificantError - Pointer to DWORD to get updated error.
        This gets updated on ROUTER_STOP_ROUTING or ROUTER_UNKNOWN.

Return Value:

    ROUTER_* status code:

    ROUTER_SUCCESS, phPrinter holds return handle, name cached
    ROUTER_UNKNOWN, printer not recognized, error updated
    ROUTER_STOP_ROUTING, printer recognized, but failure, error updated

--*/

{
    DWORD OpenError;

    OpenError = (*pProvidor->PrintProvidor.fpOpenPrinterEx)
                                        (pszPrinterName,
                                         phPrinter,
                                         pDefault,
                                         pSplClientInfo,
                                         dwLevel);

    if (( OpenError == ROUTER_UNKNOWN && GetLastError() == ERROR_NOT_SUPPORTED ) ||
        OpenError == ERROR_NOT_SUPPORTED )

        OpenError = (*pProvidor->PrintProvidor.fpOpenPrinter)
                                        (pszPrinterName,
                                         phPrinter,
                                         pDefault);

    if( OpenError == ROUTER_SUCCESS ||
        OpenError == ROUTER_STOP_ROUTING ){

        //
        // Now add this entry into the cache.  We never cache
        // the local providor.
        //
        EnterRouterSem();

        if (!FindEntryinRouterCache(pszPrinterName)) {
            AddEntrytoRouterCache(pszPrinterName, pProvidor);
        }

        LeaveRouterSem();
    }

    if( OpenError != ROUTER_SUCCESS ){
        UpdateSignificantError(GetLastError(), pdwFirstSignificantError);
    }

    return OpenError;
}

BOOL
RouterOpenPrinterW(
    LPWSTR              pszPrinterNameIn,
    HANDLE             *pHandle,
    LPPRINTER_DEFAULTS  pDefault,
    LPBYTE              pSplClientInfo,
    DWORD               dwLevel,
    BOOL                bLocalProvidor
    )

/*++

Routine Description:

    Routes the OpenPrinter{Port} call.  This checks the local providor
    first (if bLocalProvidor TRUE), the the cache, and finally all the
    non-local providors.

    To open a printer, the following steps are taken:

        1. Check localspl
           This must be done to ensure that masq printers are handled
           correctly (see comment below in code).

        2. Check cache
           This will speed up most of the connections, since OpenPrinters
           tend to be clumped together.

        3. Check registry under connections
           If this is a connected printer, first try the providor
           that granted the connection.

        4. Check provider order
           This is the last resort, since it is the slowest.

Arguments:

    pPrinterName - Name of printer to open

    pHandle - Handle to receive open printer.  If the open was not
        successful, this value may be modified!

    pDefault - Default attributes of the open.

    pSplClientInfo - Pointer ClientInfox structure

    dwLevel - Level of the ClientInfo structure
    bLocalProvidor TRUE  = OpenPrinterW called, check localspl first.
                   FALSE = OpenPrinterPortW called, don't check localspl.

Return Value:

    TRUE = success
    FALSE = fail,  GetLastError indicates error (must be non-zero!)

--*/

{
    BOOL bReturn = TRUE;
    DWORD dwFirstSignificantError = ERROR_INVALID_NAME;
    LPPROVIDOR  pProvidor;
    LPPROVIDOR  pProvidorAlreadyTried = NULL;
    PPRINTHANDLE pPrintHandle;
    HANDLE  hPrinter;
    DWORD OpenError;
    BOOL bRemoveFromCache = FALSE;
    PRINTER_DEFAULTS Default;
    PDEVMODE pDevModeFree = NULL;
    PWSTR pszPrinterName = pszPrinterNameIn;
    PWSTR pszNoCache;

    //
    // Max name we allow for printers is MAX_UNC_PRINTER_NAME.
    // Providers can use suffixes only for OpenPrinter (not for Add/Set)
    //
    if ( pszPrinterName &&
         wcslen(pszPrinterName) + 1 > MAX_UNC_PRINTER_NAME + PRINTER_NAME_SUFFIX_MAX ) {

        SetLastError(ERROR_INVALID_PRINTER_NAME);
        return FALSE;
    }

    WaitForSpoolerInitialization();

    // There may be a ",NoCache" appended to the printer name.
    // We only want to send this NoCache name to win32spl, so make
    // a regular name here.
    if (pszPrinterName) {
        pszNoCache = wcsstr(pszPrinterNameIn, szNoCache);
        if (pszNoCache) {
            pszPrinterName = AllocSplStr(pszPrinterNameIn);

            if (!pszPrinterName) {
                DBGMSG(DBG_WARNING, ("RouterOpenPrinter - Failed to alloc pszPrinterName.\n"));
                return FALSE;
            }
            pszPrinterName[pszNoCache - pszPrinterNameIn] = L'\0';
        }
    }

    pPrintHandle = AllocSplMem(sizeof(PRINTHANDLE));

    if (!pPrintHandle) {

        DBGMSG(DBG_WARNING, ("RouterOpenPrinter - Failed to alloc print handle.\n"));

        if (pszPrinterName != pszPrinterNameIn) {
            FreeSplStr(pszPrinterName);
            pszPrinterName = pszPrinterNameIn;
        }
        return FALSE;
    }

    //
    // Initialize all of the static values here, this is because 
    // FreePrinterHandle assumes that the file handles have a 
    // value of INVALID_HANDLE_VALUE. Which is correct.
    //
    pPrintHandle->signature = PRINTHANDLE_SIGNATURE;
    pPrintHandle->hFileSpooler = INVALID_HANDLE_VALUE;
    pPrintHandle->szTempSpoolFile = NULL;
    pPrintHandle->dwUniqueSessionID = 0;

    if( pszPrinterName ){
        pPrintHandle->pszPrinter = AllocSplStr( pszPrinterName );

        if (!pPrintHandle->pszPrinter) {

            DBGMSG(DBG_WARNING, ("RouterOpenPrinter - Failed to alloc print name.\n"));

            if (pszPrinterName != pszPrinterNameIn) {
                FreeSplStr(pszPrinterName);
                pszPrinterName = pszPrinterNameIn;
            }

            FreePrinterHandle( pPrintHandle );
            return FALSE;
        }
    }

    //
    // Retrieve the per-user DevMode.  This must be done at the router
    // instead of the provider, since the per-user DevMode is only available
    // on the client.  It also must be here instead of client side, since
    // spooler components will make this call also.
    //
    if( !pDefault || !pDefault->pDevMode ){

        //
        // No default specified--get the per-user one.
        //
        if( bGetDevModePerUser( NULL, pszPrinterName, &pDevModeFree ) &&
            pDevModeFree ){

            if( pDefault ){

                Default.pDatatype = pDefault->pDatatype;
                Default.DesiredAccess = pDefault->DesiredAccess;

            } else {

                Default.pDatatype = NULL;
                Default.DesiredAccess = 0;

            }

            Default.pDevMode = pDevModeFree;

            //
            // Now switch to use the temp structure.
            //
            pDefault = &Default;
        }
    }

    //
    // We must check the local print providor first in
    // the masquerading case.
    //
    // For example, when a Netware printer is opened:
    //
    // 1. First OpenPrinter to the Netware printer will succeed
    //    if it has been cached.
    //
    // 2. We create a local printer masquerading as a network printer.
    //
    // 3. Second OpenPrinter must open local masquerading printer.
    //    If we hit the cache, we will go to the Netware providor,
    //    and we will never use the masquerading printer.
    //
    // For this reason, we will not cache local printers in the
    // RouterCache.  The RouterCache will only containing Network
    // Print Providers, i.e., Win32spl NwProvAu and other such providers.
    //
    // Also, we must always check the local printprovidor since
    // DeletePrinter will be called on a false connect and
    // we need to delete the local network printer rather
    // than the remote printer.  When we get rid of the false
    // connect case, we go directly to the cache.
    //
    if (bLocalProvidor) {

        pProvidor = pLocalProvidor;

        OpenError = (*pProvidor->PrintProvidor.fpOpenPrinterEx)
                        (pszPrinterName, &hPrinter, pDefault,
                         pSplClientInfo, dwLevel);

        if (OpenError == ROUTER_SUCCESS) {
            goto Success;
        }

        UpdateSignificantError(GetLastError(), &dwFirstSignificantError);

        if (OpenError == ROUTER_STOP_ROUTING) {
            goto StopRouting;
        }
    }

    //
    // Now check the cache.
    //
    EnterRouterSem();
    pProvidor = FindEntryinRouterCache(pszPrinterName);
    LeaveRouterSem();

    if (pProvidor) {

        OpenError = (*pProvidor->PrintProvidor.fpOpenPrinterEx)
                                (pszPrinterName,
                                 &hPrinter,
                                 pDefault,
                                 pSplClientInfo,
                                 dwLevel);

        if (( OpenError == ROUTER_UNKNOWN && GetLastError() == ERROR_NOT_SUPPORTED ) ||
              OpenError == ERROR_NOT_SUPPORTED ){

            OpenError = (*pProvidor->PrintProvidor.fpOpenPrinter)
                                (pszPrinterName,
                                 &hPrinter,
                                 pDefault);
        }

        if (OpenError == ROUTER_SUCCESS) {
            goto Success;
        }

        UpdateSignificantError(GetLastError(), &dwFirstSignificantError);

        if (OpenError == ROUTER_STOP_ROUTING) {
            goto StopRouting;
        }

        //
        // Wasn't claimed by above providor, so remove from cache.
        // If a providor returns ROUTER_STOP_ROUTING, then it states
        // that it is the sole owner of the printer name (i.e.,
        // it has been recognized but can't be opened, and can't
        // be accessed by other providors).  Therefore we keep
        // it in the cache.
        //
        bRemoveFromCache = TRUE;

        //
        // Don't try this providor again below.
        //
        pProvidorAlreadyTried = pProvidor;
    }

    //
    // Not in the cache.  Check if it is in the registry under
    // connections.
    //
    pProvidor = FindProvidorFromConnection( pszPrinterName );

    //
    // If we want to remove it from the cache, do so here.  Note
    // we only remove it if we failed above, AND the connection wasn't
    // originally established using the provider.
    //
    // If the connection fails, but that provider "owns" the printer
    // connection, leave it in the cache since we won't try other providers.
    //
    if( bRemoveFromCache && pProvidor != pProvidorAlreadyTried ){

        EnterRouterSem();
        DeleteEntryfromRouterCache(pszPrinterName);
        LeaveRouterSem();
    }

    if( pProvidor ){

        //
        // If we already tried this providor, don't try it again.
        //
        if( pProvidor != pProvidorAlreadyTried ){

            OpenError = TryOpenPrinterAndCache( pProvidor,
                                                pszPrinterName,
                                                &hPrinter,
                                                pDefault,
                                                &dwFirstSignificantError,
                                                pSplClientInfo,
                                                dwLevel);

            if( OpenError == ROUTER_SUCCESS ){
                goto Success;
            }
        }

        //
        // We stop routing at this point!  If a user wants to go with
        // another providor, they need to remove the connection then
        // re-establish it.
        //
        goto StopRouting;
    }

    //
    // Check all non-localspl providors.
    //
    for (pProvidor = pLocalProvidor->pNext;
         pProvidor;
         pProvidor = pProvidor->pNext) {

        if( pProvidor == pProvidorAlreadyTried ){

            //
            // We already tried this providor, and it failed.
            //
            continue;
        }

        // Use ",NoCache" only if Provider is win32spl
        OpenError = TryOpenPrinterAndCache( pProvidor,
                                            _wcsicmp(pProvidor->lpName, szWin32spl) ?
                                            pszPrinterName : pszPrinterNameIn,
                                            &hPrinter,
                                            pDefault,
                                            &dwFirstSignificantError,
                                            pSplClientInfo,
                                            dwLevel);

        switch( OpenError ) {
            case ROUTER_SUCCESS:
                goto Success;
            case ROUTER_STOP_ROUTING:
                goto StopRouting;
        }
    }

StopRouting:

    //
    // Did not find a providor, return the error.
    //
    FreePrinterHandle( pPrintHandle );

    //
    // Set using first significant error.  If there was no signifcant
    // error, we use ERROR_INVALID_PRINTER_NAME.
    //
    SPLASSERT(dwFirstSignificantError);

    if (dwFirstSignificantError == ERROR_INVALID_NAME)
        dwFirstSignificantError = ERROR_INVALID_PRINTER_NAME;

    SetLastError(dwFirstSignificantError);

    bReturn = FALSE;

Success:

    //
    // At this point we know the provider and the printer handle.
    // 
    if( bReturn ){

        pPrintHandle->pProvidor = pProvidor;
        pPrintHandle->hPrinter = hPrinter;

        *pHandle = (HANDLE)pPrintHandle;
    }

    FreeSplMem( pDevModeFree );

    if (pszPrinterName != pszPrinterNameIn)
        FreeSplStr(pszPrinterName);

    return bReturn;
}


BOOL
ResetPrinterW(
    HANDLE  hPrinter,
    LPPRINTER_DEFAULTS pDefault)
{
    LPPRINTHANDLE  pPrintHandle=(LPPRINTHANDLE)hPrinter;

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    if (pDefault) {
        if (pDefault->pDatatype == (LPWSTR)-1 ||
            pDefault->pDevMode == (LPDEVMODE)-1) {

            if (!wcscmp(pPrintHandle->pProvidor->lpName, szLocalSplDll)) {
                return (*pPrintHandle->pProvidor->PrintProvidor.fpResetPrinter)
                                                            (pPrintHandle->hPrinter,
                                                             pDefault);
            } else {
                SetLastError(ERROR_INVALID_PARAMETER);
                return(FALSE);
            }
        } else {
            return (*pPrintHandle->pProvidor->PrintProvidor.fpResetPrinter)
                                                        (pPrintHandle->hPrinter,
                                                         pDefault);
        }
    } else {
        return (*pPrintHandle->pProvidor->PrintProvidor.fpResetPrinter)
                                                    (pPrintHandle->hPrinter,
                                                     pDefault);
    }
}

HANDLE
AddPrinterExW(
    LPWSTR  pName,
    DWORD   Level,
    LPBYTE  pPrinter,
    LPBYTE  pClientInfo,
    DWORD   dwLevel
    )
{
    LPPROVIDOR      pProvidor;
    DWORD           dwFirstSignificantError = ERROR_INVALID_NAME;
    HANDLE          hPrinter;
    PPRINTHANDLE    pPrintHandle;
    LPWSTR          pPrinterName = NULL;
    LPWSTR          pszServer = NULL;

    WaitForSpoolerInitialization();

    if ( pPrinter ) {

        switch ( Level ) {

            case 1:
                pPrinterName = ((PPRINTER_INFO_1)pPrinter)->pName;
                break;

            case 2:
                pPrinterName = ((PPRINTER_INFO_2)pPrinter)->pPrinterName;
                pszServer = ((PPRINTER_INFO_2)pPrinter)->pServerName;
                break;

            default:
                break;
        }

        //
        // Name length (plus null terminator) and server
        // name (plus backslash) length check.
        //
        if (( pPrinterName && wcslen(pPrinterName) + 1 > MAX_PRINTER_NAME ) ||
            ( pszServer && wcslen(pszServer) > (MAX_UNC_PRINTER_NAME - MAX_PRINTER_NAME - 1))) {

            SetLastError(ERROR_INVALID_PRINTER_NAME);
            return FALSE;
        }
    }

    pPrintHandle = AllocSplMem(sizeof(PRINTHANDLE));

    if (!pPrintHandle) {

        DBGMSG( DBG_WARNING, ("Failed to alloc print handle."));
        goto Fail;
    }

    if( pPrinterName ){

        WCHAR szFullPrinterName[MAX_UNC_PRINTER_NAME];
        szFullPrinterName[0] = 0;

        if( pszServer ){
            StrNCatBuff(szFullPrinterName,
                        MAX_UNC_PRINTER_NAME,
                        pszServer,
                        L"\\",
                        NULL);
        }

        StringCchCat( szFullPrinterName, 
                      MAX_UNC_PRINTER_NAME,
                      pPrinterName );

        pPrintHandle->pszPrinter = AllocSplStr( szFullPrinterName );

        if( !pPrintHandle->pszPrinter ){
            goto Fail;
        }
    }

    pProvidor = pLocalProvidor;

    while (pProvidor) {

        hPrinter = (HANDLE)(*pProvidor->PrintProvidor.fpAddPrinterEx)
                                           (pName,
                                            Level,
                                            pPrinter,
                                            pClientInfo,
                                            dwLevel);

        if ( !hPrinter && GetLastError() == ERROR_NOT_SUPPORTED ) {

            hPrinter = (HANDLE)(*pProvidor->PrintProvidor.fpAddPrinter)
                                                   (pName,
                                                    Level,
                                                    pPrinter);
        }

        if ( hPrinter ) {

            //
            // CLS
            //
            // !! HACK !!
            //
            // Make (HANDLE)-1 ROUTER_STOP_ROUTING.
            //
            if( hPrinter == (HANDLE)-1 ){

                UpdateSignificantError(GetLastError(), &dwFirstSignificantError);
                break;
            }

            pPrintHandle->signature = PRINTHANDLE_SIGNATURE;
            pPrintHandle->pProvidor = pProvidor;
            pPrintHandle->hPrinter = hPrinter;
            pPrintHandle->hFileSpooler = INVALID_HANDLE_VALUE;
            pPrintHandle->szTempSpoolFile = NULL;
            pPrintHandle->dwUniqueSessionID = 0;

            return (HANDLE)pPrintHandle;

        }

        UpdateSignificantError(GetLastError(), &dwFirstSignificantError);

        pProvidor = pProvidor->pNext;
    }

    UpdateSignificantError(ERROR_INVALID_PRINTER_NAME, &dwFirstSignificantError);
    SetLastError(dwFirstSignificantError);

Fail:

    if( pPrintHandle ){

        FreeSplStr( pPrintHandle->pszPrinter );
        FreeSplMem(pPrintHandle);
    }

    return FALSE;
}

HANDLE
AddPrinterW(
    LPWSTR  pName,
    DWORD   Level,
    LPBYTE  pPrinter
    )
{

    return AddPrinterExW(pName, Level, pPrinter, NULL, 0);
}


BOOL
DeletePrinter(
    HANDLE  hPrinter
)
{
    LPPRINTHANDLE  pPrintHandle=(LPPRINTHANDLE)hPrinter;

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    return (*pPrintHandle->pProvidor->PrintProvidor.fpDeletePrinter)(pPrintHandle->hPrinter);
}

BOOL
AddPrinterConnectionW(
    LPWSTR  pName
)
{
    DWORD dwLastError;
    HANDLE hPrinter;
    HKEY   hClientKey = NULL;
    BOOL   rc = FALSE;
    LPPRINTER_INFO_2 pPrinterInfo2;
    LPPRINTHANDLE  pPrintHandle;

    WaitForSpoolerInitialization();

    //
    // If the printer connection being made is \\server\sharename,
    // this may be different from the \\server\printername.
    // Make sure we have the real name, so that we can be consistent
    // in the registry.
    //
    if (!OpenPrinter(pName,
                     &hPrinter,
                     NULL)) {

        return FALSE;
    }

    pPrinterInfo2 = pGetPrinterInfo2( hPrinter );
    pPrintHandle = (LPPRINTHANDLE)hPrinter;

    if( pPrinterInfo2 ){

        if ((*pPrintHandle->pProvidor->PrintProvidor.
            fpAddPrinterConnection)(pPrinterInfo2->pPrinterName)) {

            if( SavePrinterConnectionInRegistry(
                pPrinterInfo2,
                pPrintHandle->pProvidor )){

                rc = TRUE;

            } else {

                dwLastError = GetLastError();
                (*pPrintHandle->pProvidor->PrintProvidor.
                    fpDeletePrinterConnection)(pPrinterInfo2->pPrinterName);

                SetLastError(dwLastError);
            }
        }
        FreeSplMem(pPrinterInfo2);
    }

    dwLastError = GetLastError();
    ClosePrinter(hPrinter);
    SetLastError(dwLastError);

    return rc;
}


BOOL
DeletePrinterConnectionW(
    LPWSTR  pName
)
{
    BOOL                bRet  = FALSE;
    BOOL                bDone = FALSE;
    HANDLE              hPrinter;

    //
    // If pName is empty string, all providers will fail with ERROR_INVALID_NAME
    // and we will delete the registry key. For empty string, it will
    // delete all subkeys under Printers\\Connections. Fix it by checking 
    // pName against empty string.
    //
    if (pName && *pName) 
    {
        WaitForSpoolerInitialization();

        //
        // Adding the code required to succeed DeletePrinterConnection
        // with a Share name
        //

        if(OpenPrinter(pName,&hPrinter,NULL))
        {
            DWORD            PrntrInfoSize=0,PrntrInfoSizeReq=0;
            PPRINTER_INFO_2  pPrinterInfo2 = NULL;

            if(!GetPrinter(hPrinter,
                           2,
                           (LPBYTE)pPrinterInfo2,
                           PrntrInfoSize,
                           &PrntrInfoSizeReq)                                                      &&
               (GetLastError() == ERROR_INSUFFICIENT_BUFFER)                                       &&
               (pPrinterInfo2 = (PPRINTER_INFO_2)AllocSplMem((PrntrInfoSize = PrntrInfoSizeReq)))  &&
               GetPrinter(hPrinter,
                          2,
                          (LPBYTE)pPrinterInfo2,
                          PrntrInfoSize,
                          &PrntrInfoSizeReq))
            {
                PPRINTHANDLE pPrintHandle;
                pPrintHandle = (PPRINTHANDLE)hPrinter;

                if((bRet = (*pPrintHandle->
                           pProvidor->
                           PrintProvidor.
                           fpDeletePrinterConnection)(pPrinterInfo2->pPrinterName)))
                {
                    bRet  = RemovePrinterConnectionInRegistry(pPrinterInfo2->pPrinterName);
                    bDone = TRUE;
                }
            }

            if(hPrinter)
                ClosePrinter(hPrinter);

            if(pPrinterInfo2)
                FreeSplMem(pPrinterInfo2);
        }
        else
        {
            LPPROVIDOR pProvidor;
            pProvidor = pLocalProvidor;

            if (pName && (wcslen(pName) < MAX_PRINTER_NAME))
            {
                for(pProvidor=pLocalProvidor;
                    pProvidor && (GetLastError()!=ERROR_INVALID_NAME) &&!bDone;
                    pProvidor = pProvidor->pNext)

                {

                    if(bRet =  (*pProvidor->PrintProvidor.fpDeletePrinterConnection)(pName))
                    {
                        bRet = RemovePrinterConnectionInRegistry(pName);
                        bDone = TRUE;
                    }
                }
            }
            else
            {
                SetLastError(ERROR_INVALID_PRINTER_NAME);
                bDone = TRUE;
            }

        }

        //
        // If all providors failed with ERROR_INVALID_NAME then try to delete
        // from registry
        //
        if(!bDone && (GetLastError()==ERROR_INVALID_NAME))
        {
            if(!(bRet = RemovePrinterConnectionInRegistry(pName)))
            {
                SetLastError(ERROR_INVALID_PRINTER_NAME);
            }
        }
    }
    else
    {
        SetLastError(ERROR_INVALID_PRINTER_NAME);
    }
    
    return bRet;
}

BOOL
SetPrinterW(
    HANDLE  hPrinter,
    DWORD   Level,
    LPBYTE  pPrinter,
    DWORD   Command
)
{
    LPPRINTHANDLE   pPrintHandle=(LPPRINTHANDLE)hPrinter;
    LPWSTR          pPrinterName = NULL;
    PDEVMODE        pDevModeRestore = NULL;
    BOOL bReturn;

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    if ( pPrinter ) {

        switch (Level) {
            case 2:
                pPrinterName = ((PPRINTER_INFO_2)pPrinter)->pPrinterName;
                break;

            case 4:
                pPrinterName = ((PPRINTER_INFO_4)pPrinter)->pPrinterName;
                break;

            case 5:
                pPrinterName = ((PPRINTER_INFO_5)pPrinter)->pPrinterName;
                break;
        }

        if ( pPrinterName &&
             wcslen(pPrinterName) + 1 > MAX_PRINTER_NAME ) {

            SetLastError(ERROR_INVALID_PRINTER_NAME);
            return FALSE;
        }
    }

    switch( Level ){
    case 8:
    {
        //
        // Setting the global DevMode.
        //
        PPRINTER_INFO_8 pPrinterInfo8 = (PPRINTER_INFO_8)pPrinter;
        PPRINTER_INFO_2 pPrinterInfo2;
        DWORD rc = FALSE;;

        if( Command != 0 ){
            SetLastError( ERROR_INVALID_PRINTER_COMMAND );
            return FALSE;
        }

        //
        // Call GetPrinter then SetPrinter.
        //
        pPrinterInfo2 = pGetPrinterInfo2( hPrinter );

        if( pPrinterInfo2 ){

            //
            // Set the DevMode, and also clear the security descriptor
            // so that the set will succeed.
            //
            pPrinterInfo2->pDevMode = pPrinterInfo8->pDevMode;
            pPrinterInfo2->pSecurityDescriptor = NULL;

            rc = (*pPrintHandle->pProvidor->PrintProvidor.fpSetPrinter) (
                     pPrintHandle->hPrinter,
                     2,
                     (PBYTE)pPrinterInfo2,
                     Command );

            FreeSplMem( pPrinterInfo2 );
        }

        return rc;
    }
    case 9:
    {
        PPRINTER_INFO_9 pPrinterInfo9 = (PPRINTER_INFO_9)pPrinter;
        
        //
        // Setting the per-user DevMode.
        //

        if( !pPrinter ){
            SetLastError( ERROR_INVALID_PARAMETER );
            return FALSE;
        }

        if( Command != 0 ){
            SetLastError( ERROR_INVALID_PRINTER_COMMAND );
            return FALSE;
        }

        if (S_OK != CheckLocalCall()) {
            SetLastError(ERROR_NOT_SUPPORTED);
            return FALSE;
        }
        
        return bSetDevModePerUser( NULL,
                                   pPrintHandle->pszPrinter,
                                   pPrinterInfo9->pDevMode );
    }
    case 2:
    {
        PPRINTER_INFO_2 pPrinterInfo2 = (PPRINTER_INFO_2)pPrinter;

        if( S_OK == CheckLocalCall() ){

            if( pPrinterInfo2 && pPrinterInfo2->pDevMode ){
                bSetDevModePerUser( NULL,
                                    pPrintHandle->pszPrinter,
                                    pPrinterInfo2->pDevMode );

                //
                // Don't set the global DevMode.
                //
                pDevModeRestore = pPrinterInfo2->pDevMode;
                pPrinterInfo2->pDevMode = NULL;
            }
        }
    }
    default:
        break;
    }

    bReturn = (*pPrintHandle->pProvidor->PrintProvidor.fpSetPrinter)
                  (pPrintHandle->hPrinter, Level, pPrinter, Command);

    if( pDevModeRestore ){
        ((PPRINTER_INFO_2)pPrinter)->pDevMode = pDevModeRestore;
    }

    return bReturn;
}

BOOL
GetPrinterW(
    HANDLE  hPrinter,
    DWORD   Level,
    LPBYTE  pPrinter,
    DWORD   cbBuf,
    LPDWORD pcbNeeded
    )
{
    LPPRINTHANDLE  pPrintHandle=(LPPRINTHANDLE)hPrinter;
    PDEVMODE pDevModeSrc = NULL;
    PDEVMODE pDevModeDest = NULL;
    PDEVMODE pDevModeFree = NULL;
    BOOL bCallServer = TRUE;
    BOOL bReturnValue = FALSE;
    PPRINTER_INFO_2 pPrinterInfo2 = NULL;
    DWORD cbDevModeSrc;
    DWORD Error;
    DWORD cbExtraSpace2 = 0;

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    if ((pPrinter == NULL) && (cbBuf != 0)) {
        SetLastError(ERROR_INVALID_USER_BUFFER);
        return FALSE;
    }

    switch( Level ){
    case 2:

        if( pPrintHandle->pszPrinter && S_OK == CheckLocalCall()){

            bGetDevModePerUser( NULL,
                                pPrintHandle->pszPrinter,
                                &pDevModeFree );

            if( pDevModeFree ){

                pDevModeSrc = pDevModeFree;

                cbDevModeSrc = pDevModeSrc->dmSize +
                               pDevModeSrc->dmDriverExtra;

                cbExtraSpace2 = DWORD_ALIGN_UP( cbDevModeSrc );
                cbBuf = DWORD_ALIGN_DOWN( cbBuf );
            }
        }
        break;

    case 8:
    {
        PPRINTER_INFO_8 pPrinterInfo8 = (PPRINTER_INFO_8)pPrinter;

        //
        // Handle info level 8 calls for global DevModes.
        //
        if( !pPrintHandle->pszPrinter ){

            SetLastError( ERROR_FILE_NOT_FOUND );
            return FALSE;
        }

        bCallServer = FALSE;
        *pcbNeeded = sizeof( PRINTER_INFO_8 );

        //
        // Call GetPrinter to get the real DevMode.
        //
        pPrinterInfo2 = pGetPrinterInfo2( hPrinter );

        if( pPrinterInfo2 ){

            //
            // Pickup the DevMode from pPrinterInfo2;
            // destination is after the pDevModeStructure.
            // Don't need to free pDevModeSrc since it will be
            // freed when pPrinterInfo2 is released.
            //
            pDevModeSrc = pPrinterInfo2->pDevMode;

            if( pDevModeSrc ){

                cbDevModeSrc = pDevModeSrc->dmSize +
                               pDevModeSrc->dmDriverExtra;

                *pcbNeeded += cbDevModeSrc;
            }

            if( cbBuf < *pcbNeeded ){

                //
                // Not enough space.  SetLastError and fall through
                // to the end.
                //
                SetLastError( ERROR_INSUFFICIENT_BUFFER );

            } else {

                bReturnValue = TRUE;

                if( pDevModeSrc ){

                    //
                    // Update the pointer and indicate via pDevModeDest
                    // that we need to copy the DevMode in.
                    //
                    pDevModeDest = (PDEVMODE)&pPrinterInfo8[1];
                    pPrinterInfo8->pDevMode = pDevModeDest;

                } else {

                    //
                    // No DevMode, return pointer to NULL.
                    //
                    pPrinterInfo8->pDevMode = NULL;
                }
            }
        }

        break;
    }
    case 9:
    {
        //
        // Per-user DevMode.  Use the client side one.
        //

        PPRINTER_INFO_9 pPrinterInfo9 = (PPRINTER_INFO_9)pPrinter;

        if( !pPrintHandle->pszPrinter ){
            SetLastError( ERROR_INVALID_HANDLE );
            return FALSE;
        }

        if( S_OK != CheckLocalCall( )){

            SetLastError( ERROR_NOT_SUPPORTED );
            return FALSE;
        }

        bCallServer = FALSE;

        *pcbNeeded = sizeof( PRINTER_INFO_9 );

        if( bGetDevModePerUserEvenForShares( NULL,
                                             pPrintHandle->pszPrinter,
                                             &pDevModeFree )){

            pDevModeSrc = pDevModeFree;

            if( pDevModeSrc ){

                cbDevModeSrc = pDevModeSrc->dmSize +
                               pDevModeSrc->dmDriverExtra;

                *pcbNeeded += cbDevModeSrc;
            }
        }

        if( cbBuf < *pcbNeeded ){

            //
            // Not enough space.  We'll fall through below
            // and fail.
            //
            SetLastError( ERROR_INSUFFICIENT_BUFFER );

        } else {

            bReturnValue = TRUE;

            if( pDevModeSrc ){

                pDevModeDest = (PDEVMODE)&pPrinterInfo9[1];
                pPrinterInfo9->pDevMode = pDevModeDest;

            } else {

                //
                // No per-user DevMode.  Return SUCCESS, but indicate
                // no DevMode available.
                //
                pPrinterInfo9->pDevMode = NULL;
            }
        }
        break;
    }
    default:
        break;
    }

    if( bCallServer ){

        DWORD cbAvailable;

        //
        // Allocate extra space at the end for the per-user DevMode,
        // in case there isn't a global devmode in the printer info 2
        // structure.
        //
        cbAvailable = ( cbBuf >= cbExtraSpace2 ) ?
                          cbBuf - cbExtraSpace2 :
                          0;

        bReturnValue = (*pPrintHandle->pProvidor->PrintProvidor.fpGetPrinter)
                           (pPrintHandle->hPrinter, Level, pPrinter,
                            cbAvailable, pcbNeeded);

        *pcbNeeded += cbExtraSpace2;
    }

    Error = GetLastError();

    if( Level == 9 && pDevModeSrc == NULL){

        PPRINTER_INFO_2 pInfo2 = (PPRINTER_INFO_2)pPrinter;

        if( pInfo2 && pInfo2->pDevMode ){

            pDevModeSrc = pInfo2->pDevMode;

        }
    }

    //
    // Special case INFO level 2, since we want to get the provider's
    // information, but then we also want the per-user DevMode.
    //
    // Only do this for local calls.
    //
    if( cbExtraSpace2 ){

        PPRINTER_INFO_2 pInfo2 = (PPRINTER_INFO_2)pPrinter;

        //
        // If we succeeded and we have a buffer, then we need to check if we
        // need to put the per-user DevMode at the end of the buffer.
        //
        if( pInfo2 && bReturnValue ){

            //
            // If we have no DevMode, or it's compatible, then we want to
            // use the per-user DevMode.
            //
            if( !pInfo2->pDevMode ||
                bCompatibleDevMode( pPrintHandle,
                                    pInfo2->pDevMode,
                                    pDevModeSrc )){

                pDevModeDest = (PDEVMODE)(pPrinter + cbBuf - cbExtraSpace2 );
                pInfo2->pDevMode = pDevModeDest;

            } else {

                //
                // !! POLICY !!
                //
                // Not compatible with per-user DevMode.  Delete the
                // per-user one.
                //
                bSetDevModePerUser( NULL, pPrintHandle->pszPrinter, NULL );
            }
        }
    }

    //
    // Check if we need to copy over a DevMode.
    //
    if( pDevModeDest ){

        //
        // Update the DevMode.
        //
        CopyMemory( (PVOID)pDevModeDest,
                    (PVOID)pDevModeSrc,
                    cbDevModeSrc );

        bReturnValue = TRUE;
    }

    FreeSplMem( pDevModeFree );
    FreeSplMem( pPrinterInfo2 );

    SetLastError( Error );

    return bReturnValue;
}


DWORD
GetPrinterDataW(
   HANDLE   hPrinter,
   LPWSTR   pValueName,
   LPDWORD  pType,
   LPBYTE   pData,
   DWORD    nSize,
   LPDWORD  pcbNeeded
)
{
    LPPRINTHANDLE   pPrintHandle=(LPPRINTHANDLE)hPrinter;

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    return (*pPrintHandle->pProvidor->PrintProvidor.fpGetPrinterData)(pPrintHandle->hPrinter,
                                                        pValueName,
                                                        pType,
                                                        pData,
                                                        nSize,
                                                        pcbNeeded);
}

DWORD
GetPrinterDataExW(
   HANDLE   hPrinter,
   LPCWSTR  pKeyName,
   LPCWSTR  pValueName,
   LPDWORD  pType,
   LPBYTE   pData,
   DWORD    nSize,
   LPDWORD  pcbNeeded
)
{
    LPPRINTHANDLE   pPrintHandle=(LPPRINTHANDLE)hPrinter;

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    return (*pPrintHandle->pProvidor->PrintProvidor.fpGetPrinterDataEx)(pPrintHandle->hPrinter,
                                                        pKeyName,
                                                        pValueName,
                                                        pType,
                                                        pData,
                                                        nSize,
                                                        pcbNeeded);
}

DWORD
EnumPrinterDataW(
    HANDLE  hPrinter,
    DWORD   dwIndex,        // index of value to query
    LPWSTR  pValueName,        // address of buffer for value string
    DWORD   cbValueName,    // size of buffer for value string
    LPDWORD pcbValueName,    // address for size of value buffer
    LPDWORD pType,            // address of buffer for type code
    LPBYTE  pData,            // address of buffer for value data
    DWORD   cbData,            // size of buffer for value data
    LPDWORD pcbData         // address for size of data buffer
)
{
    LPPRINTHANDLE   pPrintHandle=(LPPRINTHANDLE)hPrinter;

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    return (*pPrintHandle->pProvidor->PrintProvidor.fpEnumPrinterData)(pPrintHandle->hPrinter,
                                                        dwIndex,
                                                        pValueName,
                                                        cbValueName,
                                                        pcbValueName,
                                                        pType,
                                                        pData,
                                                        cbData,
                                                        pcbData);
}

DWORD
EnumPrinterDataExW(
    HANDLE  hPrinter,
    LPCWSTR pKeyName,       // address of key name
    LPBYTE  pEnumValues,
    DWORD   cbEnumValues,
    LPDWORD pcbEnumValues,
    LPDWORD pnEnumValues
)
{
    LPPRINTHANDLE   pPrintHandle=(LPPRINTHANDLE)hPrinter;

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    return (*pPrintHandle->pProvidor->PrintProvidor.fpEnumPrinterDataEx)(pPrintHandle->hPrinter,
                                                        pKeyName,
                                                        pEnumValues,
                                                        cbEnumValues,
                                                        pcbEnumValues,
                                                        pnEnumValues);
}


DWORD
EnumPrinterKeyW(
    HANDLE  hPrinter,
    LPCWSTR pKeyName,       // address of key name
    LPWSTR  pSubkey,        // address of buffer for value string
    DWORD   cbSubkey,       // size of buffer for value string
    LPDWORD pcbSubkey        // address for size of value buffer
)
{
    LPPRINTHANDLE   pPrintHandle=(LPPRINTHANDLE)hPrinter;

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    return (*pPrintHandle->pProvidor->PrintProvidor.fpEnumPrinterKey)(pPrintHandle->hPrinter,
                                                        pKeyName,
                                                        pSubkey,
                                                        cbSubkey,
                                                        pcbSubkey);
}



DWORD
DeletePrinterDataW(
    HANDLE  hPrinter,
    LPWSTR  pValueName
)
{
    LPPRINTHANDLE   pPrintHandle=(LPPRINTHANDLE)hPrinter;

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    return (*pPrintHandle->pProvidor->PrintProvidor.fpDeletePrinterData)(pPrintHandle->hPrinter,
                                                                         pValueName);
}


DWORD
DeletePrinterDataExW(
    HANDLE  hPrinter,
    LPCWSTR pKeyName,
    LPCWSTR pValueName
)
{
    LPPRINTHANDLE   pPrintHandle=(LPPRINTHANDLE)hPrinter;

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    return (*pPrintHandle->pProvidor->PrintProvidor.fpDeletePrinterDataEx)(pPrintHandle->hPrinter,
                                                                         pKeyName,
                                                                         pValueName);
}


DWORD
DeletePrinterKeyW(
    HANDLE  hPrinter,
    LPCWSTR pKeyName
)
{
    LPPRINTHANDLE   pPrintHandle=(LPPRINTHANDLE)hPrinter;

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    return (*pPrintHandle->pProvidor->PrintProvidor.fpDeletePrinterKey)(pPrintHandle->hPrinter,
                                                                        pKeyName);

}



DWORD
SetPrinterDataW(
    HANDLE  hPrinter,
    LPWSTR  pValueName,
    DWORD   Type,
    LPBYTE  pData,
    DWORD   cbData
)
{
    LPPRINTHANDLE   pPrintHandle=(LPPRINTHANDLE)hPrinter;

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    return (*pPrintHandle->pProvidor->PrintProvidor.fpSetPrinterData)(pPrintHandle->hPrinter,
                                                        pValueName,
                                                        Type,
                                                        pData,
                                                        cbData);
}


DWORD
SetPrinterDataExW(
    HANDLE  hPrinter,
    LPCWSTR pKeyName,
    LPCWSTR pValueName,
    DWORD   Type,
    LPBYTE  pData,
    DWORD   cbData
)
{
    LPPRINTHANDLE   pPrintHandle=(LPPRINTHANDLE)hPrinter;

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    return (*pPrintHandle->pProvidor->PrintProvidor.fpSetPrinterDataEx)(pPrintHandle->hPrinter,
                                                                        pKeyName,
                                                                        pValueName,
                                                                        Type,
                                                                        pData,
                                                                        cbData);
}



DWORD
WaitForPrinterChange(
   HANDLE   hPrinter,
   DWORD    Flags
)
{
    LPPRINTHANDLE   pPrintHandle=(LPPRINTHANDLE)hPrinter;

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    return (*pPrintHandle->pProvidor->PrintProvidor.fpWaitForPrinterChange)
                                        (pPrintHandle->hPrinter, Flags);
}

BOOL
ClosePrinter(
   HANDLE hPrinter
)
{
    LPPRINTHANDLE   pPrintHandle=(LPPRINTHANDLE)hPrinter;

    EnterRouterSem();

    if (!pPrintHandle || pPrintHandle->signature != PRINTHANDLE_SIGNATURE) {
        LeaveRouterSem();
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    //
    // Close any notifications on this handle.
    //
    // The local case cleans up the event, while the remote
    // case potentially cleans up the Reply Notification context
    // handle.
    //
    // We must close this first, since the Providor->ClosePrinter
    // call removes data structures that FindClose... relies on.
    //
    // Client side should be shutdown by winspool.drv.
    //
    if (pPrintHandle->pChange &&
        (pPrintHandle->pChange->eStatus & STATUS_CHANGE_VALID)) {

        FindClosePrinterChangeNotificationWorker(hPrinter);
    }

    LeaveRouterSem();

    if ((*pPrintHandle->pProvidor->PrintProvidor.fpClosePrinter) (pPrintHandle->hPrinter)) {

        //
        // We can't just free it, since there may be a reply waiting
        // on it.
        //
        FreePrinterHandle(pPrintHandle);
        return TRUE;

    } else

        return FALSE;
}



/* FormatPrinterForRegistryKey
 *
 * Returns a pointer to a copy of the source string with backslashes removed.
 * This is to store the printer name as the key name in the registry,
 * which interprets backslashes as branches in the registry structure.
 * Convert them to commas, since we don't allow printer names with commas,
 * so there shouldn't be any clashes.
 * If there are no backslashes, the string is unchanged.
 */
LPWSTR
FormatPrinterForRegistryKey(
    LPCWSTR pSource,       /* The string from which backslashes are to be removed. */
    LPWSTR  pScratch,      /* Scratch buffer for the function to write in;     */
    DWORD   cchScratchLen  /* must be at least as long as pSource.             */
    )                   
{
    LPWSTR p;

    if (pScratch != pSource) {

        //
        // Copy the string into the scratch buffer:
        //
        StringCchCopy(pScratch, cchScratchLen, pSource);
    }

    //
    // Check each character, and, if it's a backslash,
    // convert it to a comma:
    //
    for (p = pScratch; *p; ++p) {
        if (*p == L'\\')
            *p = L',';
    }

    return pScratch;
}


/* FormatRegistryKeyForPrinter
 *
 * Returns a pointer to a copy of the source string with backslashes added.
 * This must be the opposite of FormatPrinterForRegistryKey, so the mapping
 * _must_ be 1-1.
 *
 * If there are no commas, the string is unchanged.
 */
LPWSTR
FormatRegistryKeyForPrinter(
    LPWSTR pSource,      /* The string from which backslashes are to be added. */
    LPWSTR pScratch,     /* Scratch buffer for the function to write in;     */
    DWORD  cchScratchLen /* must be at least as long as pSource.             */
    )
{
    LPWSTR p;

    if (pScratch != pSource) 
    {
        StringCchCopy(pScratch, cchScratchLen, pSource);
    }

    //
    // Check each character, and, if it's a backslash, convert it to a comma:
    //
    for (p = pScratch; *p; p++) 
    {
        if (*p == L',')
        {    
            *p = L'\\';
        }
    }

    return pScratch;
}


/* SavePrinterConnectionInRegistry
 *
 * Saves data in the registry for a printer connection.
 * Creates a key under the current impersonation client's key
 * in the registry under \Printers\Connections.
 * The printer name is stripped of backslashes, since the registry
 * API does not permit the creation of keys with backslashes.
 * They are replaced by commas, which are invalid characters
 * in printer names, so we should never get one passed in.
 *
 *
 * *** WARNING ***
 *
 * IF YOU MAKE CHANGES TO THE LOCATION IN THE REGISTRY
 * WHERE PRINTER CONNECTIONS ARE STORED, YOU MUST MAKE
 * CORRESPONDING CHANGES IN USER\USERINIT\USERINIT.C.
 *
 */
BOOL
SavePrinterConnectionInRegistry(
    PPRINTER_INFO_2 pPrinterInfo2,
    LPPROVIDOR pProvidor
    )
{
    HKEY    hClientKey = NULL;
    HKEY    hConnectionsKey;
    HKEY    hPrinterKey;
    DWORD   Status;
    BOOL    rc = FALSE;
    LPCTSTR pszProvidor = pProvidor->lpName;
    PWSTR   pKeyName = NULL;
    DWORD   cchSize = MAX_PATH;
    DWORD   dwError;

    //
    // CLS
    //
    // If the provider is localspl, change it to win32spl.dll.
    // This is required for clustering since localspl handles printer
    // connections, but they should be "owned" by win32spl.dll.  When
    // Someone opens a printer that they are connected to, we will
    // always hit localspl.dll first before we look at this entry.
    //
    // When the cluster is remote, then they need to go through win32spl.dll.
    //
    if( pProvidor == pLocalProvidor ){
        pszProvidor = szWin32spl;
    }

    hClientKey = GetClientUserHandle(KEY_READ);

    if (hClientKey) {

        if (wcslen(pPrinterInfo2->pPrinterName) < cchSize &&
            (pKeyName = AllocSplMem(cchSize * sizeof(WCHAR)))) {

            Status = RegCreateKeyEx(hClientKey, szRegistryConnections,
                                    REG_OPTION_RESERVED, NULL, REG_OPTION_NON_VOLATILE,
                                    KEY_WRITE, NULL, &hConnectionsKey, NULL);

            if (Status == NO_ERROR) {

                /* Make a key name without backslashes, so that the
                 * registry doesn't interpret them as branches in the registry tree:
                 */
                FormatPrinterForRegistryKey(pPrinterInfo2->pPrinterName,
                                            pKeyName,
                                            cchSize);

                Status = RegCreateKeyEx(hConnectionsKey, pKeyName, REG_OPTION_RESERVED,
                                        NULL, 0, KEY_WRITE, NULL, &hPrinterKey, NULL);

                if (Status == NO_ERROR) {

                    RegSetValueEx(hPrinterKey,
                                  szServerValue,
                                  0,
                                  REG_SZ,
                                  (LPBYTE)pPrinterInfo2->pServerName,
                                  (lstrlen(pPrinterInfo2->pServerName)+1) *
                                  sizeof(pPrinterInfo2->pServerName[0]));

                    Status = RegSetValueEx(hPrinterKey,
                                           szProvidorValue,
                                           0,
                                           REG_SZ,
                                           (LPBYTE)pszProvidor,
                                           (lstrlen(pszProvidor)+1) *
                                               sizeof(pszProvidor[0]));

                    if (Status == ERROR_SUCCESS) {

                        dwError = UpdatePrinterRegUser(hClientKey,
                                                       NULL,
                                                       pPrinterInfo2->pPrinterName,
                                                       NULL,
                                                       UPDATE_REG_CHANGE);

                        if (dwError == ERROR_SUCCESS) {

                            BroadcastMessage(BROADCAST_TYPE_MESSAGE,
                                             WM_WININICHANGE,
                                             0,
                                             (LPARAM)szDevices);

                            rc = TRUE;

                        } else {

                            DBGMSG(DBG_TRACE, ("UpdatePrinterRegUser failed: Error %d\n",
                                               dwError));
                        }

                    } else {

                        DBGMSG(DBG_WARNING, ("RegSetValueEx(%ws) failed: Error %d\n",
                               pszProvidor, Status));

                        rc = FALSE;
                    }

                    RegCloseKey(hPrinterKey);

                } else {

                    DBGMSG(DBG_WARNING, ("RegCreateKeyEx(%ws) failed: Error %d\n",
                                         pKeyName, Status ));
                    rc = FALSE;
                }

                RegCloseKey(hConnectionsKey);

            } else {

                DBGMSG(DBG_WARNING, ("RegCreateKeyEx(%ws) failed: Error %d\n",
                                     szRegistryConnections, Status ));
                rc = FALSE;
            }


            if (!rc) {

                DBGMSG(DBG_WARNING, ("Error updating registry: %d\n",
                                     GetLastError())); /* This may not be the error */
                                                       /* that caused the failure.  */
                if (pKeyName)
                    RegDeleteKey(hClientKey, pKeyName);
            }

            FreeSplMem(pKeyName);
        }

        RegCloseKey(hClientKey);
    }

    return rc;
}

BOOL
RemovePrinterConnectionInRegistry(
    LPWSTR pName)
{
    HKEY    hClientKey;
    HKEY    hPrinterConnectionsKey;
    DWORD   Status = NO_ERROR;
    DWORD   i = 0;
    PWSTR   pKeyName = NULL;
    DWORD   cchSize = MAX_PATH;
    BOOL    Found = FALSE;
    BOOL    bRet = FALSE;

    if (pName && 
        wcslen(pName) < cchSize) {

        if (pKeyName = AllocSplMem(cchSize * sizeof(WCHAR))) {
        
            hClientKey = GetClientUserHandle(KEY_READ);


            if (hClientKey) {

                Status = RegOpenKeyEx(hClientKey, szRegistryConnections,
                                      REG_OPTION_RESERVED,
                                      KEY_READ | KEY_WRITE, &hPrinterConnectionsKey);

                if (Status == NO_ERROR) {

                    FormatPrinterForRegistryKey(pName, pKeyName, cchSize);
                    bRet = DeleteSubKeyTree(hPrinterConnectionsKey, pKeyName);

                    RegCloseKey(hPrinterConnectionsKey);
                }

                if ( bRet ) {

                    UpdatePrinterRegUser(hClientKey,
                                         NULL,
                                         pName,
                                         NULL,
                                         UPDATE_REG_DELETE);
                }

                RegCloseKey(hClientKey);

                if ( bRet ) {

                    BroadcastMessage(BROADCAST_TYPE_MESSAGE,
                                     WM_WININICHANGE,
                                     0,
                                     (LPARAM)szDevices);
                }
            }

            FreeSplMem(pKeyName);
        }
    }

    return bRet;
}

VOID
PrinterHandleRundown(
    HANDLE hPrinter)
{
    LPPRINTHANDLE pPrintHandle;

    if (hPrinter) {

        pPrintHandle = (LPPRINTHANDLE)hPrinter;

        switch (pPrintHandle->signature) {

        case PRINTHANDLE_SIGNATURE:

            // Log warning to detect handle free
            DBGMSG(DBG_WARNING, ("PrinterHandleRundown: 0x%x 0x%x", pPrintHandle, pPrintHandle->hPrinter));

            DBGMSG(DBG_TRACE, ("Rundown PrintHandle 0x%x\n", hPrinter));
            ClosePrinter(hPrinter);
            break;

        case NOTIFYHANDLE_SIGNATURE:

            DBGMSG(DBG_TRACE, ("Rundown NotifyHandle 0x%x\n", hPrinter));
            RundownPrinterNotify(hPrinter);
            break;

        case CLUSTERHANDLE_SIGNATURE:

            DBGMSG(DBG_TRACE, ("Rundown ClusterHandle 0x%x\n", hPrinter ));
            ClusterSplClose(hPrinter);
            break;

        default:

            //
            // Unknown type.
            //
            DBGMSG( DBG_ERROR, ("Rundown: Unknown type 0x%x\n", hPrinter ) );
            break;
        }
    }
    return;
}

/*++

    Function Description: 
        Validates the fully qualified printer name. Performs the following checks
        1) Length < MAX_UNC_PRINTER_NAME
        2) No invalid chars in the names \,!
        3) No empty names after removing trailing blanks

    Arguments: 
        pPrinterName  -  printer name

    Return Values: 
        TRUE if valid name; FALSE otherwise

--*/
BOOL
ValidatePrinterName(
    LPWSTR pPrinterName
    )
{
    BOOL    bRetVal        = TRUE;
    DWORD   PrinterNameLen = 0;

    //
    // '!' or ',' or '\' are not valid characters in the
    // server or printer names.
    // The min. allowed printer name length is 5 "\\s\p"
    //
    if (!pPrinterName                                                    ||
        ((PrinterNameLen = wcslen(pPrinterName)) < MIN_UNC_PRINTER_NAME) ||
        (PrinterNameLen >= MAX_UNC_PRINTER_NAME)                         ||
        (wcschr(pPrinterName, L','))                                     ||
        (wcschr(pPrinterName, L'!'))                                     ||
        (*pPrinterName++ != L'\\')                                       ||
        (*pPrinterName++ != L'\\'))
    {
        bRetVal = FALSE;
    }
    else
    {
        LPWSTR pWack      = NULL;
        LPWSTR pAfterWack = NULL;

        if (!(pWack = wcschr(pPrinterName, L'\\')) ||
            wcschr(pAfterWack=pWack+1, L'\\'))
        {
            bRetVal = FALSE;
        }
        else
        {
            WCHAR  szServer[MAX_UNC_PRINTER_NAME], szPrinter[MAX_UNC_PRINTER_NAME];
            size_t ServerNameLen  = 0;
            int    IndexInName    = 0;

            wcsncpy(szServer, pPrinterName, ServerNameLen = pWack-pPrinterName);
            szServer[ServerNameLen] = L'\0';

            StringCchCopy(szPrinter, MAX_UNC_PRINTER_NAME, pAfterWack); 

            for (IndexInName=ServerNameLen-1; 
                 IndexInName>=0;
                 IndexInName--)
            {
                if (szServer[IndexInName] != L' ')
                {
                    break;
                }
            }
            szServer[IndexInName+1] = L'\0';

            for (IndexInName=wcslen(szPrinter)-1;
                 IndexInName>=0;
                 IndexInName--)
            {
                if (szPrinter[IndexInName] != L' ')
                {
                    break;
                }
            }
            szPrinter[IndexInName+1] = L'\0';

            if (!szServer[0] || !szPrinter[0])
            {
                bRetVal = FALSE;
            }
        }
    }

    return bRetVal;   
}

BOOL
RouterAddPerMachineConnection(
    LPCWSTR   pPrinterNameP,
    LPCWSTR   pPrintServerP,
    LPCWSTR   pProviderP)

/*++
Function Description: RouterAddPerMachineConnection adds a subkey to HKEY_LOCAL_MACHINE\
                      SYSTEM\CurrentControlSet\Control\Print\Connections with the PrinterName.
                      The PrintServer name and the name of the dll used as a provider for
                      this connection are stored as values in the key.

Parameters:
            pPrinterNameP - pointer to the fully qualified printer name. (\\printserver\name)
            pPrintServerP - pointer to the print server name.
            pProviderP - pointer to the provider name. Currently only LanMan Print Services
                         is supported. This corresponds to win32spl.dll. NULL or szNULL value
                         defaults to this provider. Currently there is no check to enforce that
                         only LanMan Print Services is passed.

Return Value: TRUE for success
              FALSE otherwise.
--*/

{
    BOOL   bReturn = TRUE;
    DWORD  dwLocalConnection = 1, dwLastError, dwType, cbBuf;

    HKEY   hMcConnectionKey = NULL, hPrinterKey = NULL;
    HKEY   hProviderKey = NULL, hAllProviderKey = NULL;
    HANDLE hImpersonationToken = NULL;

    LPWSTR pPrintServer=NULL, pProvider=NULL, pPrinterName=NULL, pEnd;
    WCHAR  szConnData[MAX_PATH];
    WCHAR  szRegistryConnections[] = L"SYSTEM\\CurrentControlSet\\Control\\Print\\Connections";
    WCHAR  szRegistryProviders[] = L"SYSTEM\\CurrentControlSet\\Control\\Print\\Providers";

   EnterRouterSem();

    // Getting the name of the library for the provider.
    if (!pProviderP || !*pProviderP) {

       pProvider = AllocSplStr(L"win32spl.dll");

    } else {

       cbBuf = sizeof(szConnData);

       if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szRegistryProviders, 0,
                        KEY_READ, &hAllProviderKey) ||
           RegOpenKeyEx(hAllProviderKey, pProviderP, 0, KEY_READ,
                        &hProviderKey) ||
           RegQueryValueEx(hProviderKey, L"Name", 0, &dwType,
                           (LPBYTE)szConnData,&cbBuf))  {

            SetLastError(ERROR_INVALID_PARAMETER);
            bReturn = FALSE;
            goto CleanUp;

       } else {

            pProvider = AllocSplStr(szConnData);
       }
    }

    pPrintServer = AllocSplStr(pPrintServerP);
    pPrinterName = AllocSplStr(pPrinterNameP);

    if (!pProvider || !pPrintServer || !pPrinterName) {

        bReturn = FALSE;
        goto CleanUp;
    }

    // Check for a fully qualified printer name without commas
    if (!ValidatePrinterName(pPrinterName)) {

         SetLastError(ERROR_INVALID_PRINTER_NAME);
         bReturn = FALSE;
         goto CleanUp;
    }

    // Replacing the \'s from the Printer name with ,'s
    FormatPrinterForRegistryKey(pPrinterName, pPrinterName, wcslen(pPrinterName) + 1);

    hImpersonationToken = RevertToPrinterSelf();

    // Creating the subkey for the holding all printer connections.

    if ((dwLastError = RegCreateKeyEx(HKEY_LOCAL_MACHINE, szRegistryConnections, 0,
                                      NULL, REG_OPTION_NON_VOLATILE, KEY_SET_VALUE,
                                      NULL, &hMcConnectionKey, NULL)) ||
        (dwLastError = RegCreateKeyEx(hMcConnectionKey, pPrinterName, 0, NULL,
                                      REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, NULL,
                                      &hPrinterKey, NULL))) {

         SetLastError(dwLastError);
         bReturn = FALSE;
         goto CleanUp;
    }

    // Setting the connection data.
    if ((dwLastError = RegSetValueEx(hPrinterKey, L"Server", 0, REG_SZ, (LPBYTE) pPrintServer,
                                     (wcslen(pPrintServer)+1)*sizeof(pPrintServer[0]))) ||
        (dwLastError = RegSetValueEx(hPrinterKey, L"Provider", 0, REG_SZ, (LPBYTE) pProvider,
                                     (wcslen(pProvider)+1)*sizeof(pProvider[0]))) ||
        (dwLastError = RegSetValueEx(hPrinterKey, L"LocalConnection", 0, REG_DWORD,
                                     (LPBYTE) &dwLocalConnection, sizeof(dwLocalConnection)))) {

         SetLastError(dwLastError);
         bReturn = FALSE;
    }

CleanUp:
    if (pPrintServer) {
       FreeSplStr(pPrintServer);
    }

    if (pProvider) {
       FreeSplStr(pProvider);
    }

    if (hAllProviderKey) {
       RegCloseKey(hAllProviderKey);
    }

    if (hProviderKey) {
       RegCloseKey(hProviderKey);
    }

    if (hPrinterKey) {
        RegCloseKey(hPrinterKey);
    }

    if (!bReturn) {
       if (hMcConnectionKey) RegDeleteKey(hMcConnectionKey,pPrinterName);
    }

    if (pPrinterName) {
       FreeSplStr(pPrinterName);
    }

    if (hMcConnectionKey) {
       RegCloseKey(hMcConnectionKey);
    }

    if (hImpersonationToken) {
       ImpersonatePrinterClient(hImpersonationToken);
    }

   LeaveRouterSem();

    return bReturn;
}

BOOL
AddPerMachineConnectionW(
    LPCWSTR  pServer,
    LPCWSTR  pPrinterName,
    LPCWSTR  pPrintServer,
    LPCWSTR  pProvider
)
{
    LPPROVIDOR  pProvidor;

    WaitForSpoolerInitialization();

    pProvidor = pLocalProvidor;

    if ((*pProvidor->PrintProvidor.fpAddPerMachineConnection)
                (pServer, pPrinterName, pPrintServer, pProvider)) {

        return RouterAddPerMachineConnection(pPrinterName,pPrintServer,pProvider);

    } else if (GetLastError() != ERROR_INVALID_NAME) {

        return FALSE;
    }

    pProvidor = pProvidor->pNext;
    while (pProvidor) {

       if ((*pProvidor->PrintProvidor.fpAddPerMachineConnection)
                (pServer, pPrinterName, pPrintServer, pProvider)) {
          return TRUE;
       }

       if (GetLastError() != ERROR_INVALID_NAME) {
          return FALSE;
       }

       pProvidor = pProvidor->pNext;
    }

    return FALSE;
}

BOOL
RouterDeletePerMachineConnection(
    LPCWSTR   pPrinterNameP
    )
/*++
Function Description: This function deletes the registry entry in HKEY_LOCAL_MACHINE\
                      SYSTEM\CurrentControlSet\Control\Print\Connections corresponding to
                      pPrinterNameP. All users will lose the connection when they logon.

Parameters: pPrinterNameP - pointer to the fully qualified name of the printer.

Return Values: TRUE for Success
               FALSE otherwise.
--*/
{
    BOOL    bReturn = TRUE, bEnteredRouterSem = FALSE;
    HANDLE  hImpersonationToken = NULL;
    HKEY    hMcConnectionKey = NULL;
    LPWSTR  pPrinterName = NULL;
    DWORD   dwLastError;
    WCHAR   szRegistryConnections[] = L"SYSTEM\\CurrentControlSet\\Control\\Print\\Connections";


    if (!(pPrinterName = AllocSplStr(pPrinterNameP))) {

        bReturn = FALSE;
        goto CleanUp;
    }

    // Convert \'s to ,'s in the printer name.
    FormatPrinterForRegistryKey(pPrinterName, pPrinterName, wcslen(pPrinterName) + 1);

    EnterRouterSem();
    bEnteredRouterSem = TRUE;

    hImpersonationToken = RevertToPrinterSelf();

    if (dwLastError = RegOpenKeyEx(HKEY_LOCAL_MACHINE, szRegistryConnections, 0,
                                   KEY_ALL_ACCESS, &hMcConnectionKey)) {

        SetLastError(dwLastError);
        bReturn = FALSE;
        goto CleanUp;
    }

    if (dwLastError = RegDeleteKey(hMcConnectionKey, pPrinterName)) {

        SetLastError(dwLastError);
        bReturn = FALSE;
    }

CleanUp:
    if (hMcConnectionKey) {
       RegCloseKey(hMcConnectionKey);
    }
    
    if (pPrinterName) {
       FreeSplStr(pPrinterName);
    }
    if (hImpersonationToken) {
       ImpersonatePrinterClient(hImpersonationToken);
    }
    if (bEnteredRouterSem) {
       LeaveRouterSem();
    }

    return bReturn;
}

BOOL
DeletePerMachineConnectionW(
    LPCWSTR  pServer,
    LPCWSTR  pPrinterName
)
{
    LPPROVIDOR  pProvidor;

    WaitForSpoolerInitialization();

    pProvidor = pLocalProvidor;

    if ((*pProvidor->PrintProvidor.fpDeletePerMachineConnection)
                (pServer, pPrinterName)) {

        return RouterDeletePerMachineConnection(pPrinterName);

    } else if (GetLastError() != ERROR_INVALID_NAME) {

        return FALSE;
    }

    pProvidor = pProvidor->pNext;
    while (pProvidor) {

       if ((*pProvidor->PrintProvidor.fpDeletePerMachineConnection)
                (pServer, pPrinterName)) {
           return TRUE;
       }

       if (GetLastError() != ERROR_INVALID_NAME) {
           return FALSE;
       }

       pProvidor = pProvidor->pNext;
    }

    return FALSE;
}

BOOL
RouterEnumPerMachineConnections(
    LPCWSTR   pServer,
    LPBYTE    pPrinterEnum,
    DWORD     cbBuf,
    LPDWORD   pcbNeeded,
    LPDWORD   pcReturned
    )
/*++
Function Description: This function copies the PRINTER_INFO_4 structs for all the per
                      machine connections into the buffer (pPrinterEnum).

Parameters: pServer - pointer to the server name (NULL for local)
            pPrinterEnum - pointer to the buffer
            cbBuf - size of the buffer in bytes
            pcbNeeded - pointer to a variable which contains the number of bytes written
                        into the buffer/ number of bytes required (if the given buffer
                        is insufficient)
            pcReturned - pointer to the variable which contains the number of PRINTER_INFO_4
                         structs returned in the buffer.

Return Values: TRUE for success
               FALSE otherwise.

--*/
{
    DWORD     dwRegIndex, dwType, cbdata, dwNameSize, dwLastError;
    BOOL      bReturn = TRUE, bEnteredRouterSem = FALSE;
    HANDLE    hImpersonationToken = NULL;
    HKEY      hMcConnectionKey = NULL, hPrinterKey = NULL;
    LPBYTE    pStart = NULL, pEnd = NULL;

    WCHAR     szMachineConnections[]=L"SYSTEM\\CurrentControlSet\\Control\\Print\\Connections";
    WCHAR     szPrinterName[MAX_UNC_PRINTER_NAME],szConnData[MAX_UNC_PRINTER_NAME];

    // Check for local machine
    if (pServer && *pServer) {

        if (!MyUNCName((LPWSTR)pServer)) {

            SetLastError(ERROR_INVALID_NAME);
            bReturn = FALSE;
            goto CleanUp;
        }
    }

   EnterRouterSem();
   bEnteredRouterSem = TRUE;

    hImpersonationToken = RevertToPrinterSelf();

    *pcbNeeded = *pcReturned = 0;

    // Open the key containing all per-machine connections.
    if (dwLastError = RegOpenKeyEx(HKEY_LOCAL_MACHINE, szMachineConnections, 0,
                                   KEY_READ , &hMcConnectionKey)) {

        bReturn = (dwLastError == ERROR_FILE_NOT_FOUND) ? TRUE
                                                        : FALSE;
        if (!bReturn) {
            SetLastError(dwLastError);
        }
        goto CleanUp;
    }

    // pStart and pEnd point to the start and end of the buffer respt.
    pStart = pPrinterEnum;
    pEnd = pPrinterEnum + cbBuf;

    for (dwRegIndex = 0;

         dwNameSize = COUNTOF(szPrinterName),
         ((dwLastError = RegEnumKeyEx(hMcConnectionKey, dwRegIndex, szPrinterName,
                                      &dwNameSize, NULL, NULL, NULL, NULL)) == ERROR_SUCCESS);

         ++dwRegIndex) {

         // Enumerate each of the connections and copy data into the buffer
         cbdata = sizeof(szConnData);

         if ((dwLastError = RegOpenKeyEx(hMcConnectionKey, szPrinterName, 0,
                                         KEY_READ, &hPrinterKey)) ||
             (dwLastError = RegQueryValueEx(hPrinterKey, L"Server", NULL, &dwType,
                                            (LPBYTE)szConnData, &cbdata))) {

             SetLastError(dwLastError);
             bReturn = FALSE;
             goto CleanUp;
         }

         RegCloseKey(hPrinterKey);
         hPrinterKey=NULL;

         // Update the size of the required buffer
         *pcbNeeded = *pcbNeeded + sizeof(PRINTER_INFO_4) + sizeof(DWORD) +
                      (wcslen(szConnData) + 1)*sizeof(szConnData[0]) +
                      (wcslen(szPrinterName) + 1)*sizeof(szPrinterName[0]);

         // Copy data into the buffer if there is space.
         if (*pcbNeeded <= cbBuf) {

             pEnd = CopyPrinterNameToPrinterInfo4(szConnData,szPrinterName,pStart,pEnd);
             FormatRegistryKeyForPrinter(((PPRINTER_INFO_4) pStart)->pPrinterName,
                                         ((PPRINTER_INFO_4) pStart)->pPrinterName,
                                         wcslen(((PPRINTER_INFO_4) pStart)->pPrinterName) + 1);
             pStart += sizeof(PRINTER_INFO_4);
             (*pcReturned)++;
         }
    }

    if (dwLastError != ERROR_NO_MORE_ITEMS) {

        SetLastError(dwLastError);
        bReturn = FALSE;
        goto CleanUp;
    }

    if (cbBuf < *pcbNeeded) {

        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        bReturn = FALSE;
    }

CleanUp:

    if (hMcConnectionKey) {
       RegCloseKey(hMcConnectionKey);
    }
    if (hPrinterKey) {
       RegCloseKey(hPrinterKey);
    }
    if (hImpersonationToken) {
       ImpersonatePrinterClient(hImpersonationToken);
    }
    if (bEnteredRouterSem) {
       LeaveRouterSem();
    }
    if (!bReturn) {
       *pcReturned = 0;
    }

    return bReturn;
}

BOOL
EnumPerMachineConnectionsW(
    LPCWSTR  pServer,
    LPBYTE   pPrinterEnum,
    DWORD    cbBuf,
    LPDWORD  pcbNeeded,
    LPDWORD  pcReturned
)
{
    LPPROVIDOR  pProvidor;

    if ((pPrinterEnum == NULL) && (cbBuf != 0)) {
        SetLastError(ERROR_INVALID_USER_BUFFER);
        return FALSE;
    }

    WaitForSpoolerInitialization();

    if (RouterEnumPerMachineConnections(pServer, pPrinterEnum, cbBuf,
                                        pcbNeeded, pcReturned)) {

        return TRUE;

    } else if (GetLastError() != ERROR_INVALID_NAME) {

        return FALSE;
    }

    pProvidor = pLocalProvidor;
    while (pProvidor) {

       if ((*pProvidor->PrintProvidor.fpEnumPerMachineConnections)
                 (pServer, pPrinterEnum, cbBuf, pcbNeeded, pcReturned)) {

            return TRUE;
       }

       if (GetLastError() != ERROR_INVALID_NAME) {
           return FALSE;
       }

       pProvidor = pProvidor->pNext;
    }

    return FALSE;
}

PPRINTER_INFO_2
pGetPrinterInfo2(
    HANDLE hPrinter
    )

/*++

Routine Description:

    Retrieve a printer info 2 structure from an hPrinter.  Data must
    be FreeSplMem'd by caller.

Arguments:

    hPrinter - Printer to query.

Return Value:

    PRINTER_INFO_2 - On success, a valid structure.
    NULL - On failure.

--*/

{
    LPPRINTHANDLE  pPrintHandle=(LPPRINTHANDLE)hPrinter;
    DWORD cbPrinter = 0x1000;
    DWORD cbNeeded;
    PPRINTER_INFO_2 pPrinterInfo2;
    BOOL bSuccess = FALSE;

    if( pPrinterInfo2 = AllocSplMem( cbPrinter )){

        bSuccess = (*pPrintHandle->pProvidor->PrintProvidor.fpGetPrinter)
                         ( pPrintHandle->hPrinter,
                           2,
                           (PBYTE)pPrinterInfo2,
                           cbPrinter,
                           &cbNeeded );

        if( !bSuccess ){

            if( GetLastError() == ERROR_INSUFFICIENT_BUFFER ){

                FreeSplMem( pPrinterInfo2 );

                if (pPrinterInfo2 = (PPRINTER_INFO_2)AllocSplMem( cbNeeded )){

                    cbPrinter = cbNeeded;
                    bSuccess = (*pPrintHandle->pProvidor->PrintProvidor.fpGetPrinter)
                                     ( pPrintHandle->hPrinter,
                                       2,
                                       (PBYTE)pPrinterInfo2,
                                       cbPrinter,
                                       &cbNeeded );
                }
            }
        }
    }

    if( !bSuccess ){
        FreeSplMem( pPrinterInfo2 );
        return NULL;
    }

    return pPrinterInfo2;
}

VOID
SplDriverUnloadComplete(
    LPWSTR   pDriverFile
    )
/*++
Function Description:  Notify the print provider that the driver is being unloaded
                       so that it may continue with any pending driver upgrades.

Parameters: pDriverFile   -- name of the library that has been unloaded

Return Values: NONE
--*/
{
    LPPROVIDOR   pProvidor;

    for (pProvidor = pLocalProvidor; pProvidor; pProvidor = pProvidor->pNext) {
         if ((*pProvidor->PrintProvidor.fpDriverUnloadComplete)(pDriverFile)) {
             break;
         }
    }

    return;
}