windows-xp/Source/XPSP1/NT/base/screg/sc/server/status.cxx

/*++

Copyright (c) 1991  Microsoft Corporation

Module Name:

    status.cxx

Abstract:

    This file contains functions that are involved with setting the
    status for a service in the service controller.

        RSetServiceStatus
        RemovalThread
        RI_ScSetServiceBitsA
        RI_ScSetServiceBitsW
        ScRemoveServiceBits
        ScInitServerAnnounceFcn

Author:

    Dan Lafferty (danl)     20-Mar-1991

Environment:

    User Mode -Win32

Revision History:

    10-Mar-1998     jschwart
        Add code to RSetServiceStatus to notify Plug-and-Play when a service
        registers/deregisters for hardware profile change notifications.

    08-Jan-1997     anirudhs
        RSetServiceStatus: Fix obscure locking bugs found by the new locking
        scheme.  When a service stops, we sometimes need more restrictive
        locks than was previously assumed.

    11-Apr-1996     anirudhs
        RSetServiceStatus: Notify NDIS when a service that belongs to a
        group NDIS is interested in starts running.

    21-Nov-1995     anirudhs
        RI_ScSetServiceBitsW: Catch access violations caused if the
        hServiceStatus parameter is invalid.

    23-Mar-1994     danl
        RSetServiceStatus:  Only set the PopupStartFail flag when we have
        actually logged an event.  This means that now an auto-started service
        can quietly stop itself without reporting an exit code, and we will not
        log an event or put up a popup.
        However, we will still put up a popup if a service stops itself during
        auto-start, and it provides an exit code.

    20-Oct-1993     danl
        RSetServiceStatus: Only update the status if the service process is
        still running.  It is possible that the status could have been blocked
        when the process unexpectedly terminated, and updated the status to
        stopped.  In this case, the status that was blocked contains
        out-of-date information.

    10-Dec-1992     danl
        RI_ScSetServiceBitsW & ScRemoveServiceBits no longer hold locks when
        calling ScNetServerSetServiceBits.

    03-Nov-1992     danl
        RSetServiceStatus: Remove code that sets ExitCode to ERROR_GEN_FAILURE
        when a service transitions directly from START_PENDING to STOPPED with
        out an exit code of its own.

    25-Aug-1992     danl
        RSetServiceStatus: Allow dirty checkpoint and exitcode fields.
        Force them clean.

    19-Jun-1991     danl
        Allow ExitCodes to be specified for the SERVICE_STOP_PENDING state.
        Prior to this they were only allowed for the SERVICE_STOP state.

    20-Mar-1991     danl
        created

--*/

//
// INCLUDES
//

#include "precomp.hxx"
#include <tstr.h>       // Unicode string macros

#include "valid.h"      // ScCurrentStateInvalid
#include "depend.h"     // ScNotifyChangeState
#include "driver.h"     // ScNotifyNdis

#include <lmcons.h>     // NET_API_STATUS
#include <lmerr.h>      // NERR_Success
#include <lmsname.h>    // contains service name
#include <lmserver.h>   // SV_TYPE_NT (server announcement bits)
#include <srvann.h>     // I_NetServerSetServiceBits

#include "control.h"    // SERVICE_SET_STATUS

extern "C" {

#include <cfgmgr32.h>
#include "cfgmgrp.h"

}

//
// GLOBALS
//
    //
    // This is a special storage place for the OR'd server announcement
    // bit masks.  NOTE:  This is only read or written to when the
    // service database exclusive lock is held.
    //
    DWORD   GlobalServerAnnounce = SV_TYPE_NT;


    //
    // The following ServerHandle is the handle returned from the
    // LoadLibrary call which loaded netapi.dll.  The entrypoint for
    // I_NetServerSetServiceBits is then found and stored in the
    // global location described below.
    //
    HMODULE ScGlobalServerHandle;

    extern "C" typedef NET_API_STATUS (*SETSBPROC) (
                IN  LPTSTR  servername,
                IN  LPTSTR  transport OPTIONAL,
                IN  DWORD   servicebits,
                IN  DWORD   updateimmediately
                );

    SETSBPROC ScNetServerSetServiceBits = NULL;


//
//  Function Prototypes (local functions)
//

DWORD
RemovalThread(
    IN  LPSERVICE_RECORD    ServiceRecord
    );



