windows-xp/Source/XPSP1/NT/printscan/print/spooler/localspl/monitor.c

/*++


Copyright (c) 1990 - 1996  Microsoft Corporation

Module Name:

    monitor.c

Abstract:

   This module contains all code for Monitor-based Spooler apis

   LocalEnumPorts
   LocalAddMonitor
   LocalDeleteMonitor
   LocalEnumMonitors
   LocalAddPort
   LocalConfigurePort
   LocalDeletePort

   Support Functions in monitor.c - (Warning! Do Not Add to this list!!)

   CopyIniMonitorToMonitor          -- KrishnaG
   GetMonitorSize                   -- KrishnaG

Author:

    Dave Snipp (DaveSn) 15-Mar-1991

Revision History:
    Khaled Sedky (khaleds) 15-March-2000
        - Added LocalSendRecvBidiData

    Muhunthan Sivapragasam (MuhuntS) 15-Jun-1995
        - Port info 2 changes

    Krishna Ganugapati (KrishnaG) 2-Feb-1994
        - reorganized the entire source file

    Matthew Felton (mattfe) June 1994 pIniSpooler

--*/

#include <precomp.h>
#include <offsets.h>
#include <clusspl.h>

//
// Private declarations
//

HDESK ghdeskServer = NULL;

//
// Function declarations
//



LPBYTE
CopyIniMonitorToMonitor(
    PINIMONITOR pIniMonitor,
    DWORD   Level,
    LPBYTE  pMonitorInfo,
    LPBYTE  pEnd
    );

DWORD
GetMonitorSize(
    PINIMONITOR  pIniMonitor,
    DWORD       Level
    );



BOOL
LocalEnumPorts(
    LPWSTR   pName,
    DWORD   Level,
    LPBYTE  pPorts,
    DWORD   cbBuf,
    LPDWORD pcbNeeded,
    LPDWORD pcReturned
)
{
    PINISPOOLER pIniSpooler;
    BOOL bReturn;

    pIniSpooler = FindSpoolerByNameIncRef( pName, NULL );

    if( !pIniSpooler ){
        return ROUTER_UNKNOWN;
    }

    bReturn = SplEnumPorts( pName,
                            Level,
                            pPorts,
                            cbBuf,
                            pcbNeeded,
                            pcReturned,
                            pIniSpooler );

    FindSpoolerByNameDecRef( pIniSpooler );
    return bReturn;
}


VOID
SplReenumeratePorts(
    )
{
    LPVOID  pBuf;
    DWORD   cbNeeded, dwDontCare;

    //
    // EnumPorts checks for new ports enumerated by port monitors and updates
    // localspl pIniPorts list
    //
    if ( !SplEnumPorts(NULL, 1, NULL, 0, &cbNeeded,
                       &dwDontCare, pLocalIniSpooler)               &&
         GetLastError() == ERROR_INSUFFICIENT_BUFFER                &&
         (pBuf = AllocSplMem(cbNeeded)) ) {

        SplEnumPorts(NULL, 1, pBuf, cbNeeded, &cbNeeded,
                     &dwDontCare, pLocalIniSpooler);
        FreeSplMem(pBuf);
    }
}


BOOL
GetPortInfo2UsingPortInfo1(
    PINIMONITOR     pIniMonitor,
    LPWSTR          pName,
    LPBYTE          pPorts,
    DWORD           cbBuf,
    LPDWORD         pcbNeeded,
    LPDWORD         pcReturned
    )
{

    BOOL            bRet;
    LPPORT_INFO_1   pPortInfo1;
    LPPORT_INFO_2   pPortInfo2;
    DWORD           cReturned;

    bRet =  (*pIniMonitor->Monitor2.pfnEnumPorts)(
                pIniMonitor->hMonitor,
                pName,
                1,
                pPorts,
                cbBuf,
                pcbNeeded,
                pcReturned );

    if ( !bRet ) {

        //
        // This is the upperbound
        //
        if ( GetLastError() == ERROR_INSUFFICIENT_BUFFER )
            *pcbNeeded += (*pcbNeeded / sizeof(PORT_INFO_1)) *
                                  (sizeof(PORT_INFO_2) - sizeof(PORT_INFO_1));
    } else {

        *pcbNeeded += *pcReturned * (sizeof(PORT_INFO_2) - sizeof(PORT_INFO_1));

        if ( *pcbNeeded <= cbBuf ) {

            cReturned = *pcReturned;
            while ( cReturned-- ) {

                pPortInfo1 = (LPPORT_INFO_1) (pPorts + cReturned * sizeof(PORT_INFO_1));
                pPortInfo2 = (LPPORT_INFO_2) (pPorts + cReturned * sizeof(PORT_INFO_2));

                pPortInfo2->pPortName    = pPortInfo1->pName;
                pPortInfo2->pMonitorName = NULL;
                pPortInfo2->pDescription = NULL;
                pPortInfo2->fPortType    = 0;
                pPortInfo2->Reserved     = 0;
            }
        } else {

            *pcReturned = 0;
            bRet = FALSE;
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
        }
    }

    return bRet;
}


