windows-xp/Source/XPSP1/NT/ds/netapi/svcdlls/srvsvc/server/xsproc.c

/*++

Copyright (c) 1991-1992 Microsoft Corporation

Module Name:

    xsproc.c

Abstract:

    This module contains the main processing loop for XACTSRV.

Author:

    David Treadwell (davidtr)    05-Jan-1991
    Shanku Niyogi (w-shanku)

Revision History:

    02-Jun-1992 JohnRo
        RAID 9829: Avoid SERVICE_ equate conflicts.

    Chuck Lenzmeier (chuckl) 17-Jun-1992
        Moved from xssvc to srvsvc\server

--*/

//
// Includes.
//

#include "srvsvcp.h"
#include "xsdata.h"

#include <netevent.h>

#include <windows.h>        // from sdk\inc
#include <winspool.h>       // Dynamically loaded as needed for perf
#include <winsprlp.h>       // addjob_info_2w, private spooler defs

#include <apinums.h>        // from net\inc
#include <netlib.h>         // from net\inc (NetpGetComputerName)

#include <xactsrv2.h>       // from private\inc
#include <smbgtpt.h>

#include <xsconst.h>        // from xactsrv

#include <lmsname.h>        // from \sdk\inc
#include <lmerr.h>          // from \sdk\inc
#include <lmapibuf.h>       // from \sdk\inc (NetApiBufferFree)
#include <lmmsg.h>          // from \sdk\inc (NetMessageBufferSend)
#include <winsvc.h>         // from \sdk\inc

#if DBG
#include <stdio.h>
#include <lmbrowsr.h>
#endif

#undef DEBUG
#undef DEBUG_API_ERRORS
#include <xsdebug.h>

HMODULE hSpoolerLibrary = NULL;
CRITICAL_SECTION SpoolerMutex;

VOID
ConvertApiStatusToDosStatus(
    LPXS_PARAMETER_HEADER header
    );

BOOLEAN
XsProcessApis (
    DWORD ThreadNum
    );

BOOLEAN
XsLoadPrintSpoolerFunctions(
    );

BOOLEAN
XsUnloadPrintSpoolerFunctions(
    );


VOID
XsProcessApisWrapper (
    LPVOID ThreadNumber
    )

/*++

Routine Description:

    This routine provides multithreaded capability for main processing
    routine, XsProcessApis.

Arguments:

    ThreadNum - thread number for debugging purposes.


--*/

{
    XACTSRV_REQUEST_MESSAGE requestMessage;
    BOOLEAN LastThread;
    DWORD ThreadNum = PtrToInt( ThreadNumber );

    //
    //  Increase the priority of this thread to just above foreground (the
    //  same as the rest of the server).
    //

    SetThreadPriority( GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL );

    //
    // Do the APIs
    //
    LastThread = XsProcessApis( ThreadNum );

    IF_DEBUG(THREADS) {
        SS_PRINT(( "Thread %ld exiting, active count %ld\n", ThreadNum,
                    SsData.XsThreads ));
    }

    //
    // If the last thread has terminated, set the All Threads Terminated event.
    //

    if( LastThread ) {

        SetEvent( SsData.XsAllThreadsTerminatedEvent );

    } else if( SsData.XsTerminating ) {

        //
        // There are still threads left, and we are trying to terminate.  Queue
        //  another message to the queue so the next thread will get it and
        //  notice that we're trying to quit.
        //
        RtlZeroMemory( &requestMessage, sizeof( requestMessage ));
        requestMessage.PortMessage.u1.s1.DataLength =
            (USHORT)( sizeof(requestMessage) - sizeof(PORT_MESSAGE) );
        requestMessage.PortMessage.u1.s1.TotalLength = sizeof(requestMessage);
        requestMessage.MessageType = XACTSRV_MESSAGE_WAKEUP;

        NtRequestPort(
            SsData.XsConnectionPortHandle,
            (PPORT_MESSAGE)&requestMessage
            );
    }

    ExitThread( NO_ERROR );

} // XsProcessApisWrapper


BOOLEAN
XsProcessApis (
    DWORD ThreadNum
    )

/*++

Routine Description:

    This routine waits for messages to come through the LPC port to
    the server.  When one does, it calls the appropriate routine to
    handle the API, then replies to the server indicating that the
    API has completed.

Arguments:

    ThreadNum - thread number for debugging purposes.

Return Value:

    TRUE if we are the last thread

--*/