DWORD
RSetServiceStatus(
    IN  SC_RPC_HANDLE      hService,
    IN  LPSERVICE_STATUS   lpServiceStatus
    )

/*++

Routine Description:

    This function is called by services when they need to inform the
    service controller of a change in state.

Arguments:

    hService - A service handle that has been given to the service
        with SERVICE_SET_STATUS access granted.

    lpServiceStatus - A pointer to a SERVICE_STATUS structure.  This
        reflects the latest status of the calling service.

Return Value:

    ERROR_INVALID_HANDLE - The specified handle is invalid.

    ERROR_INVALID_SERVICE_STATUS - The specified service status is invalid.

Note:


--*/
{
    DWORD               status = NO_ERROR;
    LPSERVICE_RECORD    serviceRecord;
    LPSERVICE_RECORD    hServiceStatus;
    DWORD               threadId;
    HANDLE              threadHandle;
    DWORD               oldState;
    DWORD               oldType;
    BOOL                groupListLocked = FALSE;


    SC_LOG(TRACE,"In RSetServiceStatus routine\n",0);

    //
    // Check the handle.
    //

    if (!ScIsValidServiceHandle(hService))
    {
        return ERROR_INVALID_HANDLE;
    }

    if (((LPSC_HANDLE_STRUCT)hService)->AccessGranted != SERVICE_SET_STATUS)
    {
        return(ERROR_INVALID_HANDLE);
    }

    hServiceStatus = ((LPSC_HANDLE_STRUCT) hService)->Type.ScServiceObject.ServiceRecord;

    //
    // Validate the fields in the service status structure.
    //

    if (ScCurrentStateInvalid(lpServiceStatus->dwCurrentState))
    {
        SC_LOG2(ERROR, "RSetServiceStatus: " FORMAT_LPWSTR " set invalid "
                       " dwCurrentState x%08lx\n",
                ((LPSERVICE_RECORD) hServiceStatus)->DisplayName,
                lpServiceStatus->dwCurrentState);

        ScLogEvent(
            NEVENT_BAD_SERVICE_STATE,
            ((LPSERVICE_RECORD) hServiceStatus)->DisplayName,
            lpServiceStatus->dwCurrentState
            );

        return(ERROR_INVALID_DATA);
    }


    if( (SERVICE_STATUS_TYPE_INVALID(lpServiceStatus->dwServiceType))    ||
        (CONTROLS_ACCEPTED_INVALID(lpServiceStatus->dwControlsAccepted)) )
    {
        SC_LOG3(ERROR,
                "RSetServiceStatus: Error in one of the following for service %ws\n"
                     "\tServiceType       %#x\n"
                     "\tControlsAccepted  %#x\n",
                ((LPSERVICE_RECORD) hServiceStatus)->DisplayName,
                lpServiceStatus->dwServiceType,
                lpServiceStatus->dwControlsAccepted);

        return(ERROR_INVALID_DATA);
    }

    //
    // If the service is not in the stopped or stop-pending state, then the
    // exit code fields should be 0.
    //
    if (((lpServiceStatus->dwCurrentState != SERVICE_STOPPED) &&
         (lpServiceStatus->dwCurrentState != SERVICE_STOP_PENDING))

          &&

         ((lpServiceStatus->dwWin32ExitCode != 0) ||
          (lpServiceStatus->dwServiceSpecificExitCode != 0))  )
    {
        SC_LOG(TRACE,"RSetServiceStatus: ExitCode fields not cleaned up "
            "when state indicates SERVICE_STOPPED\n",0);

        lpServiceStatus->dwWin32ExitCode = 0;
        lpServiceStatus->dwServiceSpecificExitCode = 0;
    }

    //
    // If the service is not in a pending state, then the waitHint and
    // checkPoint fields should be 0.
    //
    if ( ( (lpServiceStatus->dwCurrentState == SERVICE_STOPPED) ||
           (lpServiceStatus->dwCurrentState == SERVICE_RUNNING) ||
           (lpServiceStatus->dwCurrentState == SERVICE_PAUSED)  )
         &&
         ( (lpServiceStatus->dwCheckPoint != 0) ||
           (lpServiceStatus->dwWaitHint   != 0) )   )
    {
        SC_LOG(TRACE,"RSetServiceStatus: Dirty Checkpoint and WaitHint fields\n",0);
        lpServiceStatus->dwCheckPoint = 0;
        lpServiceStatus->dwWaitHint   = 0;
    }


    //
    // If the service has stopped, ScRemoveServiceBits needs the service
    // list lock with shared access.
    //
    if (lpServiceStatus->dwCurrentState == SERVICE_STOPPED)
    {
        ScServiceListLock.GetShared();
    }

    //
    // Update the service record.  Exclusive locks are required for this.
    //
    // NOTICE that we don't destroy the ServiceType information that was
    // in the service record.
    //
    serviceRecord = (LPSERVICE_RECORD)hServiceStatus;

    SC_LOG(TRACE,"RSetServiceStatus:  Status field accepted, service %ws\n",
           serviceRecord->ServiceName);

    ScServiceRecordLock.GetExclusive();

    //
    // If the service stopped, and its update flag is set (its config was
    // changed while it was running) we may need the group list lock in
    // ScRemoveService.  So release the locks and reacquire them after
    // getting the group list lock.  This is a rare occurrence, hence not
    // optimized.
    //
    if (lpServiceStatus->dwCurrentState == SERVICE_STOPPED &&
        UPDATE_FLAG_IS_SET(serviceRecord))
    {
        ScServiceRecordLock.Release();
        ScServiceListLock.Release();

        ScGroupListLock.GetExclusive();
        ScServiceListLock.GetShared();
        ScServiceRecordLock.GetExclusive();
        groupListLocked = TRUE;
    }

    oldState = serviceRecord->ServiceStatus.dwCurrentState;
    oldType  = serviceRecord->ServiceStatus.dwServiceType;


    //
    // It is possible that while we were blocked waiting for the lock,
    // that a running service could have terminated (Due to the process
    // terminating).  So we need to look for "late" status updates, and
    // filter them out.  If the ImageRecord pointer is NULL, then the
    // Service has Terminated.  Otherwise update the status.
    //
    if (serviceRecord->ImageRecord != NULL)
    {
        //
        // Don't bother notifying PnP if the system is shutting down.  This
        // prevents a deadlock where we can get stuck calling PnP, which is
        // stuck calling into the Eventlog, which is stuck calling into us.
        // 
        if (!ScShutdownInProgress)
        {
            DWORD dwControlFlags;
            DWORD dwBitMask;

            dwControlFlags = serviceRecord->ServiceStatus.dwControlsAccepted
                              &
                             (SERVICE_ACCEPT_HARDWAREPROFILECHANGE |
                                 SERVICE_ACCEPT_POWEREVENT);

            dwBitMask = lpServiceStatus->dwControlsAccepted ^ dwControlFlags;

            if (dwBitMask
                 ||
                ((lpServiceStatus->dwCurrentState == SERVICE_STOPPED) && dwControlFlags))
            {
                DWORD   dwRetVal;

                //
                // The service is either changing its registration status for
                // hardware profile change notifications or power OR is stopping,
                // so inform PnP of this.  On service stop, deregister the service
                // if it accepts power or hardware profile change notifications.
                //
                dwRetVal = RegisterServiceNotification(
                               (SERVICE_STATUS_HANDLE)hServiceStatus,
                               serviceRecord->ServiceName,
                               lpServiceStatus->dwCurrentState != SERVICE_STOPPED ?
                                       lpServiceStatus->dwControlsAccepted : 0,
                               (lpServiceStatus->dwCurrentState == SERVICE_STOPPED));

                if (dwRetVal != CR_SUCCESS)
                {
                    SC_LOG3(ERROR,
                           "Hardware profile change and power %sregistration failed "
                               "for service %ws with config manager error %d\n",
                           (lpServiceStatus->dwControlsAccepted &
                               (SERVICE_ACCEPT_HARDWAREPROFILECHANGE |
                                    SERVICE_ACCEPT_POWEREVENT)) ?
                                   "" :
                                   "de",
                           serviceRecord->ServiceName,
                           dwRetVal);
                }
            }
        }

        //
        // Update to the new status
        //
        RtlCopyMemory(&(serviceRecord->ServiceStatus),
                      lpServiceStatus,
                      sizeof(SERVICE_STATUS));

        serviceRecord->ServiceStatus.dwServiceType = oldType;
    }

    //
    // For dependency handling
    //
    if ((serviceRecord->ServiceStatus.dwCurrentState == SERVICE_RUNNING ||
         serviceRecord->ServiceStatus.dwCurrentState == SERVICE_STOPPED ||
         serviceRecord->ServiceStatus.dwCurrentState == SERVICE_STOP_PENDING) &&
        oldState == SERVICE_START_PENDING)
    {
        if (serviceRecord->ServiceStatus.dwCurrentState == SERVICE_STOPPED ||
            serviceRecord->ServiceStatus.dwCurrentState == SERVICE_STOP_PENDING)
        {
            serviceRecord->StartState = SC_START_FAIL;
            SC_LOG(DEPEND, "%ws START_PENDING -> FAIL\n", serviceRecord->ServiceName);
        }
        else if (serviceRecord->ServiceStatus.dwCurrentState == SERVICE_RUNNING)
        {
            serviceRecord->StartState = SC_START_SUCCESS;
            SC_LOG(DEPEND, "%ws START_PENDING -> RUNNING\n", serviceRecord->ServiceName);
#ifdef TIMING_TEST
            DbgPrint("[SC_TIMING] TickCount for RUNNING service \t%ws\t%d\n",
            serviceRecord->ServiceName, GetTickCount());
#endif // TIMING_TEST
        }

        //
        // Tell the dependency handling code that a start-pending
        // service is now running or stopped.
        //
        ScNotifyChangeState();
    }

    //
    // Note:  We no longer need an exclusive lock on the service records,
    // but we still need at least a shared lock, since we read the
    // DisplayName and ErrorControl fields below.  (If we didn't have a
    // shared lock, ChangeServiceConfig could change the fields under
    // us.)  Later, we call ScRemoveServiceBits and ScRemoveService,
    // which acquire an exclusive lock, which is problematic if we
    // already have a shared lock.
    // To keep things simple, we just hold onto the exclusive lock.
    //

    //
    // Log an event about the service's new state if appropriate.  Don't
    // do this during auto-start to avoid hurting boot performance and
    // filling the log with a start event for every auto-start service.
    //
    if (!ScAutoStartInProgress
         &&
        lpServiceStatus->dwCurrentState != oldState
         &&
        IS_STATUS_LOGGABLE(lpServiceStatus->dwCurrentState))
    {
        ScLogControlEvent(NEVENT_SERVICE_STATUS_SUCCESS,
                          serviceRecord->DisplayName,
                          lpServiceStatus->dwCurrentState);
    }


    //
    // If the new status indicates that the service has just started,
    // tell NDIS to issue the PNP notifications about this service's arrival,
    // if it belongs to one of the groups NDIS is interested in.
    //
    if ((lpServiceStatus->dwCurrentState == SERVICE_RUNNING) &&
        (oldState != SERVICE_RUNNING))
    {
        ScNotifyNdis(serviceRecord);
    }

    //
    // If the new status indicates that the service has just stopped,
    // we need to check to see if there are any other services running
    // in the service process.  If not, then we can ask the service to
    // terminate.  Another thread is spawned to handle this since we need
    // to return from this call in order to allow the service to complete
    // its shutdown.
    //

    else if ((lpServiceStatus->dwCurrentState == SERVICE_STOPPED) &&
        (oldState != SERVICE_STOPPED))
    {
        if (lpServiceStatus->dwWin32ExitCode != NO_ERROR)
        {
            if (lpServiceStatus->dwWin32ExitCode != ERROR_SERVICE_SPECIFIC_ERROR)
            {
                ScLogEvent(
                    NEVENT_SERVICE_EXIT_FAILED,
                    serviceRecord->DisplayName,
                    lpServiceStatus->dwWin32ExitCode
                    );
            }
            else
            {
                ScLogEvent(
                    NEVENT_SERVICE_EXIT_FAILED_SPECIFIC,
                    serviceRecord->DisplayName,
                    lpServiceStatus->dwServiceSpecificExitCode
                    );
            }

            //
            // For popup after user has logged on to indicate that some service
            // started at boot has failed.
            //
            if (serviceRecord->ErrorControl == SERVICE_ERROR_NORMAL ||
                serviceRecord->ErrorControl == SERVICE_ERROR_SEVERE ||
                serviceRecord->ErrorControl == SERVICE_ERROR_CRITICAL)
            {
                ScPopupStartFail = TRUE;
            }
        }

        //
        // Clear the server announcement bits in the global location
        // for this service.
        //
        ScRemoveServiceBits(serviceRecord);

        //
        // If this is the last service in the process, then delete the
        // process handle from the ProcessWatcher list.
        //
        if ((serviceRecord->ImageRecord != NULL) &&
            (serviceRecord->ImageRecord->ServiceCount == 1))
        {
            NTSTATUS ntStatus;

            //
            // Check vs. NULL in case the work item registration failed.
            // Deregister here so the process cleanup routine doesn't get
            // called if the service process exits between now and when we
            // call ScRemoveService.
            //
            if (serviceRecord->ImageRecord->ObjectWaitHandle != NULL) {

                ntStatus = RtlDeregisterWait(serviceRecord->ImageRecord->ObjectWaitHandle);

                if (NT_SUCCESS(ntStatus)) {
                    serviceRecord->ImageRecord->ObjectWaitHandle = NULL;
                }
                else {

                    SC_LOG1(ERROR,
                            "RSetServiceStatus: RtlDeregisterWait failed 0x%x\n",
                            ntStatus);
                }
            }
        }

        //
        // Even though the service said it stopped, save a status of
        // STOP_PENDING.  ScRemoveService will set it to STOPPED.  This
        // is to prevent anyone else from trying to restart the service
        // between the time that our thread releases the locks here and
        // the time that ScRemoveService (in the thread we are about to
        // create) acquires the locks.  ScRemoveService must get to the
        // service first, because it may need to process an UPDATE_FLAG
        // set on the service before it's OK to restart it.
        //
        serviceRecord->ServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;

        SC_LOG(TRACE,
            "RSetServiceStatus:Create a thread to run ScRemoveService\n",0);

        threadHandle = CreateThread (
            NULL,                                   // Thread Attributes.
            0L,                                     // Stack Size
            (LPTHREAD_START_ROUTINE)RemovalThread,  // lpStartAddress
            (LPVOID)serviceRecord,                  // lpParameter
            0L,                                     // Creation Flags
            &threadId);                             // lpThreadId

        if (threadHandle == (HANDLE) NULL)
        {
            SC_LOG(ERROR,"RSetServiceStatus:CreateThread failed %d\n",
                GetLastError());

            //
            // If a thread couldn't be created to remove the service, it is removed
            // in the context of this thread.  The result of this is a somewhat
            // dirty termination.  The service record will be removed from the
            // installed database. If this was the last service in the process,
            // the process will terminate before we return to the thread.  Note that
            // we must release the locks before calling ScRemoveService since the
            // first thing it does is to acquire the list lock -- not releasing here
            // will cause deadlock (bug #103102).  The GroupListLock is not released
            // since ScRemoveService will acquire it in the same thread -- instead
            // of just releasing and then immediately reacquiring, release afterwards.
            //

            ScServiceRecordLock.Release();
            ScServiceListLock.Release();

            SC_LOG0(TRACE,"Attempting an in-thread removal in RSetServiceStatus\n");

            status = ScRemoveService(serviceRecord);

            if (groupListLocked)
            {
                ScGroupListLock.Release();
            }

            return status;
        }
        else
        {
            //
            // The Thread Creation was successful.
            //
            SC_LOG(TRACE,"Thread Creation Success, thread id = %#lx\n",threadId);
            CloseHandle(threadHandle);
        }
    }

    //
    // Release the locks we got earlier
    //
    ScServiceRecordLock.Release();

    if (lpServiceStatus->dwCurrentState == SERVICE_STOPPED)
    {
        ScServiceListLock.Release();
        if (groupListLocked)
        {
            ScGroupListLock.Release();
        }
    }

    SC_LOG(TRACE,"Return from RSetServiceStatus\n",0);

    return(status);

}