BOOL
SplEnumPorts(
    LPWSTR   pName,
    DWORD   Level,
    LPBYTE  pPorts,
    DWORD   cbBuf,
    LPDWORD pcbNeeded,
    LPDWORD pcReturned,
    PINISPOOLER pIniSpooler
)
{
    PINIMONITOR     pIniMonitor;
    DWORD           dwIndex, cReturned=0, cbStruct, TotalcbNeeded=0;
    LPBYTE          pBuffer = pPorts, pTemp;
    DWORD           Error=0, TempError  = 0;
    DWORD           BufferSize=cbBuf;
    LPWSTR          pPortName;
    PINIPORT        pIniPort;
    HANDLE          hToken;
    BOOL            bRemoteCall;


    if (!MyName( pName, pIniSpooler )) {

        return FALSE;
    }

    //
    // HACK: Some monitors choke if pName is non-NULL.  We can make
    // it NULL at this point since we know that we're using the same
    // ports on the local machine.
    //
    pName = NULL;

    if ( !ValidateObjectAccess(SPOOLER_OBJECT_SERVER,
                               SERVER_ACCESS_ENUMERATE,
                               NULL, NULL, pIniSpooler )) {

        return FALSE;
    }

    switch (Level) {

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

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

    default:
        return ERROR_INVALID_LEVEL;
    }

    bRemoteCall = !IsLocalCall();

    //
    // We revert to local system context only when the caller is remote.
    // The monitors may load dlls from system32 and remote users like
    // guest or anonymous logon do not have sufficient privileges for that.
    // This is safe to revert to self since we do not support delegation, so 
    // we will never use the credentials of the remote user to go remote again.
    // If the caller is logged on interactively, then we do not switch the
    // context. Thus, a monitor may be able to go on the network for the port
    // enumeration.
    //
    if (bRemoteCall && !(hToken = RevertToPrinterSelf()))
    {
        return FALSE;
    }

    for ( pIniMonitor = pIniSpooler->pIniMonitor ;
          pIniMonitor ;
          pIniMonitor = pIniMonitor->pNext ) {

        //
        // Lang monitor does not have to define this
        //
        if ( !pIniMonitor->Monitor2.pfnEnumPorts )
            continue;

        *pcReturned = 0;

        *pcbNeeded = 0;

        if (!(*pIniMonitor->Monitor2.pfnEnumPorts)(
                   pIniMonitor->hMonitor,
                   pName,
                   Level,
                   pPorts,
                   BufferSize,
                   pcbNeeded,
                   pcReturned)) {

            TempError = GetLastError();
            //
            // Level 2 is a superset of level 1. So we can make a level 1
            // call if the monitor does not support it
            //
            if ( Level == 2 && TempError == ERROR_INVALID_LEVEL ) {

                TempError = 0;
                if ( !GetPortInfo2UsingPortInfo1(pIniMonitor,
                                                 pName,
                                                 pPorts,
                                                 BufferSize,
                                                 pcbNeeded,
                                                 pcReturned) )
                    TempError = GetLastError();
            }

            if ( TempError ) {

                Error = TempError;

                *pcReturned = 0;

                if ( TempError != ERROR_INSUFFICIENT_BUFFER ) {

                    *pcbNeeded  = 0;
                    break;
                }
            }
        } else {

            //
            // Now we look for new ports not in pIniPort list and add them
            //
            EnterSplSem();

            for ( dwIndex = 0, pTemp = pPorts ;
                  dwIndex < *pcReturned ;
                  ++dwIndex ) {

                switch ( Level ) {

                    case 1:
                        pPortName   = ((LPPORT_INFO_1)pTemp)->pName;
                        pTemp      += sizeof(PORT_INFO_1);
                        break;

                    case 2:
                        pPortName   = ((LPPORT_INFO_2)pTemp)->pPortName;
                        pTemp      += sizeof(PORT_INFO_2);
                        break;

                    default:
                        SPLASSERT(Level == 1 || Level == 2);
                }

                pIniPort = FindPort(pPortName, pIniSpooler);
                if ( !pIniPort ) {
                    CreatePortEntry(pPortName, pIniMonitor, pIniSpooler);

                } else if ( !pIniPort->pIniMonitor ) {
                    //
                    // If a fake port gets eventually enumerated by a monitor, 
                    // update the pIniPort structure (USB monitor). It is no
                    // longer a placeholder port at this point.
                    //
                    pIniPort->pIniMonitor = pIniMonitor;
                    pIniPort->Status |= PP_MONITOR;   
                    pIniPort->Status &= ~PP_PLACEHOLDER;                    
                }
            }

            LeaveSplSem();
        }


        cReturned += *pcReturned;

        pPorts += *pcReturned * cbStruct;

        if (*pcbNeeded <= BufferSize)
            BufferSize -= *pcbNeeded;
        else
            BufferSize = 0;

        TotalcbNeeded += *pcbNeeded;
    }

    if (bRemoteCall) 
    {
        ImpersonatePrinterClient(hToken);
    }

    *pcbNeeded = TotalcbNeeded;

    *pcReturned = cReturned;


    if (Error) {

        SetLastError(Error);
        return FALSE;
    } else if (TotalcbNeeded > cbBuf ) {

        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    } else {

        //
        // Stop routing if this is a cluster'd spooler.  Otherwise,
        // we'll talk to win32spl, which RPCs to us again.
        //
        if( pIniSpooler->SpoolerFlags & SPL_TYPE_CLUSTER ){
            return ROUTER_STOP_ROUTING;
        }
        return TRUE;
    }
}


BOOL
LocalEnumMonitors(
    LPWSTR   pName,
    DWORD   Level,
    LPBYTE  pMonitors,
    DWORD   cbBuf,
    LPDWORD pcbNeeded,
    LPDWORD pcReturned
)
{
    PINISPOOLER pIniSpooler;
    BOOL bReturn;

    pIniSpooler = FindSpoolerByNameIncRef( pName, NULL );

    if( !pIniSpooler ){
        return ROUTER_UNKNOWN;
    }

    bReturn = SplEnumMonitors( pName, Level, pMonitors, cbBuf,
                               pcbNeeded, pcReturned, pIniSpooler );


    FindSpoolerByNameDecRef( pIniSpooler );
    return bReturn;
}