{
    NTSTATUS status;
    NET_API_STATUS error;
    XACTSRV_REQUEST_MESSAGE request;
    XACTSRV_REPLY_MESSAGE reply;
    BOOL sendReply = FALSE;
    BOOL ValidationSuccessful = FALSE;
    LPTRANSACTION transaction;
    WORD apiNumber;
    LPXS_PARAMETER_HEADER header;
    LPVOID parameters;
    LPDESC structureDesc;
    LPDESC auxStructureDesc;
    LPDESC paramStructureDesc;
    LARGE_INTEGER timeout;
#if 0
    LARGE_INTEGER XactSrvStartTime;
    LARGE_INTEGER XactSrvEndTime;
    LARGE_INTEGER PerformanceFrequency;
#endif
    LONG availableThreads;
    LONG i;

    i = InterlockedIncrement( &SsData.XsThreads );

    //
    // Loop dispatching API requests.
    //
    while ( SsData.XsTerminating == FALSE ) {

        //
        // We're waiting to handle another API...
        //
        InterlockedIncrement( &SsData.XsWaitingApiThreads );

        //
        // Send the reply to the last message and wait for the next message.
        //
        // Wait for 30 seconds if there are many servicing threads.  If there
        //  is only one thread, we can wait without a timeout.
        //
        timeout.QuadPart = -1*10*1000*1000*30;

        status = NtReplyWaitReceivePortEx(
                     SsData.XsCommunicationPortHandle,
                     NULL,                       // PortContext
                     sendReply ? (PPORT_MESSAGE)&reply : NULL,
                     (PPORT_MESSAGE)&request,
                     SsData.XsThreads > 1 ? &timeout : NULL
                     );

        sendReply = TRUE;

        //
        // Set 'availableThreads' to the number of threads currently available to service
        //  API requests
        //
        availableThreads = InterlockedDecrement( &SsData.XsWaitingApiThreads );

        IF_DEBUG(THREADS) {
            SS_PRINT(( "XsProcessApis: Thread %d:  NtReplyWaitReceivePort %X, msg %X\n",
                       ThreadNum, status, &request ));
        }

        if( status == STATUS_TIMEOUT ) {
            //
            // If this is the last thread, or we seem busy, then don't terminate.
            //
            if( InterlockedDecrement( &SsData.XsThreads ) == 0 ||
                availableThreads == 0 ) {

                    //
                    // Do not terminate.
                    //
                    InterlockedIncrement( &SsData.XsThreads );
                    sendReply = FALSE;
                    continue;
            }

            //
            // This thread can terminate, there isn't enough work to support it.
            //
            return FALSE;

        }

        if( !NT_SUCCESS( status ) ||
            SsData.XsTerminating ||
            request.PortMessage.u2.s2.Type == LPC_PORT_CLOSED ) {

            //
            // The port is no longer valid, or XACTSRV is terminating.
            //

            IF_DEBUG(THREADS) {
                SS_PRINT(( "XsProcessApis: %X\n", status ));
                SS_PRINT(( "XsProcessApis: %s.  Thread %ld quitting\n",
                            SsData.XsTerminating ?
                                "XACTSRV terminating" : "Port invalid",
                            ThreadNum ));
            }

            break;
        }

        //
        // If we have received anything other than a message, then something
        //  strange is happening.  Ignore it.
        //
        if( (request.PortMessage.u2.s2.Type & ~LPC_KERNELMODE_MESSAGE) == LPC_CONNECTION_REQUEST ) {
            //
            // Reject this connection attempt
            //

            IF_DEBUG(LPC) {
                SS_PRINT(( "XsProcessApis: unexpected LPC_CONNECTION_REQUEST rejected\n" ));
            }

            NtAcceptConnectPort(    SsData.XsCommunicationPortHandle,
                                    NULL,
                                    (PPORT_MESSAGE)&request,
                                    FALSE,
                                    NULL,
                                    NULL
                                );
            sendReply = FALSE;
            continue;

        } else if( !(request.PortMessage.u2.s2.Type & LPC_REQUEST) ) {
            //
            // This is not a request message.  Reject it.
            //

            IF_DEBUG(LPC) {
                SS_PRINT(( "XsProcessApis: unexpected LPC type %X rejected\n",
                        request.PortMessage.u2.s2.Type ));
            }

            sendReply = FALSE;
            continue;
        }

        IF_DEBUG(THREADS) {
            SS_PRINT(( "XsProcessApis: Thread %ld responding to request, "
                       "  MessageType %d, SsData.XsTerminating %d",
                        ThreadNum, request.MessageType, SsData.XsTerminating ));
        }

        if( availableThreads == 0 ) {

            HANDLE threadHandle;
            DWORD  threadId;
            
            //
            // Are there other threads ready to handle new requests?  If not, then
            // we should spawn a new thread.  Since the server synchronously sends
            // requests to xactsrv, we will never end up with more than
            // the maximum number of server worker threads + 1.
            //

            threadHandle = CreateThread(
                                NULL,
                                0,
                                (LPTHREAD_START_ROUTINE)XsProcessApisWrapper,
                                IntToPtr(SsData.XsThreads),
                                0,
                                &threadId
                                );

            if ( threadHandle != 0 ) {

                IF_DEBUG(THREADS) {
                    SS_PRINT(( "XsStartXactsrv: Created thread %ld for "
                                  "processing APIs\n", SsData.XsThreads ));
                }

                CloseHandle( threadHandle );

            } else {

                IF_DEBUG(THREADS) {
                    SS_PRINT(( "XsStartXactsrv: Unable to create thread %ld for "
                                  "processing APIs\n", SsData.XsThreads ));
                }

            }
        }

        //
        // Set up the response message to be sent on the next call to
        // NtReplyWaitReceivePort.
        //
        reply.PortMessage.u1.s1.DataLength =
            sizeof(reply) - sizeof(PORT_MESSAGE);
        reply.PortMessage.u1.s1.TotalLength = sizeof(reply);
        reply.PortMessage.u2.ZeroInit = 0;
        reply.PortMessage.ClientId = request.PortMessage.ClientId;
        reply.PortMessage.MessageId = request.PortMessage.MessageId;

        switch ( request.MessageType ) {
        case XACTSRV_MESSAGE_DOWN_LEVEL_API:

            //
            // Get a pointer to the transaction block from the message.
            // It is the file server's responsibility to set up this
            // pointer correctly, and since he is a trusted entity, we
            // do no checking on the pointer value.
            //

            transaction = request.Message.DownLevelApi.Transaction;
            ASSERT( transaction != NULL );

#if 0
            NtQueryPerformanceCounter(&XactSrvStartTime, &PerformanceFrequency);

            //
            //  Convert frequency from ticks/second to ticks/millisecond
            //

            PerformanceFrequency = LiXDiv(PerformanceFrequency, 1000);

            if (LiGeq(XactSrvStartTime, transaction->XactSrvTime)) {
                CHAR Buffer[200];
                LARGE_INTEGER LpcTime = LiSub(XactSrvStartTime, transaction->XactSrvTime);

                LpcTime = LiDiv(LpcTime, PerformanceFrequency);

                sprintf(Buffer, "XactSrv: LPC Time: %ld milliseconds (%ld)\n", LpcTime.LowPart, LpcTime.HighPart);

                I_BrowserDebugTrace(NULL, Buffer);
            }
#endif
            //
            // The API number is the first word in the parameters
            // section, and it is followed by the parameter descriptor
            // string.  After that comes the data descriptor.
            //

            apiNumber = SmbGetUshort( (LPWORD)transaction->InParameters );
            paramStructureDesc = (LPDESC)( transaction->InParameters + 2 );

            try {

                structureDesc = paramStructureDesc
                                + strlen( paramStructureDesc ) + 1;

            } except( EXCEPTION_EXECUTE_HANDLER ) {
                reply.Message.DownLevelApi.Status = GetExceptionCode();
                break;
            }

            //
            // Make sure the API number is in range.
            //

            if ( apiNumber >=
                    (sizeof(XsApiTable) / sizeof(XS_API_TABLE_ENTRY)) ) {

                reply.Message.DownLevelApi.Status =
                                            STATUS_INVALID_SYSTEM_SERVICE;
                break;
            }

            //
            // Make sure xactsrv.dll is loaded, and a handler is available for this
            //  request.
            //
            if( XsApiTable[ apiNumber ].Handler == NULL &&
                XsLoadXactLibrary( apiNumber ) == FALSE ) {

                reply.Message.DownLevelApi.Status = STATUS_INVALID_SYSTEM_SERVICE;
                break;
            }

            //
            // Check if the parameter descriptor is valid.  If not,
            // there is obviously something very wrong about this
            // request.
            //

            ValidationSuccessful = FALSE;

            try {
                if (XsApiTable[apiNumber].Params == NULL &&
                    *paramStructureDesc != '\0') {
                    reply.Message.DownLevelApi.Status = STATUS_INVALID_PARAMETER;
                    goto ValidationFailed;
                } else if ( !XsCheckSmbDescriptor(
                                 paramStructureDesc,
                                 XsApiTable[apiNumber].Params )) {
                    reply.Message.DownLevelApi.Status = STATUS_INVALID_PARAMETER;
                    goto ValidationFailed;
                }

                //
                // Capture the input parameters into a buffer.  The API
                // handler will treat this data as passed-in parameters.
                //

                header = XsCaptureParameters( transaction, &auxStructureDesc );

                if ( header == NULL ) {
                    reply.Message.DownLevelApi.Status = STATUS_NO_MEMORY;
                    goto ValidationFailed;
                }

                ValidationSuccessful = TRUE;

            ValidationFailed:
                ;
            } except( EXCEPTION_EXECUTE_HANDLER ) {
                reply.Message.DownLevelApi.Status = GetExceptionCode();
                break;
            }

            if (!ValidationSuccessful) {
                break;
            }

            //
            // Initialize header to default values.
            //

            header->Converter = 0;
            header->Status = NO_ERROR;
            header->ClientMachineName =
                request.Message.DownLevelApi.ClientMachineName;

            header->ClientTransportName = request.Message.DownLevelApi.TransportName;

            header->EncryptionKey = request.Message.DownLevelApi.LanmanSessionKey;

            header->Flags = request.Message.DownLevelApi.Flags;

            header->ServerName = request.Message.DownLevelApi.ServerName;

            parameters = header + 1;

            IF_DEBUG(LPC) {

                SS_PRINT(( "XsProcessApis: received message from %ws at %lx, "
                              "transaction %lx, API %ld on transport %ws\n",
                              header->ClientMachineName, &request,
                              transaction, apiNumber,
                              header->ClientTransportName ));
            }

            IF_DEBUG(DESC_STRINGS) {

                SS_PRINT(( "XsProcessApis: API %ld, parameters %s, data %s\n",
                              apiNumber, paramStructureDesc, structureDesc ));
            }

            //
            // Impersonate the client before calling the API.
            //

            if ( XsApiTable[apiNumber].ImpersonateClient ) {

                // NULL-session requests to impersonating API's are blocked by SRV.SYS (in xssupp.c),
                // otherwise NULL sessions could execute API's as privileged users.

                status = NtImpersonateClientOfPort(
                             SsData.XsCommunicationPortHandle,
                             (PPORT_MESSAGE)&request
                             );

                if ( !NT_SUCCESS(status) ) {

                    IF_DEBUG(ERRORS) {
                        SS_PRINT(( "XsProcessApis: NtImpersonateClientOfPort "
                                      "failed: %X\n", status ));
                    }

                    reply.Message.DownLevelApi.Status = ERROR_ACCESS_DENIED;
                    break;
                }
            }

            try {
                //
                // Call the API processing routine to perform the actual API call.
                // The called routine should set up parameters, make the actual API
                // call, and return the status to us.
                //

                reply.Message.DownLevelApi.Status =
                    XsApiTable[apiNumber].Handler(
                         header,
                         parameters,
                         structureDesc,
                         auxStructureDesc
                         );
            } except( EXCEPTION_EXECUTE_HANDLER ) {
                reply.Message.DownLevelApi.Status = GetExceptionCode();
            }

            //
            // Discontinue client impersonation.
            //

            if ( XsApiTable[apiNumber].ImpersonateClient ) {

                PVOID dummy = NULL;

                status = NtSetInformationThread(
                             NtCurrentThread( ),
                             ThreadImpersonationToken,
                             &dummy,  // discontinue impersonation
                             sizeof(PVOID)
                             );

                if ( !NT_SUCCESS(status)) {
                    IF_DEBUG(ERRORS) {
                        SS_PRINT(( "XsProcessApis: NtSetInformationThread "
                                      "(revert) failed: %X\n", status ));
                    }
                    // *** Ignore the error.
                }
            }

            //
            // Make sure we return the right error codes
            //

            if ( header->Status != NERR_Success ) {
                ConvertApiStatusToDosStatus( header );
            }

            //
            // Put the parameters in the transaction and free the parameter
            // buffer.
            //

            XsSetParameters( transaction, header, parameters );

            break;

        case XACTSRV_MESSAGE_OPEN_PRINTER: {

            UNICODE_STRING printerName;

            if( !pSpoolerOpenPrinterFunction )
            {
                if( !XsLoadPrintSpoolerFunctions() )
                {
                    reply.Message.OpenPrinter.Error = GetLastError();
                    break;
                }
            }

            RtlInitUnicodeString(
                &printerName,
                (PWCH)request.Message.OpenPrinter.PrinterName
                );

            if (!(*pSpoolerOpenPrinterFunction)( printerName.Buffer,
                              &reply.Message.OpenPrinter.hPrinter, NULL)) {

                reply.Message.OpenPrinter.Error = GetLastError();
                SS_PRINT(( "XsProcessApis: OpenPrinter failed: %ld\n",
                                  reply.Message.OpenPrinter.Error ));
                break;
            }


            reply.Message.OpenPrinter.Error = NO_ERROR;
            break;
        }

        case XACTSRV_MESSAGE_ADD_JOB_PRINTER:
        {
            LPADDJOB_INFO_2W addJob;
            PRINTER_DEFAULTS prtDefault;
            DWORD bufferLength;
            UNICODE_STRING dosName;
            UNICODE_STRING ntName;
            BOOL ok;
            PVOID dummy = NULL;

            if( !(pSpoolerResetPrinterFunction || pSpoolerAddJobFunction) )
            {
                if( !XsLoadPrintSpoolerFunctions() )
                {
                    reply.Message.OpenPrinter.Error = GetLastError();
                    break;
                }
            }

            //
            // Allocate space for the add job structure.  This buffer
            // will get the JobId and the spool file path name.
            //

            bufferLength = sizeof(ADDJOB_INFO_2W) +
                                (MAXIMUM_FILENAME_LENGTH * sizeof(TCHAR));

            addJob = (LPADDJOB_INFO_2W) LocalAlloc( LPTR, bufferLength );
            if ( addJob == NULL ) {
                reply.Message.AddPrintJob.Error = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }

            //
            // Impersonate the client before calling the API.
            //

            status = NtImpersonateClientOfPort(
                         SsData.XsCommunicationPortHandle,
                         (PPORT_MESSAGE)&request
                         );

            if ( !NT_SUCCESS(status) ) {

                IF_DEBUG(ERRORS) {
                    SS_PRINT(( "XsProcessApis: NtImpersonateClientOfPort "
                                  "failed: %X\n", status ));
                }

                LocalFree( addJob );
                reply.Message.DownLevelApi.Status = ERROR_ACCESS_DENIED;
                break;
            }

            //
            // call ResetJob so that we will pick up the new printer defaults
            //

            prtDefault.pDatatype = (LPWSTR)-1;
            prtDefault.pDevMode = (LPDEVMODEW)-1;
            prtDefault.DesiredAccess = 0;

            ok = (*pSpoolerResetPrinterFunction)(
                        request.Message.AddPrintJob.hPrinter,
                        &prtDefault
                        );

            if ( !ok ) {

                //
                // *** Ignore the error.  AddJob will use the old defaults
                // in this case.
                //

                IF_DEBUG(ERRORS) {
                    DWORD error;
                    error = GetLastError( );
                    SS_PRINT(( "XsProcessApis: ResetPrinter "
                        "failed: %ld\n", error ));
                }
            }

            // Setup IN arguments to AddJob buffer

            addJob->pData = request.Message.AddPrintJob.ClientMachineName;

            //
            // Call AddJob to set up the print job and get a job ID
            // and spool file name.
            //

            ok = (*pSpoolerAddJobFunction)(
                      request.Message.AddPrintJob.hPrinter,
                      3,
                      (LPBYTE)addJob,
                      bufferLength,
                      &bufferLength
                      );

            if ( !ok ) {
                reply.Message.AddPrintJob.Error = GetLastError( );
            }

            //
            // Discontinue client impersonation.
            //

            status = NtSetInformationThread(
                         NtCurrentThread( ),
                         ThreadImpersonationToken,
                         &dummy,  // discontinue impersonation
                         sizeof(PVOID)
                         );

            if ( !NT_SUCCESS(status)) {
                IF_DEBUG(ERRORS) {
                    SS_PRINT(( "XsProcessApis: NtSetInformationThread "
                                  "(revert) failed: %X\n", status ));
                }
                // *** Ignore the error.
            }

            if ( !ok ) {
                SS_PRINT(( "XsProcessApis: AddJob failed, %ld\n",
                                  reply.Message.AddPrintJob.Error ));
                LocalFree( addJob );
                break;
            }

            //
            // Set up the information in the return buffer.
            //

            reply.Message.AddPrintJob.JobId = addJob->JobId;

            RtlInitUnicodeString( &dosName, addJob->pData );

            status = RtlDosPathNameToNtPathName_U(
                         dosName.Buffer,
                         &ntName,
                         NULL,
                         NULL
                         );
            if ( !NT_SUCCESS(status) ) {
                IF_DEBUG(ERRORS) {
                    SS_PRINT(( "XsProcessApis: Dos-to-NT path failed: %X\n",
                                status ));
                }
                ntName.Buffer = NULL;
                ntName.Length = 0;
            }

            //
            // Set up return data.
            //

            reply.Message.AddPrintJob.BufferLength = ntName.Length;
            reply.Message.AddPrintJob.Error = NO_ERROR;
            RtlCopyMemory(
                request.Message.AddPrintJob.Buffer,
                ntName.Buffer,
                ntName.Length
                );

            //
            // Free allocated resources.
            //

            LocalFree( addJob );
            if ( ntName.Buffer != NULL ) {
                RtlFreeHeap( RtlProcessHeap( ), 0, ntName.Buffer );
            }

            break;
        }

        case XACTSRV_MESSAGE_SCHD_JOB_PRINTER:

            if( !pSpoolerScheduleJobFunction )
            {
                if( !XsLoadPrintSpoolerFunctions() )
                {
                    reply.Message.OpenPrinter.Error = GetLastError();
                    break;
                }
            }

            //
            // Call ScheduleJob( ) to indicate that we're done writing to
            // the spool file.
            //

            if ( !(*pSpoolerScheduleJobFunction)(
                      request.Message.SchedulePrintJob.hPrinter,
                      request.Message.SchedulePrintJob.JobId ) ) {

                reply.Message.SchedulePrintJob.Error = GetLastError( );
                SS_PRINT(( "XsProcessApis: ScheduleJob failed, %ld\n",
                                  reply.Message.SchedulePrintJob.Error ));
                break;
            }

            reply.Message.SchedulePrintJob.Error = NO_ERROR;
            break;

        case XACTSRV_MESSAGE_CLOSE_PRINTER:

            if( !pSpoolerClosePrinterFunction )
            {
                if( !XsLoadPrintSpoolerFunctions() )
                {
                    reply.Message.OpenPrinter.Error = GetLastError();
                    break;
                }
            }

            if ( !(*pSpoolerClosePrinterFunction)( request.Message.ClosePrinter.hPrinter ) ) {
                reply.Message.ClosePrinter.Error = GetLastError( );
                SS_PRINT(( "XsProcessApis: ClosePrinter failed: %ld\n",
                                  reply.Message.ClosePrinter.Error ));
                break;
            }

            reply.Message.ClosePrinter.Error = NO_ERROR;
            break;

        case XACTSRV_MESSAGE_MESSAGE_SEND:
        {
            LPTSTR sender;

            error = NetpGetComputerName( &sender );

            if ( error != NO_ERROR ) {
                SS_PRINT(( "XsProcessApis: NetpGetComputerName failed: %ld\n",
                            error ));
                reply.Message.MessageBufferSend.Error = error;
                break;
            }

            error = NetMessageBufferSend(
                        NULL,

                        //
                        // the following LPTSTR typecast is not wrong, because the
                        // ServerService will always be built for UNICODE.  If you
                        // want to rebuild it for ASCII, then 
                        // it must be fixed in ntos\srv\scavengr.c which
                        // should pass in a LPWSTR if built for unicode or
                        // convert the UNICODE_STRING to an OEM_STRING and
                        // pass a pointer to the buffer field, as it does
                        // now
                        //

                        (LPTSTR)request.Message.MessageBufferSend.Receipient,
                        sender,
                        request.Message.MessageBufferSend.Buffer,
                        request.Message.MessageBufferSend.BufferLength
                        );

            if ( error != NO_ERROR ) {
                SS_PRINT(( "XsProcessApis: NetMessageBufferSend failed: %ld\n",
                            error ));
            }

            (void) NetApiBufferFree( sender );

            reply.Message.MessageBufferSend.Error = error;
            break;
        }

        case XACTSRV_MESSAGE_LSREQUEST:
            SS_PRINT(( "LSREQUEST User: %ws\n", request.Message.LSRequest.UserName ));
        {
            NT_LS_DATA NtLSData;

            //
            // Ensure we have loaded the license library.  Or at least tried to!
            //
            if( SsData.SsLicenseRequest == NULL && !SsLoadLicenseLibrary() ) {
                //
                // Now what do we do?  Let's be a kind and gentle server and let
                //  the client in.
                //
                reply.Message.LSRequest.Status = STATUS_SUCCESS;
                reply.Message.LSRequest.hLicense = &SsData.SsFreeLicense;
                break;
            }

            NtLSData.DataType = NT_LS_USER_NAME;
            NtLSData.Data = request.Message.LSRequest.UserName;
            NtLSData.IsAdmin = request.Message.LSRequest.IsAdmin;

            reply.Message.LSRequest.Status = SsData.SsLicenseRequest (
                SsData.ServerProductName,
                SsData.szVersionNumber,
                (LS_HANDLE *)&reply.Message.LSRequest.hLicense,
                &NtLSData
               );

            if( !NT_SUCCESS( reply.Message.LSRequest.Status ) ) {
                //
                // We need to return the 'same old' error code that clients are used to
                //  getting for when the server is full
                //
                SS_PRINT(("LSREQUEST returns status %X, mapping to %X\n",
                          reply.Message.LSRequest.Status, STATUS_REQUEST_NOT_ACCEPTED ));
                reply.Message.LSRequest.Status = STATUS_REQUEST_NOT_ACCEPTED;
            }

            break;
        }

        case XACTSRV_MESSAGE_LSRELEASE:

            SS_PRINT(( "LSRELEASE Handle: %X\n", request.Message.LSRelease.hLicense ));

            if( SsData.SsFreeLicense != NULL &&
                request.Message.LSRelease.hLicense != &SsData.SsFreeLicense ) {

                SsData.SsFreeLicense( (LS_HANDLE)request.Message.LSRelease.hLicense );
            }

            break;

        case XACTSRV_MESSAGE_PNP:
        {
            PUNICODE_STRING transportName;
            BOOLEAN bind = request.Message.Pnp.Bind;

            //
            // Capture the parameters, release the server, and issue the bind or unbind
            //
            transportName = (PUNICODE_STRING)LocalAlloc(
                                        LPTR,
                                        sizeof( UNICODE_STRING ) +
                                        request.Message.Pnp.TransportName.MaximumLength
                                        );

            if( transportName == NULL ) {
                SS_PRINT(( "XACTSRV_MESSAGE_PNP: LocalAlloc failed!\n" ));
                break;
            }

            transportName->Buffer = (PUSHORT)(transportName+1);
            transportName->MaximumLength = request.Message.Pnp.TransportName.MaximumLength;
            RtlCopyUnicodeString(transportName, &request.Message.Pnp.TransportName );

            //
            // Now process the PNP command
            //
            if( bind == TRUE ) {
                //
                // If it is a bind, send the response now, and continue with the operation
                //
                sendReply = FALSE;
                status = NtReplyPort( SsData.XsCommunicationPortHandle, (PPORT_MESSAGE)&reply );

                //
                // Bind to the transport.  First bind the primary server name, then bind all
                //   of the secondary names.  These calls will log errors as necessary.
                //
                BindToTransport( transportName->Buffer );

                BindOptionalNames( transportName->Buffer );

            } else {
                //
                // Unbind from the transport
                //
                I_NetServerTransportDel( transportName );
            }

            LocalFree( transportName );

            break;
        }

        default:

            SS_ASSERT( FALSE );

        }
   }

    return (InterlockedDecrement( &SsData.XsThreads ) == 0) ? TRUE : FALSE;

} // XsProcessApis



