/*++ Copyright (c) 1991 Microsoft Corporation Module Name: services.c Abstract: This is the service dispatcher for the security process. It contains the service dispatcher initialization routine and the routines to load the DLL for the individual serices and execute them. Author: Rajen Shah (rajens) 11-Apr-1991 [Environment:] User Mode - Win32 Revision History: 11-Apr-1991 RajenS created 27-Sep-1991 JohnRo More work toward UNICODE. 24-Jan-1991 CliffV Converted to be service dispatcher for the security process. --*/ // // INCLUDES // #include #include #include #include #include #include // NERR_ and ERROR_ equates. #include #include #include #include #include #if DBG #define IF_DEBUG() if (TRUE) #else #define IF_DEBUG() if (FALSE) #endif #define IN_RANGE(SomeValue, SomeMin, SomeMax) \ ( ((SomeValue) >= (SomeMin)) && ((SomeValue) <= (SomeMax)) ) // // SET_SERVICE_EXITCODE() sets the SomeApiStatus to NetCodeVariable // if it is within the NERR_BASE and NERR_MAX range. Otherwise, // Win32CodeVariable is set. // #define SET_SERVICE_EXITCODE(SomeApiStatus, Win32CodeVariable, NetCodeVariable) \ { \ if ((SomeApiStatus) == NERR_Success) { \ (Win32CodeVariable) = NO_ERROR; \ (NetCodeVariable) = NERR_Success; \ } else if (! IN_RANGE((SomeApiStatus), MIN_LANMAN_MESSAGE_ID, \ MAX_LANMAN_MESSAGE_ID)) { \ (Win32CodeVariable) = (DWORD) (SomeApiStatus); \ (NetCodeVariable) = (DWORD) (SomeApiStatus); \ } else { \ (Win32CodeVariable) = ERROR_SERVICE_SPECIFIC_ERROR; \ (NetCodeVariable) = (DWORD) (SomeApiStatus); \ } \ } typedef DWORD (*PNETLOGON_MAIN) ( \ IN DWORD dwNumServicesArgs, \ IN LPTSTR *lpServiceArgVectors \ ); VOID DummyControlHandler( IN DWORD opcode ) /*++ Routine Description: Process and respond to a control signal from the service controller. Arguments: opcode - Supplies a value which specifies the action for the Netlogon service to perform. Return Value: None. NOTE : this is a dummy handler, used to uninstall the netlogon service when we unable to load netlogon dll. --*/ { IF_DEBUG() { DbgPrint( "[Security Process] in control handler\n"); } return; } VOID SrvLoadNetlogon ( IN DWORD dwNumServicesArgs, IN LPTSTR *lpServiceArgVectors ) /*++ Routine Description: This routine is the 'main' routine for the netlogon service. It loads Netlogon.dll (which contains the remainder of the service) and calls the main entry point there. Arguments: dwNumServicesArgs - Number of arguments in lpServiceArgVectors. lpServiceArgVectors - Argument strings. Return Value: return nothing. Note: --*/ { NET_API_STATUS NetStatus; HANDLE NetlogonDllHandle = NULL; PNETLOGON_MAIN NetlogonMain; DWORD ReturnStatus; SERVICE_STATUS_HANDLE ServiceHandle; SERVICE_STATUS ServiceStatus; // // Load netlogon.dll // NetlogonDllHandle = LoadLibraryA( "Netlogon" ); if ( NetlogonDllHandle == NULL ) { NetStatus = GetLastError(); IF_DEBUG() { DbgPrint( "[Security process] " "load library netlogon.dll failed %ld\n", NetStatus ); } goto Cleanup; } // // Find the main entry point for the netlogon service. // NetlogonMain = (PNETLOGON_MAIN) GetProcAddress( NetlogonDllHandle, "NlNetlogonMain"); if ( NetlogonMain == NULL ) { NetStatus = GetLastError(); IF_DEBUG() { DbgPrint( "[Security process] GetProcAddress failed %ld\n", NetStatus ); } goto Cleanup; } // // Call the Netlogon service. // ReturnStatus = (*NetlogonMain)( dwNumServicesArgs, lpServiceArgVectors ); // // Unload the library and return. // (VOID) FreeLibrary( NetlogonDllHandle ); return; Cleanup: if ( NetlogonDllHandle != NULL ) { (VOID) FreeLibrary( NetlogonDllHandle ); } // // register netlogon to service controller // ServiceHandle = RegisterServiceCtrlHandler( SERVICE_NETLOGON, DummyControlHandler); if (ServiceHandle != (SERVICE_STATUS_HANDLE) NULL) { // // inform service controller that the service can't start. // ServiceStatus.dwServiceType = SERVICE_WIN32; ServiceStatus.dwCurrentState = SERVICE_STOPPED; ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE; ServiceStatus.dwCheckPoint = 0; ServiceStatus.dwWaitHint = 0; SET_SERVICE_EXITCODE( NetStatus, ServiceStatus.dwWin32ExitCode, ServiceStatus.dwServiceSpecificExitCode ); if( !SetServiceStatus( ServiceHandle, &ServiceStatus ) ) { IF_DEBUG() { DbgPrint( "[Security process] SetServiceStatus failed %ld\n", GetLastError() ); } } } else { IF_DEBUG() { DbgPrint( "[Security process] " "RegisterServiceCtrlHandler failed %ld\n", GetLastError() ); } } return; } // // Dispatch table for all services. Passed to NetServiceStartCtrlDispatcher. // // Add new service entries here. // SERVICE_TABLE_ENTRY SecurityServiceDispatchTable[] = { { SERVICE_NETLOGON, SrvLoadNetlogon }, { NULL, NULL } }; DWORD ServiceDispatcherThread ( LPVOID Parameter ) /*++ Routine Description: This routine synchronizes with the service controller. It waits for the service controller to set the SECURITY_SERVICES_STARTED event then starts up the main thread that is going to handle the control requests from the service controller. It basically sets up the ControlDispatcher and, on return, exits from this main thread. The call to NetServiceStartCtrlDispatcher does not return until all services have terminated, and this process can go away. It will be up to the ControlDispatcher thread to start/stop/pause/continue any services. If a service is to be started, it will create a thread and then call the main routine of that service. Arguments: EventHandle - Event handle to wait on before continuing. Return Value: Exit status of thread. Note: --*/ { DWORD WaitStatus; HANDLE EventHandle; BOOL StartStatus; // // Create an event for us to wait on. // EventHandle = CreateEventW( NULL, // No special security TRUE, // Must be manually reset FALSE, // The event is initially not signalled SECURITY_SERVICES_STARTED ); if ( EventHandle == NULL ) { WaitStatus = GetLastError(); // // If the event already exists, // the service controller already created it. Just open it. // if ( WaitStatus == ERROR_ALREADY_EXISTS ) { EventHandle = OpenEventW( EVENT_ALL_ACCESS, FALSE, SECURITY_SERVICES_STARTED ); if ( EventHandle == NULL ) { WaitStatus = GetLastError(); IF_DEBUG() { DbgPrint("[Security process] OpenEvent failed %ld\n", WaitStatus ); } return WaitStatus; } } else { IF_DEBUG() { DbgPrint("[Security process] CreateEvent failed %ld\n", WaitStatus); } return WaitStatus; } } // // Wait for the service controller to come up. // WaitStatus = WaitForSingleObject( (HANDLE) EventHandle, (DWORD) -1 ); (VOID) CloseHandle( EventHandle ); if ( WaitStatus != 0 ) { IF_DEBUG() { DbgPrint("[Security process] WaitForSingleObject failed %ld\n", WaitStatus ); } return WaitStatus; } // // Call NetServiceStartCtrlDispatcher to set up the control interface. // The API won't return until all services have been terminated. At that // point, we just exit. // StartStatus = StartServiceCtrlDispatcher ( SecurityServiceDispatchTable ); IF_DEBUG() { DbgPrint("[Security process] return from StartCtrlDispatcher %ld \n", StartStatus ); } return StartStatus; UNREFERENCED_PARAMETER(Parameter); } NTSTATUS ServiceInit ( VOID ) /*++ Routine Description: This is a main routine for the service dispatcher of the security process. It starts up a thread responsible for coordinating with the service controller. Arguments: NONE. Return Value: Status of the thread creation operation. Note: --*/ { DWORD ThreadId; HANDLE ThreadHandle; // // The control dispatcher runs in a thread of its own. // ThreadHandle = CreateThread( NULL, // No special thread attributes 0, // No special stack size &ServiceDispatcherThread, NULL, // No special parameter 0, // No special creation flags &ThreadId); if ( ThreadHandle == NULL ) { return (NTSTATUS) GetLastError(); } return STATUS_SUCCESS; }