BOOL
SplEnumMonitors(
    LPWSTR   pName,
    DWORD   Level,
    LPBYTE  pMonitors,
    DWORD   cbBuf,
    LPDWORD pcbNeeded,
    LPDWORD pcReturned,
    PINISPOOLER pIniSpooler
)
{
    PINIMONITOR pIniMonitor;
    DWORD   cReturned=0, cbStruct, cb;
    LPBYTE  pBuffer = pMonitors;
    DWORD   BufferSize=cbBuf, rc;
    LPBYTE  pEnd;

    if (!MyName( pName, pIniSpooler )) {

        return ROUTER_UNKNOWN;
    }

    if ( !ValidateObjectAccess(SPOOLER_OBJECT_SERVER,
                               SERVER_ACCESS_ENUMERATE,
                               NULL, NULL, pIniSpooler )) {

        return ROUTER_UNKNOWN;
    }

    switch (Level) {

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

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

    default:
        SetLastError(ERROR_INVALID_LEVEL);
        return ROUTER_UNKNOWN;
    }

   EnterSplSem();

    for ( cb = 0, pIniMonitor = pIniSpooler->pIniMonitor ;
          pIniMonitor ;
          pIniMonitor = pIniMonitor->pNext ) {

        //
        // We'll not enumerate monitors which do not support AddPort
        //
        if ( pIniMonitor->Monitor2.pfnAddPort ||
             pIniMonitor->Monitor2.pfnXcvOpenPort)
            cb+=GetMonitorSize(pIniMonitor, Level);
    }

    *pcbNeeded = cb;
    *pcReturned = 0;

    if (cb <= cbBuf) {

        pEnd=pMonitors + cbBuf;

        for ( pIniMonitor = pIniSpooler->pIniMonitor ;
              pIniMonitor ;
              pIniMonitor = pIniMonitor->pNext ) {

            //
            // We'll not enumerate monitors which do not support AddPort
            //
            if ( !pIniMonitor->Monitor2.pfnAddPort &&
                 !pIniMonitor->Monitor2.pfnXcvOpenPort )
                continue;

            pEnd = CopyIniMonitorToMonitor(pIniMonitor, Level, pMonitors, pEnd);

            switch (Level) {

            case 1:
                pMonitors+=sizeof(MONITOR_INFO_1);
                break;

            case 2:
                pMonitors+=sizeof(MONITOR_INFO_2);
                break;
            }

            (*pcReturned)++;
        }

        if( pIniSpooler->SpoolerFlags & SPL_TYPE_CLUSTER ){

            //
            // Stop routing, since we don't want any one else to report
            // back monitors.  If we're on the local machine now and
            // we continue routing, win32spl will RPC back to ourself
            // and re-enumerate the same ports.
            //
            rc = ROUTER_STOP_ROUTING;

        } else {

            rc = ROUTER_SUCCESS;
        }

    } else {

        rc = ROUTER_UNKNOWN;
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
    }

   LeaveSplSem();

    return rc;
}

BOOL
LocalAddPort(
    LPWSTR   pName,
    HWND    hWnd,
    LPWSTR   pMonitorName
)
{
    PINISPOOLER pIniSpooler;
    BOOL bReturn;

    pIniSpooler = FindSpoolerByNameIncRef( pName, NULL );

    if( !pIniSpooler ){
        return ROUTER_UNKNOWN;
    }

    bReturn = SplAddPort( pName, hWnd, pMonitorName, pIniSpooler );

    FindSpoolerByNameDecRef( pIniSpooler );
    return bReturn;
}





BOOL
SplAddPort(
    LPWSTR   pName,
    HWND    hWnd,
    LPWSTR   pMonitorName,
    PINISPOOLER pIniSpooler
)
{
    PINIMONITOR pIniMonitor;
    BOOL        rc=FALSE;

    if (!MyName( pName, pIniSpooler )) {

        return FALSE;
    }

    if ( !ValidateObjectAccess(SPOOLER_OBJECT_SERVER,
                               SERVER_ACCESS_ADMINISTER,
                               NULL, NULL, pIniSpooler )) {

        return FALSE;
    }

   EnterSplSem();
    SPLASSERT( pIniSpooler->signature == ISP_SIGNATURE );
    pIniMonitor = FindMonitor(pMonitorName, pIniSpooler);
   LeaveSplSem();

    if ( pIniMonitor ) {

        if ( pIniMonitor->Monitor2.pfnAddPort )
            rc = (*pIniMonitor->Monitor2.pfnAddPort)(
                       pIniMonitor->hMonitor,
                       pName,
                       hWnd,
                       pMonitorName );
        else
            SetLastError(ERROR_INVALID_PARAMETER);
    }
    else {

        SetLastError(ERROR_INVALID_NAME);
    }

    if (rc)
        rc = AddPortToSpooler(pName, pIniMonitor, pIniSpooler);

    return rc;
}