VOID
ConvertApiStatusToDosStatus(
    LPXS_PARAMETER_HEADER Header
    )
/*++

Routine Description:

    This routine converts an api return status to status expected by
    downlevel.

Arguments:

    Header - structure containing the status.

Return Value:

--*/
{
    WORD dosStatus;

    switch ( Header->Status ) {
    case ERROR_SPECIAL_ACCOUNT:
    case ERROR_SPECIAL_GROUP:
    case ERROR_SPECIAL_USER:
    case ERROR_INVALID_LOGON_TYPE:
        dosStatus = ERROR_INVALID_PARAMETER;
        break;

    case ERROR_DEPENDENT_SERVICES_RUNNING:
        dosStatus = NERR_ServiceCtlNotValid;
        break;

    case ERROR_INVALID_DOMAINNAME:
        dosStatus = NERR_NotLocalDomain;
        break;

    case ERROR_NO_SUCH_USER:
        dosStatus = NERR_UserNotFound;
        break;

    case ERROR_ALIAS_EXISTS:
        dosStatus = NERR_GroupExists;
        break;

    case NERR_BadServiceName:
        dosStatus = NERR_ServiceNotInstalled;
        break;

    case ERROR_ILL_FORMED_PASSWORD:
    case NERR_PasswordTooRecent:
        dosStatus = ERROR_INVALID_PASSWORD;
        break;

    case ERROR_PASSWORD_RESTRICTION:
        dosStatus = NERR_PasswordHistConflict;
        break;

    case ERROR_ACCOUNT_RESTRICTION:
        dosStatus = NERR_PasswordTooRecent;
        break;

    case ERROR_PASSWORD_EXPIRED:
    case ERROR_PASSWORD_MUST_CHANGE:
        dosStatus = NERR_PasswordExpired;
        break;

    case ERROR_INVALID_PRINTER_NAME:
        dosStatus = NERR_QNotFound;
        break;

    case ERROR_UNKNOWN_PRINTER_DRIVER:
        dosStatus = NERR_DriverNotFound;
        break;

    case ERROR_NO_BROWSER_SERVERS_FOUND:

        //
        //  Down level clients don't understand how to deal with
        //  the "No browser server" error, so we turn it into success.
        //
        //  This seems wrong to me, but it is what WfW does in the
        //  same circumstance.
        //

        if ( !(Header->Flags & XS_FLAGS_NT_CLIENT) ) {
            dosStatus = NERR_Success;
        } else {
            dosStatus = Header->Status;
        }
        break;

    default:

        //
        // make sure it's a valid lm error code
        //

        if ( (Header->Status > ERROR_VC_DISCONNECTED) &&
                    ((Header->Status < NERR_BASE) ||
                     (Header->Status > MAX_NERR)) ) {

            NTSTATUS status;
            LPWSTR substring[1];
            WCHAR errorString[10];
            UNICODE_STRING unicodeString;

            substring[0] = errorString;
            unicodeString.MaximumLength = 10 * sizeof(WCHAR);
            unicodeString.Buffer = errorString;

            status = RtlIntegerToUnicodeString(
                            (ULONG) Header->Status,
                            10,
                            &unicodeString
                            );

            if ( NT_SUCCESS( status ) ) {
                SsLogEvent(
                    EVENT_SRV_CANT_MAP_ERROR,
                    1,
                    substring,
                    NO_ERROR
                    );
            }

            dosStatus = ERROR_UNEXP_NET_ERR;
            SS_PRINT(( "srvsvc: unmapped error %d from xactsrv.\n",
                        Header->Status )) ;

        } else {

            //
            // No change
            //

            return;
        }
    }

    Header->Status = dosStatus;
    return;

} // ConvertApiStatusToDosStatus