DWORD
RemovalThread(
    IN  LPSERVICE_RECORD    ServiceRecord
    )

/*++

Routine Description:

    This thread is used by RSetServiceStatus to remove a service from the
    Service Controller's database, and also - if necessary - shut down
    the service process.  The later step is only done if this was the last
    service running in that process.

    The use of this thread allows RSetServiceStatus to return to the service
    so that the service can then continue to terminate itself.

    We know that the service record will not go away before this thread
    acquires an exclusive lock on the database, because the service record's
    use count is not zero.

Arguments:

    ServiceRecord - This is a pointer to the service record that is being
        removed.

Return Value:

    Same as return values for RemoveService().

--*/
{
    ScRemoveService (ServiceRecord);

    return(0);
}

DWORD
RI_ScSetServiceBitsA(
    IN  SC_RPC_HANDLE   hService,
    IN  DWORD           dwServiceBits,
    IN  DWORD           bSetBitsOn,
    IN  DWORD           bUpdateImmediately,
    IN  LPSTR           pszReserved
    )

/*++

Routine Description:

    This function Or's the Service Bits that are passed in - into a
    global bitmask maintained by the service controller.  Everytime this
    function is called, we check to see if the server service is running.
    If it is, then we call an internal entry point in the server service
    to pass in the complete bitmask.

    This function also Or's the Service Bits into the ServerAnnounce
    element in the service's ServiceRecord.

    NOTE:  The exclusive database lock is obtained and held while the
           service record is being read, and while the GlobalServerAnnounce
           bits are set.

Arguments:


Return Value:

    NO_ERROR - The operation was completely successful.  The information
        may or may not be delivered to the Server depending on if it is
        running or not.

    or any error returned from the server service I_NetServerSetServiceBits
    function.

Note:


--*/
{
    if (ScShutdownInProgress) {
        return(ERROR_SHUTDOWN_IN_PROGRESS);
    }

    if (pszReserved != NULL) {
        return (ERROR_INVALID_PARAMETER);
    }

    return RI_ScSetServiceBitsW((SC_RPC_HANDLE)hService,
                                dwServiceBits,
                                bSetBitsOn,
                                bUpdateImmediately,
                                NULL);

}