BOOL
AddPortToSpooler(
    PCWSTR      pName,
    PINIMONITOR pIniMonitor,
    PINISPOOLER pIniSpooler
)
{
    DWORD i, cbNeeded, cbDummy, cReturned;
    PPORT_INFO_1    pPorts;
    PINIPORT        pIniPort;


    /* If we don't already have the port in our local cache, add it:
     */
    if (!(*pIniMonitor->Monitor2.pfnEnumPorts)(
               pIniMonitor->hMonitor,
               (PWSTR)pName,
               1,
               NULL,
               0,
               &cbNeeded,
               &cReturned)) {

        pPorts = AllocSplMem(cbNeeded);

        if (pPorts) {

            if ((*pIniMonitor->Monitor2.pfnEnumPorts)(
                      pIniMonitor->hMonitor,
                      (PWSTR)pName,
                      1,
                      (LPBYTE)pPorts,
                      cbNeeded,
                      &cbDummy,
                      &cReturned)) {

               EnterSplSem();

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

                    pIniPort = FindPort(pPorts[i].pName, pIniSpooler);
                    if ( !pIniPort ) {
                        CreatePortEntry(pPorts[i].pName, pIniMonitor, pIniSpooler);

                    //
                    // If we have a port without a monitor and it gets added at
                    // this time. Remove the placeholder status from it.
                    //
                    } else if ( !pIniPort->pIniMonitor ) {
                            pIniPort->pIniMonitor = pIniMonitor;
                            pIniPort->Status |= PP_MONITOR;
                            pIniPort->Status &= ~PP_PLACEHOLDER;
                    }
                }

               LeaveSplSem();
            }

            FreeSplMem(pPorts);
        }
    }

    EnterSplSem();
    SetPrinterChange(NULL,
                     NULL,
                     NULL,
                     PRINTER_CHANGE_ADD_PORT,
                     pIniSpooler);
    LeaveSplSem();

    return TRUE;
}


BOOL
LocalConfigurePort(
    LPWSTR   pName,
    HWND     hWnd,
    LPWSTR   pPortName
)
{
    PINISPOOLER pIniSpooler;
    BOOL bReturn;

    pIniSpooler = FindSpoolerByNameIncRef( pName, NULL );

    if( !pIniSpooler ){
        return ROUTER_UNKNOWN;
    }

    bReturn = SplConfigurePort( pName, hWnd, pPortName, pIniSpooler );

    FindSpoolerByNameDecRef( pIniSpooler );
    return bReturn;
}



BOOL
SplConfigurePort(
    LPWSTR   pName,
    HWND     hWnd,
    LPWSTR   pPortName,
    PINISPOOLER pIniSpooler
)
{
    PINIPORT    pIniPort;
    BOOL        rc;

    if (!MyName( pName, pIniSpooler )) {

        return FALSE;
    }

    if ( !ValidateObjectAccess(SPOOLER_OBJECT_SERVER,
                               SERVER_ACCESS_ADMINISTER,
                               NULL, NULL, pIniSpooler )) {

        return FALSE;
    }

   EnterSplSem();
    pIniPort = FindPort(pPortName, pIniSpooler);
   LeaveSplSem();

    if ((pIniPort) && (pIniPort->Status & PP_MONITOR)) {

        if ( !pIniPort->pIniMonitor->Monitor2.pfnConfigurePort ) {

            SetLastError(ERROR_NOT_SUPPORTED);
            return FALSE;
        }

        if (rc = (*pIniPort->pIniMonitor->Monitor2.pfnConfigurePort)(
                       pIniPort->pIniMonitor->hMonitor,
                       pName,
                       hWnd,
                       pPortName)) {

            EnterSplSem();

            SetPrinterChange(NULL,
                             NULL,
                             NULL,
                             PRINTER_CHANGE_CONFIGURE_PORT,
                             pIniSpooler);
            LeaveSplSem();
        }

        return rc;
    }

    SetLastError(ERROR_UNKNOWN_PORT);
    return FALSE;
}


BOOL
LocalDeletePort(
    LPWSTR   pName,
    HWND    hWnd,
    LPWSTR   pPortName
)
{
    PINISPOOLER pIniSpooler;
    BOOL bReturn;

    pIniSpooler = FindSpoolerByNameIncRef( pName, NULL );

    if( !pIniSpooler ){
        return ROUTER_UNKNOWN;
    }

    bReturn = SplDeletePort( pName,
                             hWnd,
                             pPortName,
                             pIniSpooler );

    FindSpoolerByNameDecRef( pIniSpooler );
    return bReturn;
}



BOOL
SplDeletePort(
    LPWSTR   pName,
    HWND    hWnd,
    LPWSTR   pPortName,
    PINISPOOLER pIniSpooler
)
{
    PINIPORT    pIniPort;
    BOOL        rc=FALSE;

    if (!MyName( pName, pIniSpooler )) {

        return FALSE;
    }

    if ( !ValidateObjectAccess(SPOOLER_OBJECT_SERVER,
                               SERVER_ACCESS_ADMINISTER,
                               NULL, NULL, pIniSpooler )) {

        return FALSE;
    }

    EnterSplSem();

    pIniPort = FindPort(pPortName, pIniSpooler);

    if ( !pIniPort || !(pIniPort->Status & PP_MONITOR) ) {
        LeaveSplSem();
        SetLastError(ERROR_UNKNOWN_PORT);
        return FALSE;
    }

    if( !pIniPort->pIniMonitor->Monitor2.pfnDeletePort ){
        LeaveSplSem();
        SetLastError( ERROR_NOT_SUPPORTED );
        return FALSE;
    }

    rc = DeletePortFromSpoolerStart( pIniPort );

    LeaveSplSem();

    if (!rc)
        goto Cleanup;

    rc = (*pIniPort->pIniMonitor->Monitor2.pfnDeletePort)(
               pIniPort->pIniMonitor->hMonitor,
               pName,
               hWnd,
               pPortName);

    rc = DeletePortFromSpoolerEnd(pIniPort, pIniSpooler, rc);

Cleanup:
    SplOutSem();
    return rc;
}



BOOL
DeletePortFromSpoolerEnd(
    PINIPORT    pIniPort,
    PINISPOOLER pIniSpooler,
    BOOL        bSuccess
)
{

    EnterSplSem();

    if(bSuccess) {

        DeletePortEntry( pIniPort );

        //
        // Success, delete the port data and send a notification.
        //
        SetPrinterChange( NULL,
                          NULL,
                          NULL,
                          PRINTER_CHANGE_DELETE_PORT,
                          pIniSpooler );
    } else {

        //
        // Add it back.  If the name is already used (e.g., just added
        // while we were out of the critical section), we're in trouble,
        // but there's not much we can do about it.  (When we restart,
        // we'll re-enumerate the duplicate name from the monitors
        // anyway.)
        //
        DBGMSG( DBG_WARN, ( "SplDeletePort: port.DeletePort failed %d\n", GetLastError()));
        LinkPortToSpooler( pIniPort, pIniSpooler );
    }

    LeaveSplSem();
    SplOutSem();

    return bSuccess;
}