BOOLEAN
XsLoadPrintSpoolerFunctions(
    )
{
    BOOLEAN bReturn = TRUE;

    EnterCriticalSection( &SpoolerMutex );

    if( !hSpoolerLibrary )
    {
        hSpoolerLibrary = LoadLibrary( L"winspool.drv" );
        if( !hSpoolerLibrary )
        {
            bReturn = FALSE;
            goto finish;
        }

        pSpoolerOpenPrinterFunction = (PSPOOLER_OPEN_PRINTER)GetProcAddress( hSpoolerLibrary, "OpenPrinterW" );
        if( !pSpoolerOpenPrinterFunction )
        {
            bReturn = FALSE;
            goto finish;
        }
        pSpoolerResetPrinterFunction = (PSPOOLER_RESET_PRINTER)GetProcAddress( hSpoolerLibrary, "ResetPrinterW" );
        if( !pSpoolerResetPrinterFunction )
        {
            bReturn = FALSE;
            goto finish;
        }
        pSpoolerAddJobFunction = (PSPOOLER_ADD_JOB)GetProcAddress( hSpoolerLibrary, "AddJobW" );
        if( !pSpoolerAddJobFunction )
        {
            bReturn = FALSE;
            goto finish;
        }
        pSpoolerScheduleJobFunction = (PSPOOLER_SCHEDULE_JOB)GetProcAddress( hSpoolerLibrary, "ScheduleJob" );
        if( !pSpoolerScheduleJobFunction )
        {
            bReturn = FALSE;
            goto finish;
        }
        pSpoolerClosePrinterFunction = (PSPOOLER_CLOSE_PRINTER)GetProcAddress( hSpoolerLibrary, "ClosePrinter" );
        if( !pSpoolerClosePrinterFunction )
        {
            bReturn = FALSE;
            goto finish;
        }
    }

finish:
    if( !bReturn )
    {
        pSpoolerOpenPrinterFunction = NULL;
        pSpoolerResetPrinterFunction = NULL;
        pSpoolerAddJobFunction = NULL;
        pSpoolerScheduleJobFunction = NULL;
        pSpoolerClosePrinterFunction = NULL;

        if( hSpoolerLibrary )
        {
            FreeLibrary( hSpoolerLibrary );
            hSpoolerLibrary = NULL;
        }
    }

    LeaveCriticalSection( &SpoolerMutex );

    return bReturn;
}

BOOLEAN
XsUnloadPrintSpoolerFunctions(
    )
{
    EnterCriticalSection( &SpoolerMutex );

    pSpoolerOpenPrinterFunction = NULL;
    pSpoolerResetPrinterFunction = NULL;
    pSpoolerAddJobFunction = NULL;
    pSpoolerScheduleJobFunction = NULL;
    pSpoolerClosePrinterFunction = NULL;

    if( hSpoolerLibrary )
    {
        FreeLibrary( hSpoolerLibrary );
        hSpoolerLibrary = NULL;
    }

    LeaveCriticalSection( &SpoolerMutex );

    return TRUE;
}