DWORD
RI_ScSetServiceBitsW(
    IN  SC_RPC_HANDLE   hService,
    IN  DWORD           dwServiceBits,
    IN  DWORD           bSetBitsOn,
    IN  DWORD           bUpdateImmediately,
    IN  LPWSTR          pszReserved
    )

/*++

Routine Description:

    This function Or's the Service Bits that are passed in - into a
    global bitmask maintained by the service controller.  Everytime this
    function is called, we check to see if the server service is running.
    If it is, then we call an internal entry point in the server service
    to pass in the complete bitmask.

    This function also Or's the Service Bits into the ServerAnnounce
    element in the service's ServiceRecord.

    NOTE:  The exclusive database lock is obtained and held while the
           service record is being read, and while the GlobalServerAnnounce
           bits are set.

Arguments:


Return Value:

    NO_ERROR - The operation was completely successful.

    ERROR_GEN_FAILURE - The server service is there, but the call to
        update it failed.

Note:


--*/
{
    DWORD               status = NO_ERROR;
    LPSERVICE_RECORD    serviceRecord;
    LPWSTR              serverServiceName;
    DWORD               serviceState;

    if (ScShutdownInProgress) {
        return(ERROR_SHUTDOWN_IN_PROGRESS);
    }

    if (pszReserved != NULL) {
        return (ERROR_INVALID_PARAMETER);
    }

    //
    // Check the handle.
    //
    if (!ScIsValidServiceHandle(hService))
    {
        return ERROR_INVALID_HANDLE;
    }

    if (((LPSC_HANDLE_STRUCT)hService)->AccessGranted != SERVICE_SET_STATUS) {
        return(ERROR_INVALID_HANDLE);
    }

    if (ScNetServerSetServiceBits == (SETSBPROC)NULL) {
        if (! ScInitServerAnnounceFcn()) {
            return(ERROR_NO_NETWORK);
        }
    }

    serverServiceName = SERVICE_SERVER;

    CServiceListSharedLock LLock;
    CServiceRecordExclusiveLock RLock;

    serviceRecord = ((LPSC_HANDLE_STRUCT) hService)->Type.ScServiceObject.ServiceRecord;

    if (bSetBitsOn) {
        //
        // Set the bits in the global location.
        //
        GlobalServerAnnounce |= dwServiceBits;

        //
        // Set the bits in the service record.
        //

        serviceRecord->ServerAnnounce |= dwServiceBits;


    }
    else {
        //
        // Clear the bits in the global location.
        //
        GlobalServerAnnounce &= ~dwServiceBits;

        //
        // Clear the bits in the service record.
        //

        serviceRecord->ServerAnnounce &= ~dwServiceBits;


    }
    //
    // If the server service is running, then send the Global mask to
    // the server service.
    //

    status = ScGetNamedServiceRecord(
                serverServiceName,
                &serviceRecord);

    if (status == NO_ERROR) {

        serviceState = serviceRecord->ServiceStatus.dwCurrentState;

        if (serviceState == SERVICE_RUNNING) {

            status = ScNetServerSetServiceBits(
                        NULL,                   // ServerName
                        NULL,                   // TransportName
                        GlobalServerAnnounce,
                        bUpdateImmediately);

            if (status != NERR_Success) {
                SC_LOG(ERROR,"I_ScSetServiceBits: I_NetServerSetServiceBits failed %lu\n",
                       status);
            }
            else {
                SC_LOG(TRACE,"I_ScSetServiceBits: I_NetServerSetServiceBits success\n",0);
            }
        }
    }
    else {
        status = NO_ERROR;
    }

    SC_LOG(TRACE,"I_ScSetServiceBits: GlobalServerAnnounce = 0x%lx\n",
           GlobalServerAnnounce);

    return(status);
}