BOOL
DeletePortFromSpoolerStart(
    PINIPORT    pIniPort
    )
{
    BOOL        rc = FALSE;
    PINISPOOLER pIniSpooler = pIniPort->pIniSpooler;

    SplInSem();

    if ( pIniPort->cPrinters || pIniPort->cRef || pIniPort->cJobs ) {

        SetLastError(ERROR_BUSY);
        goto Cleanup;
    }

    //
    // Remove it from the linked list so that no one will try to grab
    // a reference to while we're deleting it.
    //
    DelinkPortFromSpooler( pIniPort, pIniSpooler );
    rc = TRUE;


Cleanup:

    return rc;
}



BOOL
LocalAddMonitor(
    LPWSTR  pName,
    DWORD   Level,
    LPBYTE  pMonitorInfo
)
{
    PINISPOOLER pIniSpooler;
    BOOL bReturn;

    pIniSpooler = FindSpoolerByNameIncRef( pName, NULL );

    if( !pIniSpooler ){
        return ROUTER_UNKNOWN;
    }

    bReturn = SplAddMonitor( pName,
                             Level,
                             pMonitorInfo,
                             pIniSpooler );

    FindSpoolerByNameDecRef( pIniSpooler );
    return bReturn;
}




BOOL
SplAddMonitor(
    LPWSTR  pName,
    DWORD   Level,
    LPBYTE  pMonitorInfo,
    PINISPOOLER pIniSpooler
)
{
    PINIMONITOR  pIniMonitor;
    PMONITOR_INFO_2  pMonitor = (PMONITOR_INFO_2)pMonitorInfo;
    HANDLE  hToken;
    HKEY    hKey;
    LONG    Status;
    BOOL    rc = FALSE;
    DWORD   dwPathLen = 0;

    if (!MyName( pName, pIniSpooler )) {

        return FALSE;
    }

    if ( !ValidateObjectAccess(SPOOLER_OBJECT_SERVER,
                               SERVER_ACCESS_ADMINISTER,
                               NULL, NULL, pIniSpooler )) {

        return FALSE;
    }

    if (Level != 2) {

        SetLastError( ERROR_INVALID_LEVEL );
        return FALSE;
    }

    if (!pMonitor            ||
        !pMonitor->pName     ||
        !*pMonitor->pName) {

        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }

    if (!pMonitor->pEnvironment  ||
        !*pMonitor->pEnvironment ||
        lstrcmpi(pMonitor->pEnvironment, szEnvironment)) {

        SetLastError( ERROR_INVALID_ENVIRONMENT );
        return FALSE;
    }

    if (!pMonitor->pDLLName  ||
        !*pMonitor->pDLLName ){

        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }


   EnterSplSem();

    if (FindMonitor(pMonitor->pName, pIniSpooler)) {

        LeaveSplSem();
        SetLastError(ERROR_PRINT_MONITOR_ALREADY_INSTALLED);
        return FALSE;
    }

    hToken = RevertToPrinterSelf();

    pIniMonitor = CreateMonitorEntry(pMonitor->pDLLName,
                                     pMonitor->pName,
                                     pIniSpooler);

    if (pIniMonitor != (PINIMONITOR)-1) {

        WCHAR   szRegistryRoot[MAX_PATH];
        PINISPOOLER pIniSpoolerMonitor;
        HANDLE hKeyOut;
        LPCWSTR pszPathOut;

        //
        // Note that even though this is built once per pIniSpooler, the
        // list of monitors is the same for all spoolers.  However, the
        // ports that the monitor returns from EnumPorts is different for
        // each pIniSpooler (for clustering).
        //
        // If it's not local, then it could be a cached win32 monitor.
        //
        if( pIniSpooler->SpoolerFlags & SPL_TYPE_LOCAL ){
            pIniSpoolerMonitor = pLocalIniSpooler;
        } else {
            pIniSpoolerMonitor = pIniSpooler;
        }

        //
        // Build the registry path.  In some cases it's a relative
        // path from hckRoot; other times it's a hard coded path from
        // HKLM (e.g., win32spl).
        //
        GetRegistryLocation( pIniSpoolerMonitor->hckRoot,
                             pIniSpoolerMonitor->pszRegistryMonitors,
                             &hKeyOut,
                             &pszPathOut );

        Status = StrNCatBuff( szRegistryRoot, 
                              COUNTOF(szRegistryRoot), 
                              pszPathOut,
                              L"\\",
                              pMonitor->pName,
                              NULL );
        
        if (Status == ERROR_SUCCESS)
        {

            Status = RegCreateKeyEx( hKeyOut,
                                     szRegistryRoot,
                                     0,
                                     NULL,
                                     0,
                                     KEY_WRITE,
                                     NULL,
                                     &hKey,
                                     NULL );
    
            if (Status == ERROR_SUCCESS) {
    
                Status = RegSetValueEx( hKey,
                                        L"Driver",
                                        0,
                                        REG_SZ,
                                        (LPBYTE)pMonitor->pDLLName,
                                        (wcslen(pMonitor->pDLLName) + 1)*sizeof(WCHAR));
    
                if (Status == ERROR_SUCCESS) {
                    rc = TRUE;
                } else {
                    SetLastError( Status );
                }
    
                RegCloseKey(hKey);
    
            } else {
                SetLastError( Status );
            }
        }
        else
        {
            SetLastError(Status);
        }

    }

    ImpersonatePrinterClient(hToken);

    //
    //  Bug 54843 if this fails we could still have a IniMonitor on the linked list that
    //  is BAD, it should be removed.  MattFe 19th Jan 95
    //  Note *maybe* we do this because a monitor might fail to initialize
    //  but will correctly function next time you reboot, like hpmon ( dlc doesn't become active until
    //  the next reboot.   Please Verify.

   LeaveSplSem();

    if ( !rc ) {
        DBGMSG( DBG_WARNING, ("SplAddMonitor failed %d\n", GetLastError() ));
    }

    return rc;
}

