able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/netapi/svcdlls/browser/server/brmain.c

1310 lines
31 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1990-1992 Microsoft Corporation
Module Name:
brmain.c
Abstract:
This is the main routine for the NT LAN Manager Browser service.
Author:
Larry Osterman (LarryO) 3-23-92
Environment:
User Mode - Win32
Revision History:
--*/
#include "precomp.h"
#pragma hdrstop
#if DBG
#endif
//-------------------------------------------------------------------//
// //
// Local structure definitions //
// //
//-------------------------------------------------------------------//
ULONG
UpdateAnnouncementPeriodicity[] = {1*60*1000, 2*60*1000, 5*60*1000, 10*60*1000, 15*60*1000, 30*60*1000, 60*60*1000};
ULONG
UpdateAnnouncementMax = (sizeof(UpdateAnnouncementPeriodicity) / sizeof(ULONG)) - 1;
//-------------------------------------------------------------------//
// //
// Global variables //
// //
//-------------------------------------------------------------------//
BR_GLOBAL_DATA
BrGlobalData = {0};
ULONG
BrDefaultRole = {0};
PSVCHOST_GLOBAL_DATA BrLmsvcsGlobalData;
HANDLE BrGlobalEventlogHandle;
//-------------------------------------------------------------------//
// //
// Function prototypes //
// //
//-------------------------------------------------------------------//
NET_API_STATUS
BrInitializeBrowser(
OUT LPDWORD BrInitState
);
NET_API_STATUS
BrInitializeBrowserService(
OUT LPDWORD BrInitState
);
VOID
BrUninitializeBrowser(
IN DWORD BrInitState
);
VOID
BrShutdownBrowser(
IN NET_API_STATUS ErrorCode,
IN DWORD BrInitState
);
VOID
BrowserControlHandler(
IN DWORD Opcode
);
VOID
SvchostPushServiceGlobals (
PSVCHOST_GLOBAL_DATA pGlobals
)
{
BrLmsvcsGlobalData = pGlobals;
}
VOID
ServiceMain ( // (BROWSER_main)
DWORD NumArgs,
LPTSTR *ArgsArray
)
/*++
Routine Description:
This is the main routine of the Browser Service which registers
itself as an RPC server and notifies the Service Controller of the
Browser service control entry point.
Arguments:
NumArgs - Supplies the number of strings specified in ArgsArray.
ArgsArray - Supplies string arguments that are specified in the
StartService API call. This parameter is ignored by the
Browser service.
Return Value:
None.
--*/
{
NET_API_STATUS NetStatus;
DWORD BrInitState = 0;
BrGlobalBrowserSecurityDescriptor = NULL;
UNREFERENCED_PARAMETER(NumArgs);
UNREFERENCED_PARAMETER(ArgsArray);
//
// Make sure svchost.exe gave us the global data
//
ASSERT(BrLmsvcsGlobalData != NULL);
NetStatus = BrInitializeBrowserService(&BrInitState);
//
// Process requests in this thread, and wait for termination.
//
if ( NetStatus == NERR_Success) {
//
// Set the browser threads to time critical priority.
//
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
BrWorkerThread((PVOID)-1);
}
BrShutdownBrowser(
NetStatus,
BrInitState
);
return;
}
NET_API_STATUS
BrInitializeBrowserService(
OUT LPDWORD BrInitState
)
/*++
Routine Description:
This function initializes the Browser service.
Arguments:
BrInitState - Returns a flag to indicate how far we got with initializing
the Browser service before an error occured.
Return Value:
NET_API_STATUS - NERR_Success or reason for failure.
--*/
{
NET_API_STATUS Status;
NTSTATUS NtStatus;
//
// Initialize event logging
//
BrGlobalEventlogHandle = NetpEventlogOpen ( SERVICE_BROWSER,
2*60*60*1000 ); // 2 hours
if ( BrGlobalEventlogHandle == NULL ) {
BrPrint((BR_CRITICAL, "Cannot NetpEventlogOpen\n" ));
return ERROR_NOT_ENOUGH_MEMORY;
}
//
// Initialize all the status fields so that subsequent calls to
// SetServiceStatus need to only update fields that changed.
//
BrGlobalData.Status.dwServiceType = SERVICE_WIN32;
BrGlobalData.Status.dwCurrentState = SERVICE_START_PENDING;
BrGlobalData.Status.dwControlsAccepted = 0;
BrGlobalData.Status.dwCheckPoint = 0;
BrGlobalData.Status.dwWaitHint = BR_WAIT_HINT_TIME;
SET_SERVICE_EXITCODE(
NO_ERROR,
BrGlobalData.Status.dwWin32ExitCode,
BrGlobalData.Status.dwServiceSpecificExitCode
);
#if DBG
BrInitializeTraceLog();
#endif
BrPrint(( BR_INIT, "Browser starting\n"));
//
// Initialize Browser to receive service requests by registering the
// control handler.
//
if ((BrGlobalData.StatusHandle = RegisterServiceCtrlHandler(
SERVICE_BROWSER,
BrowserControlHandler
)) == (SERVICE_STATUS_HANDLE) 0) {
Status = GetLastError();
BrPrint(( BR_CRITICAL, "Cannot register control handler "
FORMAT_API_STATUS "\n", Status));
return Status;
}
//
// Create an event which is used by the service control handler to notify
// the Browser service that it is time to terminate.
//
if ((BrGlobalData.TerminateNowEvent =
CreateEvent(
NULL, // Event attributes
TRUE, // Event must be manually reset
FALSE,
NULL // Initial state not signalled
)) == NULL) {
Status = GetLastError();
BrPrint(( BR_CRITICAL, "Cannot create termination event "
FORMAT_API_STATUS "\n", Status));
return Status;
}
(*BrInitState) |= BR_TERMINATE_EVENT_CREATED;
//
// Notify the Service Controller for the first time that we are alive
// and we are start pending
//
if ((Status = BrGiveInstallHints( SERVICE_START_PENDING )) != NERR_Success) {
BrPrint(( BR_CRITICAL, "SetServiceStatus error "
FORMAT_API_STATUS "\n", Status));
return Status;
}
//
// Create well known SIDs for browser.dll
//
NtStatus = NetpCreateWellKnownSids( NULL );
if( !NT_SUCCESS( NtStatus ) ) {
Status = NetpNtStatusToApiStatus( NtStatus );
BrPrint(( BR_CRITICAL, "NetpCreateWellKnownSids error "
FORMAT_API_STATUS "\n", Status));
return Status;
}
//
// Create the security descriptors we'll use for the APIs
//
NtStatus = BrCreateBrowserObjects();
if( !NT_SUCCESS( NtStatus ) ) {
Status = NetpNtStatusToApiStatus( NtStatus );
BrPrint(( BR_CRITICAL, "BrCreateBrowserObjects error "
FORMAT_API_STATUS "\n", Status));
return Status;
}
//
// Open a handle to the driver.
//
if ((Status = BrOpenDgReceiver()) != NERR_Success) {
BrPrint(( BR_CRITICAL, "BrOpenDgReceiver error "
FORMAT_API_STATUS "\n", Status));
return Status;
}
BrPrint(( BR_INIT, "Devices initialized.\n"));
(*BrInitState) |= BR_DEVICES_INITIALIZED;
//
// Enable PNP to start queueing PNP notifications in the bowser driver.
// We won't actually get any notifications until we later call
// PostWaitForPnp ().
//
if ((Status = BrEnablePnp( TRUE )) != NERR_Success) {
BrPrint(( BR_CRITICAL, "BrEnablePnp error "
FORMAT_API_STATUS "\n", Status));
return Status;
}
BrPrint(( BR_INIT, "PNP initialized.\n"));
//
// Initialize NetBios synchronization with the service controller.
//
BrLmsvcsGlobalData->NetBiosOpen();
(*BrInitState) |= BR_NETBIOS_INITIALIZED;
//
// Read the configuration information to initialize the browser service.
//
if ((Status = BrInitializeBrowser(BrInitState)) != NERR_Success) {
BrPrint(( BR_CRITICAL, "Cannot start browser "
FORMAT_API_STATUS "\n", Status));
if (Status == NERR_ServiceInstalled) {
Status = NERR_WkstaInconsistentState;
}
return Status;
}
BrPrint(( BR_INIT, "Browser initialized.\n"));
(*BrInitState) |= BR_BROWSER_INITIALIZED;
//
// Service install still pending.
//
(void) BrGiveInstallHints( SERVICE_START_PENDING );
//
// Initialize the browser service to receive RPC requests
//
if ((Status = BrLmsvcsGlobalData->StartRpcServer(
BROWSER_INTERFACE_NAME,
browser_ServerIfHandle
)) != NERR_Success) {
BrPrint(( BR_CRITICAL, "Cannot start RPC server "
FORMAT_API_STATUS "\n", Status));
return Status;
}
(*BrInitState) |= BR_RPC_SERVER_STARTED;
//
// Update our announcement bits based on our current role.
//
// This will force the server to announce itself. It will also update
// the browser information in the driver.
//
//
if ((Status = BrUpdateAnnouncementBits( NULL, BR_PARANOID )) != NERR_Success) {
BrPrint(( BR_CRITICAL, "BrUpdateAnnouncementBits error "
FORMAT_API_STATUS "\n", Status));
return Status;
}
BrPrint(( BR_INIT, "Network status updated.\n"));
//
// We are done with starting the browser service. Tell Service
// Controller our new status.
//
if ((Status = BrGiveInstallHints( SERVICE_RUNNING )) != NERR_Success) {
BrPrint(( BR_CRITICAL, "SetServiceStatus error "
FORMAT_API_STATUS "\n", Status));
return Status;
}
if ((Status = PostWaitForPnp()) != NERR_Success) {
BrPrint(( BR_CRITICAL, "PostWaitForPnp error "
FORMAT_API_STATUS "\n", Status));
return Status;
}
BrPrint(( BR_MAIN, "Successful Initialization\n"));
return NERR_Success;
}
NET_API_STATUS
BrInitializeBrowser(
OUT LPDWORD BrInitState
)
/*++
Routine Description:
This function shuts down the Browser service.
Arguments:
ErrorCode - Supplies the error code of the failure
BrInitState - Supplies a flag to indicate how far we got with initializing
the Browser service before an error occured, thus the amount of
clean up needed.
Return Value:
None.
--*/
{
NET_API_STATUS NetStatus;
SERVICE_STATUS ServiceStatus;
//
// The browser depends on the following services being started:
//
// WORKSTATION (to initialize the bowser driver)
// SERVER (to receive remote APIs)
//
// Check to make sure that the services are started.
//
try{
if ((NetStatus = CheckForService(SERVICE_WORKSTATION, &ServiceStatus)) != NERR_Success) {
LPWSTR SubStrings[2];
CHAR ServiceStatusString[10];
WCHAR ServiceStatusStringW[10];
SubStrings[0] = SERVICE_WORKSTATION;
_ultoa(ServiceStatus.dwCurrentState, ServiceStatusString, 10);
mbstowcs(ServiceStatusStringW, ServiceStatusString, 10);
SubStrings[1] = ServiceStatusStringW;
BrLogEvent(EVENT_BROWSER_DEPENDANT_SERVICE_FAILED, NetStatus, 2, SubStrings);
try_return ( NetStatus );
}
if ((NetStatus = CheckForService(SERVICE_SERVER, &ServiceStatus)) != NERR_Success) {
LPWSTR SubStrings[2];
CHAR ServiceStatusString[10];
WCHAR ServiceStatusStringW[10];
SubStrings[0] = SERVICE_SERVER;
_ultoa(ServiceStatus.dwCurrentState, ServiceStatusString, 10);
mbstowcs(ServiceStatusStringW, ServiceStatusString, 10);
SubStrings[1] = ServiceStatusStringW;
BrLogEvent(EVENT_BROWSER_DEPENDANT_SERVICE_FAILED, NetStatus, 2, SubStrings);
try_return ( NetStatus );
}
BrPrint(( BR_INIT, "Dependant services are running.\n"));
//
// We now know that our dependant services are started.
//
// Look up our configuration information.
//
if ((NetStatus = BrGetBrowserConfiguration()) != NERR_Success) {
try_return ( NetStatus );
}
BrPrint(( BR_INIT, "Configuration read.\n"));
(*BrInitState) |= BR_CONFIG_INITIALIZED;
//
// Initialize the browser statistics now.
//
NumberOfServerEnumerations = 0;
NumberOfDomainEnumerations = 0;
NumberOfOtherEnumerations = 0;
NumberOfMissedGetBrowserListRequests = 0;
InitializeCriticalSection(&BrowserStatisticsLock);
//
// MaintainServerList == -1 means No
//
if (BrInfo.MaintainServerList == -1) {
BrPrint(( BR_CRITICAL, "MaintainServerList value set to NO. Stopping\n"));
try_return ( NetStatus = NERR_BrowserConfiguredToNotRun );
}
//
// Initialize the worker threads.
//
(void) BrGiveInstallHints( SERVICE_START_PENDING );
if ((NetStatus = BrWorkerInitialization()) != NERR_Success) {
try_return ( NetStatus );
}
BrPrint(( BR_INIT, "Worker threads created.\n"));
(*BrInitState) |= BR_THREADS_STARTED;
//
// Initialize the networks module
//
(void) BrGiveInstallHints( SERVICE_START_PENDING );
BrInitializeNetworks();
(*BrInitState) |= BR_NETWORKS_INITIALIZED;
//
// Initialize the Domains module (and create networks for primary domain)
//
(void) BrGiveInstallHints( SERVICE_START_PENDING );
NetStatus = BrInitializeDomains();
if ( NetStatus != NERR_Success ) {
try_return ( NetStatus );
}
(*BrInitState) |= BR_DOMAINS_INITIALIZED;
NetStatus = NERR_Success;
try_exit:NOTHING;
} finally {
#if DBG
if ( NetStatus != NERR_Success ) {
KdPrint( ("[Browser.dll]: Error <%lu>. Failed to initialize browser\n",
NetStatus ) );
}
#endif
}
return NetStatus;
}
VOID
BrUninitializeBrowser(
IN DWORD BrInitState
)
/*++
Routine Description:
This function shuts down the parts of the browser service started by
BrInitializeBrowser.
Arguments:
BrInitState - Supplies a flag to indicate how far we got with initializing
the Browser service before an error occured, thus the amount of
clean up needed.
Return Value:
None.
--*/
{
if (BrInitState & BR_CONFIG_INITIALIZED) {
BrDeleteConfiguration(BrInitState);
}
if (BrInitState & BR_DOMAINS_INITIALIZED) {
BrUninitializeDomains();
}
if (BrInitState & BR_NETWORKS_INITIALIZED) {
BrUninitializeNetworks(BrInitState);
}
DeleteCriticalSection(&BrowserStatisticsLock);
}
NET_API_STATUS
BrElectMasterOnNet(
IN PNETWORK Network,
IN PVOID Context
)
{
DWORD Event = PtrToUlong(Context);
PWSTR SubString[1];
REQUEST_ELECTION ElectionRequest;
if (!LOCK_NETWORK(Network)) {
return NERR_InternalError;
}
if (!(Network->Flags & NETWORK_RAS)) {
//
// Indicate we're forcing an election in the event log.
//
SubString[0] = Network->NetworkName.Buffer;
BrLogEvent(Event,
STATUS_SUCCESS,
1 | NETP_ALLOW_DUPLICATE_EVENTS,
SubString);
//
// Force an election on this net.
//
ElectionRequest.Type = Election;
ElectionRequest.ElectionRequest.Version = 0;
ElectionRequest.ElectionRequest.Criteria = 0;
ElectionRequest.ElectionRequest.TimeUp = 0;
ElectionRequest.ElectionRequest.MustBeZero = 0;
ElectionRequest.ElectionRequest.ServerName[0] = '\0';
SendDatagram( BrDgReceiverDeviceHandle,
&Network->NetworkName,
&Network->DomainInfo->DomUnicodeDomainNameString,
Network->DomainInfo->DomUnicodeDomainName,
BrowserElection,
&ElectionRequest,
sizeof(ElectionRequest));
}
UNLOCK_NETWORK(Network);
return NERR_Success;
}
NET_API_STATUS
BrShutdownBrowserForNet(
IN PNETWORK Network,
IN PVOID Context
)
{
NET_API_STATUS NetStatus;
if (!LOCK_NETWORK(Network)) {
return NERR_InternalError;
}
NetStatus = BrUpdateNetworkAnnouncementBits(Network, (PVOID)BR_SHUTDOWN );
if ( NetStatus != NERR_Success ) {
BrPrint(( BR_CRITICAL,
"%ws: %ws: BrShutdownBrowserForNet: Cannot BrUpdateNetworkAnnouncementBits %ld\n",
Network->DomainInfo->DomUnicodeDomainName,
Network->NetworkName.Buffer,
NetStatus ));
}
//
// Force an election if we are the master for this network - this will
// cause someone else to become master.
//
if ( Network->Role & ROLE_MASTER ) {
BrElectMasterOnNet(Network, (PVOID)EVENT_BROWSER_ELECTION_SENT_LANMAN_NT_STOPPED);
}
UNLOCK_NETWORK(Network);
//
// Continue with next network regardless of success or failure of this one.
//
return NERR_Success;
}
VOID
BrShutdownBrowser (
IN NET_API_STATUS ErrorCode,
IN DWORD BrInitState
)
/*++
Routine Description:
This function shuts down the Browser service.
Arguments:
ErrorCode - Supplies the error code of the failure
BrInitState - Supplies a flag to indicate how far we got with initializing
the Browser service before an error occured, thus the amount of
clean up needed.
Return Value:
None.
--*/
{
if (BrInitState & BR_RPC_SERVER_STARTED) {
//
// Stop the RPC server
//
BrLmsvcsGlobalData->StopRpcServer(browser_ServerIfHandle);
}
//
// Don't need to ask redirector to unbind from its transports when
// cleaning up because the redirector will tear down the bindings when
// it stops.
//
if (BrInitState & BR_DEVICES_INITIALIZED) {
//
// Disable PNP to prevent any new networks from being created.
//
BrEnablePnp( FALSE );
//
// Delete any networks.
//
if (BrInitState & BR_NETWORKS_INITIALIZED) {
BrEnumerateNetworks(BrShutdownBrowserForNet, NULL );
}
//
// Shut down the datagram receiver.
//
// This will cancel all I/O outstanding on the browser for this
// handle.
//
BrShutdownDgReceiver();
}
//
// Clean up the browser threads.
//
// This will guarantee that there are no operations outstanding in
// the browser when it is shut down.
//
if (BrInitState & BR_THREADS_STARTED) {
BrWorkerKillThreads();
}
if (BrInitState & BR_BROWSER_INITIALIZED) {
//
// Shut down the browser (including removing networks).
//
BrUninitializeBrowser(BrInitState);
}
//
// Now that we're sure no one will try to use the worker threads,
// Unitialize the subsystem.
//
if (BrInitState & BR_THREADS_STARTED) {
BrWorkerTermination();
}
if (BrInitState & BR_TERMINATE_EVENT_CREATED) {
//
// Close handle to termination event
//
CloseHandle(BrGlobalData.TerminateNowEvent);
}
if (BrInitState & BR_DEVICES_INITIALIZED) {
NtClose(BrDgReceiverDeviceHandle);
BrDgReceiverDeviceHandle = NULL;
}
//
// Tell service controller we are done using NetBios.
//
if (BrInitState & BR_NETBIOS_INITIALIZED) {
BrLmsvcsGlobalData->NetBiosClose();
}
//
// Delete well known SIDs if they are allocated already.
//
NetpFreeWellKnownSids();
if ( BrGlobalBrowserSecurityDescriptor != NULL ) {
NetpDeleteSecurityObject( &BrGlobalBrowserSecurityDescriptor );
BrGlobalBrowserSecurityDescriptor = NULL;
}
#if DBG
BrUninitializeTraceLog();
#endif
//
// Free the list of events that have already been logged.
//
NetpEventlogClose ( BrGlobalEventlogHandle );
BrGlobalEventlogHandle = NULL;
//
// We are done with cleaning up. Tell Service Controller that we are
// stopped.
//
SET_SERVICE_EXITCODE(
ErrorCode,
BrGlobalData.Status.dwWin32ExitCode,
BrGlobalData.Status.dwServiceSpecificExitCode
);
(void) BrGiveInstallHints( SERVICE_STOPPED );
}
NET_API_STATUS
BrGiveInstallHints(
DWORD NewState
)
/*++
Routine Description:
This function updates the Browser service status with the Service
Controller.
Arguments:
NewState - State to tell the service contoller
Return Value:
NET_API_STATUS - NERR_Success or reason for failure.
--*/
{
NET_API_STATUS status = NERR_Success;
//
// If we're not starting,
// we don't need this install hint.
//
if ( BrGlobalData.Status.dwCurrentState != SERVICE_START_PENDING &&
NewState == SERVICE_START_PENDING ) {
return NERR_Success;
}
//
// Update our state for the service controller.
//
BrGlobalData.Status.dwCurrentState = NewState;
switch ( NewState ) {
case SERVICE_RUNNING:
BrGlobalData.Status.dwControlsAccepted = SERVICE_ACCEPT_STOP;
//
// On DCs, shut down cleanly.
//
if (BrInfo.IsLanmanNt) {
BrGlobalData.Status.dwControlsAccepted |= SERVICE_ACCEPT_SHUTDOWN;
}
BrGlobalData.Status.dwCheckPoint = 0;
BrGlobalData.Status.dwWaitHint = 0;
break;
case SERVICE_START_PENDING:
BrGlobalData.Status.dwCheckPoint++;
break;
case SERVICE_STOPPED:
BrGlobalData.Status.dwCurrentState = SERVICE_STOPPED;
BrGlobalData.Status.dwControlsAccepted = 0;
BrGlobalData.Status.dwCheckPoint = 0;
BrGlobalData.Status.dwWaitHint = 0;
break;
case SERVICE_STOP_PENDING:
BrGlobalData.Status.dwCurrentState = SERVICE_STOP_PENDING;
BrGlobalData.Status.dwCheckPoint = 1;
BrGlobalData.Status.dwWaitHint = BR_WAIT_HINT_TIME;
break;
}
//
// Tell the service controller our current state.
//
if (BrGlobalData.StatusHandle == (SERVICE_STATUS_HANDLE) 0) {
BrPrint(( BR_CRITICAL,
"Cannot call SetServiceStatus, no status handle.\n"
));
return ERROR_INVALID_HANDLE;
}
if (! SetServiceStatus(BrGlobalData.StatusHandle, &BrGlobalData.Status)) {
status = GetLastError();
BrPrint(( BR_CRITICAL, "SetServiceStatus error %lu\n", status));
}
return status;
}
NET_API_STATUS
BrUpdateAnnouncementBits(
IN PDOMAIN_INFO DomainInfo OPTIONAL,
IN ULONG Flags
)
/*++
Routine Description:
This will update the service announcement bits appropriately depending on
the role of the browser server.
Arguments:
DomainInfo - Domain the announcement is to be made for
NULL implies the primary domain.
Flags - Control flags to pass to BrUpdateNetworkAnnouncement
Return Value:
Status - Status of the update..
--*/
{
NET_API_STATUS Status;
Status = BrEnumerateNetworksForDomain(DomainInfo, BrUpdateNetworkAnnouncementBits, ULongToPtr(Flags));
return Status;
}
ULONG
BrGetBrowserServiceBits(
IN PNETWORK Network
)
{
DWORD ServiceBits = 0;
if (Network->Role & ROLE_POTENTIAL_BACKUP) {
ServiceBits |= SV_TYPE_POTENTIAL_BROWSER;
}
if (Network->Role & ROLE_BACKUP) {
ServiceBits |= SV_TYPE_BACKUP_BROWSER;
}
if (Network->Role & ROLE_MASTER) {
ServiceBits |= SV_TYPE_MASTER_BROWSER;
}
if (Network->Role & ROLE_DOMAINMASTER) {
ServiceBits |= SV_TYPE_DOMAIN_MASTER;
ASSERT (ServiceBits & SV_TYPE_BACKUP_BROWSER);
}
return ServiceBits;
}
VOID
BrUpdateAnnouncementTimerRoutine(
IN PVOID TimerContext
)
/*++
Routine Description:
This routine is called periodically until we've successfully updated
our announcement status.
Arguments:
None.
Return Value:
None
--*/
{
PNETWORK Network = TimerContext;
ULONG Periodicity;
NET_API_STATUS Status;
//
// Prevent the network from being deleted while we're in this timer routine.
//
if ( BrReferenceNetwork( Network ) == NULL ) {
return;
}
if (!LOCK_NETWORK(Network)) {
return;
}
BrPrint(( BR_NETWORK,
"%ws: %ws: Periodic try to BrUpdateNetworkAnnouncementBits\n",
Network->DomainInfo->DomUnicodeDomainName,
Network->NetworkName.Buffer ));
//
// If we still need an announcement,
// do it now.
//
if ( Network->Flags & NETWORK_ANNOUNCE_NEEDED ) {
(VOID) BrUpdateNetworkAnnouncementBits( Network, (PVOID) BR_PARANOID );
}
UNLOCK_NETWORK(Network);
BrDereferenceNetwork( Network );
}
NET_API_STATUS
BrUpdateNetworkAnnouncementBits(
IN PNETWORK Network,
IN PVOID Context
)
/*++
Routine Description:
This is the informs the bowser driver and the SMB server the current status
of this transport.
Arguments:
Network - Network being updated
Context - Flags describing the circumstance of the call.
BR_SHUTDOWN - Transport is being shutdown.
BR_PARANOID - This is a superfluous call ensuring the services are
in sync with us.
Return Value:
None.
--*/
{
NET_API_STATUS NetStatus;
NET_API_STATUS NetStatusToReturn = NERR_Success;
ULONG Flags = PtrToUlong(Context);
ULONG Periodicity;
BOOL fUpdateNow;
ULONG ServiceBits;
if (!LOCK_NETWORK(Network)) {
return NERR_InternalError;
}
ServiceBits = BrGetBrowserServiceBits(Network);
//
// Have the browser update it's information.
//
//
// Don't ever tell the browser to turn off the potential bit - this
// has the side effect of turning off the election name.
//
NetStatus = BrUpdateBrowserStatus(
Network,
(Flags & BR_SHUTDOWN) ? 0 : ServiceBits | SV_TYPE_POTENTIAL_BROWSER);
if (NetStatus != NERR_Success) {
BrPrint(( BR_CRITICAL,
"%ws: %ws: BrUpdateNetworkAnnouncementBits: Cannot BrUpdateBrowserStatus %ld\n",
Network->DomainInfo->DomUnicodeDomainName,
Network->NetworkName.Buffer,
NetStatus ));
NetStatusToReturn = NetStatus;
}
#if DBG
BrUpdateDebugInformation(L"LastServiceStatus", L"LastServiceBits", Network->NetworkName.Buffer, NULL, ServiceBits);
#endif
//
// Tell the SMB server what the status is.
//
// On shutdown, tell it that we have no services.
// When paranoid (or pseudo), don't force an announcement.
//
#ifdef ENABLE_PSEUDO_BROWSER
if ( (Flags & BR_PARANOID) &&
BrInfo.PseudoServerLevel != BROWSER_PSEUDO ) {
fUpdateNow = TRUE;
}
else {
fUpdateNow = FALSE;
}
#else
fUpdateNow = (Flags & BR_PARANOID) ? TRUE : FALSE;
#endif
NetStatus = I_NetServerSetServiceBitsEx(
NULL,
Network->DomainInfo->DomUnicodeComputerName,
Network->NetworkName.Buffer,
BROWSER_SERVICE_BITS_OF_INTEREST,
( Flags & BR_SHUTDOWN) ? 0 : ServiceBits,
fUpdateNow );
if ( NetStatus != NERR_Success) {
BrPrint(( BR_CRITICAL,
"%ws: %ws: BrUpdateNetworkAnnouncementBits: Cannot I_NetServerSetServiceBitsEx %ld\n",
Network->DomainInfo->DomUnicodeDomainName,
Network->NetworkName.Buffer,
NetStatus ));
//
// If the only problem is that the transport doesn't exist in
// the SMB server, don't even bother reporting the problem.
// Or if it's a shutdown, filter out log failures. In some cases the
// smb svr is already unavailable & we get unexpected failures. Reporting
// to event log can mislead the admin.
//
if ( NetStatus != ERROR_PATH_NOT_FOUND &&
NetStatus != NERR_NetNameNotFound &&
!(Flags & BR_SHUTDOWN) ) {
BrLogEvent(EVENT_BROWSER_STATUS_BITS_UPDATE_FAILED, NetStatus, 0, NULL);
NetStatusToReturn = NetStatus;
#if 0
// debugging when we get service update bit failures
OutputDebugStringA("\nBrowser.dll: Update service bits tracing.\n");
ASSERT( NetStatus != NERR_Success );
#endif
}
//
// Either way. Mark that we need to announce again later.
//
Network->Flags |= NETWORK_ANNOUNCE_NEEDED;
Periodicity = UpdateAnnouncementPeriodicity[Network->UpdateAnnouncementIndex];
BrSetTimer(&Network->UpdateAnnouncementTimer, Periodicity, BrUpdateAnnouncementTimerRoutine, Network);
if (Network->UpdateAnnouncementIndex != UpdateAnnouncementMax) {
Network->UpdateAnnouncementIndex += 1;
}
//
// If we successfully informed the server,
// mark it.
//
} else {
Network->Flags &= ~NETWORK_ANNOUNCE_NEEDED;
Network->UpdateAnnouncementIndex = 0;
}
UNLOCK_NETWORK(Network);
return NetStatusToReturn;
}
VOID
BrowserControlHandler(
IN DWORD Opcode
)
/*++
Routine Description:
This is the service control handler of the Browser service.
Arguments:
Opcode - Supplies a value which specifies the action for the Browser
service to perform.
Arg - Supplies a value which tells a service specifically what to do
for an operation specified by Opcode.
Return Value:
None.
--*/
{
BrPrint(( BR_MAIN, "In Control Handler\n"));
switch (Opcode) {
case SERVICE_CONTROL_STOP:
case SERVICE_CONTROL_SHUTDOWN:
if (BrGlobalData.Status.dwCurrentState != SERVICE_STOP_PENDING) {
BrPrint(( BR_MAIN, "Stopping Browser...\n"));
if (! SetEvent(BrGlobalData.TerminateNowEvent)) {
//
// Problem with setting event to terminate Browser
// service.
//
BrPrint(( BR_CRITICAL, "Error setting TerminateNowEvent "
FORMAT_API_STATUS "\n", GetLastError()));
NetpAssert(FALSE);
}
}
//
// Send the status response.
//
(void) BrGiveInstallHints( SERVICE_STOP_PENDING );
return;
case SERVICE_CONTROL_INTERROGATE:
break;
default:
BrPrint(( BR_CRITICAL, "Unknown Browser opcode " FORMAT_HEX_DWORD
"\n", Opcode));
}
//
// Send the status response.
//
(void) BrGiveInstallHints( SERVICE_START_PENDING );
}
Reference in a new issue Copy permalink