DWORD
ScRemoveServiceBits(
    IN  LPSERVICE_RECORD  ServiceRecord
    )

/*++

Routine Description:

    This function is called when a service stops running.  It looks in
    the service record for any server announcement bits that are set
    and turns them off in GlobalServerAnnounce.  The ServerAnnounce
    element in the service record is set to 0.

Arguments:

    ServiceRecord - This is a pointer to the service record that
        has changed to the stopped state.

Return Value:

    The status returned from I_NetServerSetServiceBits.

--*/
{
    DWORD               status = NO_ERROR;
    LPSERVICE_RECORD    serverServiceRecord;
    DWORD               serviceState;


    if (ScNetServerSetServiceBits == (SETSBPROC)NULL) {
        if (! ScInitServerAnnounceFcn()) {
            return(ERROR_NO_NETWORK);
        }
    }

    if (ServiceRecord->ServerAnnounce != 0) {

        CServiceRecordExclusiveLock RLock;

        //
        // Clear the bits in the global location.
        //
        GlobalServerAnnounce &= ~(ServiceRecord->ServerAnnounce);


        //
        // Clear the bits in the service record.
        //

        ServiceRecord->ServerAnnounce = 0;

        SC_LOG1(TRACE,"RemoveServiceBits: New GlobalServerAnnounce = 0x%lx\n",
            GlobalServerAnnounce);

        //
        // If the server service is running, then send the Global mask to
        // the server service.
        //

        status = ScGetNamedServiceRecord(
                    SERVICE_SERVER,
                    &serverServiceRecord);


        if (status == NO_ERROR) {

            serviceState = serverServiceRecord->ServiceStatus.dwCurrentState;

            if ( serviceState == SERVICE_RUNNING) {

                status = ScNetServerSetServiceBits(
                            NULL,                   // ServerName
                            NULL,                   // Transport name
                            GlobalServerAnnounce,
                            TRUE);                  // Update immediately.

                if (status != NERR_Success) {
                    SC_LOG(ERROR,"ScRemoveServiceBits: I_NetServerSetServiceBits failed %d\n",
                    status);
                }
            }
        }
    }
    return(status);
}

BOOL
ScInitServerAnnounceFcn(
    VOID
    )

/*++

Routine Description:



Arguments:



Return Value:



--*/
{

    ScGlobalServerHandle = LoadLibraryW(L"netapi32.dll");

    if (ScGlobalServerHandle == NULL) {
        SC_LOG(ERROR,"ScInitServerAnnouncFcn: LoadLibrary failed %d\n",
            GetLastError());
        return(FALSE);
    }

    //
    // Use I_NetServerSetServiceBits rather than the Ex version since
    // it uses a special flag to prevent the RPC failure path from
    // calling back into services.exe and potentially causing a deadlock.
    //

    ScNetServerSetServiceBits = (SETSBPROC)GetProcAddress(
                                    ScGlobalServerHandle,
                                    "I_NetServerSetServiceBits");


    if (ScNetServerSetServiceBits == (SETSBPROC)NULL) {
        SC_LOG(ERROR,"ScInitServerAnnouncFcn: GetProcAddress failed %d\n",
            GetLastError());
        return(FALSE);
    }
    return TRUE;
}