BOOL
LocalDeleteMonitor(
    LPWSTR   pName,
    LPWSTR   pEnvironment,
    LPWSTR   pMonitorName
)
{
    PINISPOOLER pIniSpooler;
    BOOL bReturn;

    pIniSpooler = FindSpoolerByNameIncRef( pName, NULL );

    if( !pIniSpooler ){
        return ROUTER_UNKNOWN;
    }

    bReturn = SplDeleteMonitor( pName,
                                pEnvironment,
                                pMonitorName,
                                pIniSpooler );

    FindSpoolerByNameDecRef( pIniSpooler );
    return bReturn;
}




BOOL
SplDeleteMonitor(
    LPWSTR   pName,
    LPWSTR   pEnvironment,
    LPWSTR   pMonitorName,
    PINISPOOLER pIniSpooler
)
{
    BOOL    Remote=FALSE;
    PINIMONITOR pIniMonitor;
    PINIPORT    pIniPort, pIniPortNext;
    HKEY    hKeyMonitors, hKey;
    LONG    Status;
    BOOL    rc = FALSE;
    HANDLE  hToken;
    HANDLE hKeyOut;
    LPCWSTR pszPathOut;

    if (pName && *pName) {

        if (!MyName( pName, pIniSpooler )) {

            return FALSE;

        } else {

            Remote=TRUE;
        }
    }

    if ((pMonitorName == NULL) || (*pMonitorName == L'\0')) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    if ( !ValidateObjectAccess(SPOOLER_OBJECT_SERVER,
                               SERVER_ACCESS_ADMINISTER,
                               NULL, NULL, pIniSpooler )) {

        return FALSE;
    }

    EnterSplSem();

    if (!(pIniMonitor=(PINIMONITOR)FindMonitor(pMonitorName,
                                               pIniSpooler))) {

        SetLastError(ERROR_UNKNOWN_PRINT_MONITOR);
        LeaveSplSem();
        return FALSE;
    }

    if ( pIniMonitor->cRef ) {

        SetLastError(ERROR_PRINT_MONITOR_IN_USE);
        LeaveSplSem();
        return FALSE;
    }

    pIniPort = pIniSpooler->pIniPort;

    while (pIniPort) {

        if ((pIniPort->pIniMonitor == pIniMonitor) &&
            (pIniPort->cPrinters || pIniPort->cRef)) {

            SetLastError(ERROR_BUSY);
            LeaveSplSem();
            return FALSE;
        }

        pIniPort = pIniPort->pNext;
    }

    hToken = RevertToPrinterSelf();

    GetRegistryLocation( pIniSpooler->hckRoot,
                         pIniSpooler->pszRegistryMonitors,
                         &hKeyOut,
                         &pszPathOut );

    Status = SplRegOpenKey(hKeyOut,
                           pszPathOut,
                           KEY_READ | KEY_WRITE,
                           &hKeyMonitors,
                           pIniSpooler);

    if (Status == ERROR_SUCCESS)
    {
        Status = SplRegOpenKey(hKeyMonitors, 
                               pMonitorName,
                               KEY_READ | KEY_WRITE, 
                               &hKey,
                               pIniSpooler);

        if (Status == ERROR_SUCCESS)
        {
            Status = DeleteSubkeys(hKey, pIniSpooler);

            SplRegCloseKey(hKey, pIniSpooler);

            if (Status == ERROR_SUCCESS)
                Status = SplRegDeleteKey(hKeyMonitors, pMonitorName, pIniSpooler);
        }

        SplRegCloseKey(hKeyMonitors, pIniSpooler);
    }


    if (Status == ERROR_SUCCESS) {

        pIniPort = pIniSpooler->pIniPort;

        while (pIniPort) {

            pIniPortNext = pIniPort->pNext;

            if (pIniPort->pIniMonitor == pIniMonitor)
                DeletePortEntry(pIniPort);

            pIniPort = pIniPortNext;
        }

        RemoveFromList((PINIENTRY *)&pIniSpooler->pIniMonitor,
                       (PINIENTRY)pIniMonitor);

        FreeIniMonitor( pIniMonitor );

        rc = TRUE;

    }

    if (Status != ERROR_SUCCESS)
        SetLastError(Status);

    ImpersonatePrinterClient(hToken);

    LeaveSplSem();

    return rc;
}

LPBYTE
CopyIniMonitorToMonitor(
    PINIMONITOR pIniMonitor,
    DWORD   Level,
    LPBYTE  pMonitorInfo,
    LPBYTE  pEnd
)
{
    LPWSTR *pSourceStrings, *SourceStrings;
    DWORD j;
    DWORD *pOffsets;

    switch (Level) {

    case 1:
        pOffsets = MonitorInfo1Strings;
        break;

    case 2:
        pOffsets = MonitorInfo2Strings;
        break;

    default:
        return pEnd;
    }

    for (j=0; pOffsets[j] != -1; j++) {
    }

    SourceStrings = pSourceStrings = AllocSplMem(j * sizeof(LPWSTR));

    if (!SourceStrings) {
        DBGMSG(DBG_WARNING, ("Failed to alloc Port source strings.\n"));
        return pEnd;
    }

    switch (Level) {

    case 1:
        *pSourceStrings++=pIniMonitor->pName;
        break;

    case 2:
        *pSourceStrings++=pIniMonitor->pName;
        *pSourceStrings++=szEnvironment;
        *pSourceStrings++=pIniMonitor->pMonitorDll;
        break;
    }

    pEnd = PackStrings(SourceStrings, pMonitorInfo, pOffsets, pEnd);
    FreeSplMem(SourceStrings);

    return pEnd;
}

DWORD
GetMonitorSize(
    PINIMONITOR  pIniMonitor,
    DWORD       Level
)
{
    DWORD cb=0;

    switch (Level) {

    case 1:
        cb=sizeof(MONITOR_INFO_1) + wcslen(pIniMonitor->pName)*sizeof(WCHAR) +
                                    sizeof(WCHAR);
        break;

    case 2:
        cb = wcslen(pIniMonitor->pName) + 1 + wcslen(pIniMonitor->pMonitorDll) + 1
                                            + wcslen(szEnvironment) + 1;
        cb *= sizeof(WCHAR);
        cb += sizeof(MONITOR_INFO_2);
        break;

    default:

        cb = 0;
        break;
    }

    return cb;
}


BOOL
LocalAddPortEx(
    LPWSTR   pName,
    DWORD    Level,
    LPBYTE   pBuffer,
    LPWSTR   pMonitorName
)
{
    return  ( SplAddPortEx( pName,
                            Level,
                            pBuffer,
                            pMonitorName,

                            pLocalIniSpooler ));
}


BOOL
SplAddPortEx(
    LPWSTR   pName,
    DWORD    Level,
    LPBYTE   pBuffer,
    LPWSTR   pMonitorName,
    PINISPOOLER pIniSpooler
)
{
   PINIMONITOR pIniMonitor;
    BOOL        rc=FALSE;
    DWORD       i, cbNeeded, cReturned, cbDummy;
    PPORT_INFO_1    pPorts = NULL;
    PINIPORT        pIniPort;

    if (!MyName( pName, pIniSpooler )) {

        return FALSE;
    }

    if ( !ValidateObjectAccess(SPOOLER_OBJECT_SERVER,
                               SERVER_ACCESS_ADMINISTER,
                               NULL, NULL, pIniSpooler )) {

        return FALSE;
    }

   EnterSplSem();
   pIniMonitor = FindMonitor(pMonitorName, pIniSpooler);
   LeaveSplSem();

   if (!pIniMonitor) {
       SetLastError(ERROR_INVALID_NAME);
       return(FALSE);
   }

   if (pIniMonitor->Monitor2.pfnAddPortEx) {
    rc = (*pIniMonitor->Monitor2.pfnAddPortEx)(
               pIniMonitor->hMonitor,
               pName,
               Level,
               pBuffer,
               pMonitorName);
   }
   if (!rc) {
       return(FALSE);
   }

   if (!(*pIniMonitor->Monitor2.pfnEnumPorts)(
              pIniMonitor->hMonitor,
              pName,
              1,
              NULL,
              0,
              &cbNeeded,
              &cReturned)) {

       pPorts = AllocSplMem(cbNeeded);
   }

   if (pPorts) {
       if ((*pIniMonitor->Monitor2.pfnEnumPorts)(
                 pIniMonitor->hMonitor,
                 pName,
                 1,
                 (LPBYTE)pPorts,
                 cbNeeded,
                 &cbDummy,
                 &cReturned)) {

           EnterSplSem();

           for (i = 0; i < cReturned; i++) {
               
                pIniPort = FindPort(pPorts[i].pName, pIniSpooler);
                if ( !pIniPort ) {
                    CreatePortEntry(pPorts[i].pName, pIniMonitor, pIniSpooler);

                } else if ( !pIniPort->pIniMonitor ) {
                    pIniPort->pIniMonitor = pIniMonitor;
                    pIniPort->Status |= PP_MONITOR;                
                }
           }
           LeaveSplSem();
       }

       FreeSplMem(pPorts);
   }

    EnterSplSem();
    SetPrinterChange(NULL,
                     NULL,
                     NULL,
                     PRINTER_CHANGE_ADD_PORT,
                     pIniSpooler);
    LeaveSplSem();

    return rc;
}


VOID
LinkPortToSpooler(
    PINIPORT pIniPort,
    PINISPOOLER pIniSpooler
    )

/*++

Routine Description:

    Links a pIniPort onto the pIniSpooler.

Arguments:

    pIniPort - Port to link; must not already be on a ll.

    pIniSpooler - Provides ll for pIniPort.

Return Value:

--*/

{
    SplInSem();
    SPLASSERT( !pIniPort->pIniSpooler );

    pIniPort->pNext = pIniSpooler->pIniPort;
    pIniPort->pIniSpooler = pIniSpooler;
    pIniSpooler->pIniPort = pIniPort;
}

VOID
DelinkPortFromSpooler(
    PINIPORT pIniPort,
    PINISPOOLER pIniSpooler
    )

/*++

Routine Description:

    Remove a pIniPort from a pIniSpooler->pIniPort linked list.  The
    pIniPort may or may not be on the list; if it isn't, then this
    routine does nothing.

    Generic delink code ripped out into a subroutine.

    The refcount on pIniPort must be zero.  Anyone that uses pIniPort
    must hold a reference, since it may be deleted outside the
    SplSem when cRef==0.

Arguments:

    pIniPort - Port to delink from the list.  May or may not be on
        pIniSpooler->pIniPort.

    pIniSpooler - Linked list from which the pIniPort will be removed.

Return Value:

--*/

{
    PINIPORT *ppCurPort;

    SplInSem();
    SPLASSERT( !pIniPort->cRef );

    //
    // Keep searching for pIniPort until we hit the end of the
    // list or we've found it.
    //
    for( ppCurPort = &pIniSpooler->pIniPort;
         *ppCurPort && *ppCurPort != pIniPort;
         ppCurPort = &((*ppCurPort)->pNext )){

        ; // Don't do anything.
    }

    //
    // If we found it, delink it.
    //
    if( *ppCurPort ){
        *ppCurPort = (*ppCurPort)->pNext;

        //
        // Null out the back pointer since we have removed it from
        // the pIniSpooler.
        //
        pIniPort->pIniSpooler = NULL;
    }
}

/*++
    Function Name:
        LocalSendRecvBidiData
        
    Description:
        This function is the providor point of communicating with 
        Monitors supporting BIDI data. It allows the providor to 
        set data in the printer and query data from the printer
     
     Parameters:
        hPrinter    : This could be a Printer/Port Handle
        dwAccessBit : Priverledges allowed to the accessing thread
        pAction     :
        pReqData    : Request encapsulatig the queries in an array
        ppResData   : Response returned to client in an array of Data
        
        
     Return Value:
        Win32 Error Code
--*/

DWORD
LocalSendRecvBidiData(
    IN  HANDLE                    hPrinter,
    IN  LPCTSTR                   pAction,
    IN  PBIDI_REQUEST_CONTAINER   pReqData,
    OUT PBIDI_RESPONSE_CONTAINER* ppResData
)
{
    DWORD        dwRet        = ERROR_SUCCESS;
    PSPOOL       pSpool       = (PSPOOL)hPrinter;
    PINIPORT     pIniPort     = NULL;
    PINIMONITOR  pIniMonitor  = NULL;

    EnterSplSem();
    {
        //
        // Process of validating the parameters
        //
        if((!pAction || !*pAction)   ||
           (!pReqData && !ppResData))
        {
            dwRet = ERROR_INVALID_PARAMETER;
        }
        else
        {
            if (!ValidateSpoolHandle( pSpool, PRINTER_HANDLE_SERVER ))
            {
                dwRet = ERROR_INVALID_HANDLE;
            }
            else
            {
                if(pSpool->TypeofHandle & PRINTER_HANDLE_PRINTER)
                {
                    PINIPRINTER     pIniPrinter;
                    PINIMONITOR     pIniLangMonitor = NULL;
                    
                    if(pIniPrinter = pSpool->pIniPrinter)
                    {
                        pIniPort = FindIniPortFromIniPrinter( pIniPrinter );

                        if (pIniPort)
                        {
                        
                            pIniLangMonitor = pIniPrinter->pIniDriver->pIniLangMonitor;
                            
                            if ( pIniLangMonitor &&
                                 !pIniLangMonitor->Monitor2.pfnSendRecvBidiDataFromPort )
                                pIniLangMonitor = NULL;
    
    
                            //
                            // Port needs to be opened?
                            //
                            if ( pIniPort->pIniLangMonitor != pIniLangMonitor ||
                                 !pIniPort->hPort ) 
                            {
                                LPTSTR pszPrinter;
                                TCHAR szFullPrinter[ MAX_UNC_PRINTER_NAME ];
                                
                                if( pIniPrinter->pIniSpooler->SpoolerFlags & SPL_TYPE_CLUSTER )
                                {
                                    pszPrinter = szFullPrinter;
                                    wsprintf( szFullPrinter,
                                              L"%ws\\%ws",
                                              pIniPrinter->pIniSpooler->pMachineName,
                                              pIniPrinter->pName );
                                } else {
                                    
                                    pszPrinter = pIniPrinter->pName;
                                }
    
                                    
                                if ( !OpenMonitorPort(pIniPort,
                                                      & pIniLangMonitor,
                                                      pszPrinter,
                                                      FALSE) ) {
    
                                    dwRet = ERROR_INVALID_HANDLE;
                                }
                            }
                        }
                        else
                            dwRet = ERROR_INVALID_HANDLE;

                    }
                }
                else if(pSpool->TypeofHandle & PRINTER_HANDLE_PORT)
                {
                    pIniPort = pSpool->pIniPort;
                }

                if(dwRet == ERROR_SUCCESS && pIniPort && (pIniPort->Status & PP_MONITOR))
                {
                    pIniMonitor = pIniPort->pIniLangMonitor ? 
                                  pIniPort->pIniLangMonitor : 
                                  pIniPort->pIniMonitor;
                    
                    if(pIniMonitor)
                    {
                        //
                        // Calling into the monitor
                        //
                        if(pIniMonitor->Monitor2.pfnSendRecvBidiDataFromPort)
                        {
                        
                            INCPORTREF(pIniPort);
                            INCMONITORREF(pIniMonitor);
                            
                            LeaveSplSem();
                            SplOutSem();
                            
                            dwRet = (*pIniMonitor->Monitor2.pfnSendRecvBidiDataFromPort)(pIniPort->hPort,
                                                                                         pSpool->GrantedAccess,
                                                                                         pAction,
                                                                                         pReqData,
                                                                                         ppResData);
                            EnterSplSem();
                            
                            DECMONITORREF(pIniMonitor);
                            DECPORTREF(pIniPort);
                        }
                        else
                        {
                            //
                            // Here we could use a simulation code;
                            //
                            dwRet = ERROR_NOT_SUPPORTED;
                        }
                    }
                    else
                    {
                        dwRet = ERROR_INVALID_HANDLE;
                    }
                }
                else
                {
                    dwRet = ERROR_INVALID_HANDLE;
                }
            }
        }
    }
    LeaveSplSem();
    return(dwRet);
}