/* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* This module ALONE requires the window message API from user.h * and the default APR include of windows.h will omit it, so * preload the API symbols now... */ #define CORE_PRIVATE #define _WINUSER_ #include "httpd.h" #include "http_log.h" #include "mpm_winnt.h" #include "apr_strings.h" #include "apr_lib.h" #include "ap_regkey.h" #ifdef NOUSER #undef NOUSER #endif #undef _WINUSER_ #include static char *mpm_service_name = NULL; static char *mpm_display_name = NULL; static struct { HANDLE mpm_thread; /* primary thread handle of the apache server */ HANDLE service_thread; /* thread service/monitor handle */ DWORD service_thread_id;/* thread service/monitor ID */ HANDLE service_init; /* controller thread init mutex */ HANDLE service_term; /* NT service thread kill signal */ SERVICE_STATUS ssStatus; SERVICE_STATUS_HANDLE hServiceStatus; } globdat; static int ReportStatusToSCMgr(int currentState, int exitCode, int waitHint); #define PRODREGKEY "SOFTWARE\\" AP_SERVER_BASEVENDOR "\\" \ AP_SERVER_BASEPRODUCT "\\" AP_SERVER_BASEREVISION /* * Get the server root from the registry into 'dir' which is * size bytes long. Returns 0 if the server root was found * or if the serverroot key does not exist (in which case * dir will contain an empty string), or -1 if there was * an error getting the key. */ apr_status_t ap_registry_get_server_root(apr_pool_t *p, char **buf) { apr_status_t rv; ap_regkey_t *key; if ((rv = ap_regkey_open(&key, AP_REGKEY_LOCAL_MACHINE, PRODREGKEY, APR_READ, p)) == APR_SUCCESS) { rv = ap_regkey_value_get(buf, key, "ServerRoot", p); ap_regkey_close(key); if (rv == APR_SUCCESS) return rv; } if ((rv = ap_regkey_open(&key, AP_REGKEY_CURRENT_USER, PRODREGKEY, APR_READ, p)) == APR_SUCCESS) { rv = ap_regkey_value_get(buf, key, "ServerRoot", p); ap_regkey_close(key); if (rv == APR_SUCCESS) return rv; } *buf = NULL; return rv; } /* The service configuration's is stored under the following trees: * * HKLM\System\CurrentControlSet\Services\[service name] * * \DisplayName * \ImagePath * \Parameters\ConfigArgs * * For Win9x, the launch service command is stored under: * * HKLM\Software\Microsoft\Windows\CurrentVersion\RunServices\[service name] */ /* exit() for Win32 is macro mapped (horrible, we agree) that allows us * to catch the non-zero conditions and inform the console process that * the application died, and hang on to the console a bit longer. * * The macro only maps for http_main.c and other sources that include * the service.h header, so we best assume it's an error to exit from * _any_ other module. * * If ap_real_exit_code is reset to 0, it will not be set or trigger this * behavior on exit. All service and child processes are expected to * reset this flag to zero to avoid undesireable side effects. */ AP_DECLARE_DATA int ap_real_exit_code = 1; void hold_console_open_on_error(void) { HANDLE hConIn; HANDLE hConErr; DWORD result; time_t start; time_t remains; char *msg = "Note the errors or messages above, " "and press the key to exit. "; CONSOLE_SCREEN_BUFFER_INFO coninfo; INPUT_RECORD in; char count[16]; if (!ap_real_exit_code) return; hConIn = GetStdHandle(STD_INPUT_HANDLE); hConErr = GetStdHandle(STD_ERROR_HANDLE); if ((hConIn == INVALID_HANDLE_VALUE) || (hConErr == INVALID_HANDLE_VALUE)) return; if (!WriteConsole(hConErr, msg, (DWORD)strlen(msg), &result, NULL) || !result) return; if (!GetConsoleScreenBufferInfo(hConErr, &coninfo)) return; if (!SetConsoleMode(hConIn, ENABLE_MOUSE_INPUT | 0x80)) return; start = time(NULL); do { while (PeekConsoleInput(hConIn, &in, 1, &result) && result) { if (!ReadConsoleInput(hConIn, &in, 1, &result) || !result) return; if ((in.EventType == KEY_EVENT) && in.Event.KeyEvent.bKeyDown && (in.Event.KeyEvent.uChar.AsciiChar == 27)) return; if (in.EventType == MOUSE_EVENT && (in.Event.MouseEvent.dwEventFlags == DOUBLE_CLICK)) return; } remains = ((start + 30) - time(NULL)); sprintf (count, "%d...", remains); if (!SetConsoleCursorPosition(hConErr, coninfo.dwCursorPosition)) return; if (!WriteConsole(hConErr, count, (DWORD)strlen(count), &result, NULL) || !result) return; } while ((remains > 0) && WaitForSingleObject(hConIn, 1000) != WAIT_FAILED); } static BOOL die_on_logoff = FALSE; static LRESULT CALLBACK monitor_service_9x_proc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { /* This is the WndProc procedure for our invisible window. * When the user shuts down the system, this window is sent * a signal WM_ENDSESSION. We clean up by signaling Apache * to shut down, and idle until Apache's primary thread quits. */ if ((msg == WM_ENDSESSION) && (die_on_logoff || (lParam != ENDSESSION_LOGOFF))) { ap_signal_parent(SIGNAL_PARENT_SHUTDOWN); if (wParam) /* Don't leave this message until we are dead! */ WaitForSingleObject(globdat.mpm_thread, 30000); return 0; } return (DefWindowProc(hWnd, msg, wParam, lParam)); } static DWORD WINAPI monitor_service_9x_thread(void *service_name) { /* When running as a service under Windows 9x, there is no console * window present, and no ConsoleCtrlHandler to call when the system * is shutdown. If the WatchWindow thread is created with a NULL * service_name argument, then the ...SystemMonitor window class is * used to create the "Apache" window to watch for logoff and shutdown. * If the service_name is provided, the ...ServiceMonitor window class * is used to create the window named by the service_name argument, * and the logoff message is ignored. */ WNDCLASS wc; HWND hwndMain; MSG msg; wc.style = CS_GLOBALCLASS; wc.lpfnWndProc = monitor_service_9x_proc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = NULL; wc.hIcon = NULL; wc.hCursor = NULL; wc.hbrBackground = NULL; wc.lpszMenuName = NULL; if (service_name) wc.lpszClassName = "ApacheWin95ServiceMonitor"; else wc.lpszClassName = "ApacheWin95SystemMonitor"; die_on_logoff = service_name ? FALSE : TRUE; if (!RegisterClass(&wc)) { ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, apr_get_os_error(), NULL, "Could not register window class for WatchWindow"); globdat.service_thread_id = 0; return 0; } /* Create an invisible window */ hwndMain = CreateWindow(wc.lpszClassName, service_name ? (char *) service_name : "Apache", WS_OVERLAPPEDWINDOW & ~WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, NULL, NULL); if (!hwndMain) { ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, apr_get_os_error(), NULL, "Could not create WatchWindow"); globdat.service_thread_id = 0; return 0; } /* If we succeed, eliminate the console window. * Signal the parent we are all set up, and * watch the message queue while the window lives. */ FreeConsole(); SetEvent(globdat.service_init); while (GetMessage(&msg, NULL, 0, 0)) { if (msg.message == WM_CLOSE) DestroyWindow(hwndMain); else { TranslateMessage(&msg); DispatchMessage(&msg); } } globdat.service_thread_id = 0; return 0; } static BOOL CALLBACK console_control_handler(DWORD ctrl_type) { switch (ctrl_type) { case CTRL_BREAK_EVENT: fprintf(stderr, "Apache server restarting...\n"); ap_signal_parent(SIGNAL_PARENT_RESTART); return TRUE; case CTRL_C_EVENT: fprintf(stderr, "Apache server interrupted...\n"); /* for Interrupt signals, shut down the server. * Tell the system we have dealt with the signal * without waiting for Apache to terminate. */ ap_signal_parent(SIGNAL_PARENT_SHUTDOWN); return TRUE; case CTRL_CLOSE_EVENT: case CTRL_LOGOFF_EVENT: case CTRL_SHUTDOWN_EVENT: /* for Terminate signals, shut down the server. * Wait for Apache to terminate, but respond * after a reasonable time to tell the system * that we did attempt to shut ourself down. * THESE EVENTS WILL NOT OCCUR UNDER WIN9x! */ fprintf(stderr, "Apache server shutdown initiated...\n"); ap_signal_parent(SIGNAL_PARENT_SHUTDOWN); Sleep(30000); return TRUE; } /* We should never get here, but this is (mostly) harmless */ return FALSE; } static void stop_console_handler(void) { SetConsoleCtrlHandler(console_control_handler, FALSE); } void mpm_start_console_handler(void) { SetConsoleCtrlHandler(console_control_handler, TRUE); atexit(stop_console_handler); } /* Special situation - children of services need to mind their * P's & Q's and wait quietly, ignoring the mean OS signaling * shutdown and other horrors, to kill them gracefully... */ static BOOL CALLBACK child_control_handler(DWORD ctrl_type) { switch (ctrl_type) { case CTRL_C_EVENT: case CTRL_BREAK_EVENT: /* for Interrupt signals, ignore them. * The system will also signal the parent process, * which will terminate Apache. */ return TRUE; case CTRL_CLOSE_EVENT: case CTRL_LOGOFF_EVENT: case CTRL_SHUTDOWN_EVENT: /* for Shutdown signals, ignore them, but... . * The system will also signal the parent process, * which will terminate Apache, so we need to wait. */ Sleep(30000); return TRUE; } /* We should never get here, but this is (mostly) harmless */ return FALSE; } static void stop_child_console_handler(void) { SetConsoleCtrlHandler(child_control_handler, FALSE); } void mpm_start_child_console_handler(void) { if (osver.dwPlatformId == VER_PLATFORM_WIN32_NT) { FreeConsole(); } else { SetConsoleCtrlHandler(child_control_handler, TRUE); atexit(stop_child_console_handler); } } /********************************** WinNT service control management **********************************/ static int ReportStatusToSCMgr(int currentState, int exitCode, int waitHint) { static int checkPoint = 1; int rv = APR_SUCCESS; if (globdat.hServiceStatus) { if (currentState == SERVICE_RUNNING) { globdat.ssStatus.dwWaitHint = 0; globdat.ssStatus.dwCheckPoint = 0; globdat.ssStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP; } else if (currentState == SERVICE_STOPPED) { globdat.ssStatus.dwWaitHint = 0; globdat.ssStatus.dwCheckPoint = 0; if (!exitCode && globdat.ssStatus.dwCurrentState != SERVICE_STOP_PENDING) { /* An unexpected exit? Better to error! */ exitCode = 1; } if (exitCode) { globdat.ssStatus.dwWin32ExitCode =ERROR_SERVICE_SPECIFIC_ERROR; globdat.ssStatus.dwServiceSpecificExitCode = exitCode; } } else { globdat.ssStatus.dwCheckPoint = ++checkPoint; globdat.ssStatus.dwControlsAccepted = 0; if(waitHint) globdat.ssStatus.dwWaitHint = waitHint; } globdat.ssStatus.dwCurrentState = currentState; rv = SetServiceStatus(globdat.hServiceStatus, &globdat.ssStatus); } return(rv); } /* Set the service description regardless of platform. * We revert to set_service_description on NT/9x, the * very long way so any Apache management program can grab the * description. This would be bad on Win2000, since it wouldn't * notify the service control manager of the name change. */ /* borrowed from mpm_winnt.c */ extern apr_pool_t *pconf; /* Windows 2000 alone supports ChangeServiceConfig2 in order to * register our server_version string... so we need some fixups * to avoid binding to that function if we are on WinNT/9x. */ static void set_service_description(void) { const char *full_description; SC_HANDLE schSCManager; BOOL ret = 0; /* Nothing to do if we are a console */ if (!mpm_service_name) return; /* Time to fix up the description, upon each successful restart */ full_description = ap_get_server_description(); if ((osver.dwPlatformId == VER_PLATFORM_WIN32_NT) && (osver.dwMajorVersion > 4) && (ChangeServiceConfig2) && (schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT))) { SC_HANDLE schService = OpenService(schSCManager, mpm_service_name, SERVICE_CHANGE_CONFIG); if (schService) { /* Cast is necessary, ChangeServiceConfig2 handles multiple * object types, some volatile, some not. */ /* ###: utf-ize */ if (ChangeServiceConfig2(schService, 1 /* SERVICE_CONFIG_DESCRIPTION */, (LPVOID) &full_description)) { full_description = NULL; } CloseServiceHandle(schService); } CloseServiceHandle(schSCManager); } if (full_description) { char szPath[MAX_PATH]; ap_regkey_t *svckey; apr_status_t rv; /* Find the Service key that Monitor Applications iterate */ apr_snprintf(szPath, sizeof(szPath), "SYSTEM\\CurrentControlSet\\Services\\%s", mpm_service_name); rv = ap_regkey_open(&svckey, AP_REGKEY_LOCAL_MACHINE, szPath, APR_READ | APR_WRITE, pconf); if (rv != APR_SUCCESS) { return; } /* Attempt to set the Description value for our service */ ap_regkey_value_set(svckey, "Description", full_description, 0, pconf); ap_regkey_close(svckey); } } /* handle the SCM's ControlService() callbacks to our service */ static VOID WINAPI service_nt_ctrl(DWORD dwCtrlCode) { if (dwCtrlCode == SERVICE_CONTROL_STOP) { ap_signal_parent(SIGNAL_PARENT_SHUTDOWN); ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR, 30000); return; } if (dwCtrlCode == SERVICE_APACHE_RESTART) { ap_signal_parent(SIGNAL_PARENT_RESTART); ReportStatusToSCMgr(SERVICE_START_PENDING, NO_ERROR, 30000); return; } ReportStatusToSCMgr(globdat.ssStatus.dwCurrentState, NO_ERROR, 0); } /* service_nt_main_fn is outside of the call stack and outside of the * primary server thread... so now we _really_ need a placeholder! * The winnt_rewrite_args has created and shared mpm_new_argv with us. */ extern apr_array_header_t *mpm_new_argv; /* ###: utf-ize */ static void __stdcall service_nt_main_fn(DWORD argc, LPTSTR *argv) { const char *ignored; /* args and service names live in the same pool */ mpm_service_set_name(mpm_new_argv->pool, &ignored, argv[0]); memset(&globdat.ssStatus, 0, sizeof(globdat.ssStatus)); globdat.ssStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS; globdat.ssStatus.dwCurrentState = SERVICE_START_PENDING; globdat.ssStatus.dwCheckPoint = 1; /* ###: utf-ize */ if (!(globdat.hServiceStatus = RegisterServiceCtrlHandler(argv[0], service_nt_ctrl))) { ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, apr_get_os_error(), NULL, "Failure registering service handler"); return; } /* Report status, no errors, and buy 3 more seconds */ ReportStatusToSCMgr(SERVICE_START_PENDING, NO_ERROR, 30000); /* We need to append all the command arguments passed via StartService() * to our running service... which just got here via the SCM... * but we hvae no interest in argv[0] for the mpm_new_argv list. */ if (argc > 1) { char **cmb_data; mpm_new_argv->nalloc = mpm_new_argv->nelts + argc - 1; cmb_data = malloc(mpm_new_argv->nalloc * sizeof(const char *)); /* mpm_new_argv remains first (of lower significance) */ memcpy (cmb_data, mpm_new_argv->elts, mpm_new_argv->elt_size * mpm_new_argv->nelts); /* Service args follow from StartService() invocation */ memcpy (cmb_data + mpm_new_argv->nelts, argv + 1, mpm_new_argv->elt_size * (argc - 1)); /* The replacement arg list is complete */ mpm_new_argv->elts = (char *)cmb_data; mpm_new_argv->nelts = mpm_new_argv->nalloc; } /* Let the main thread continue now... but hang on to the * signal_monitor event so we can take further action */ SetEvent(globdat.service_init); WaitForSingleObject(globdat.service_term, INFINITE); } DWORD WINAPI service_nt_dispatch_thread(LPVOID nada) { apr_status_t rv = APR_SUCCESS; SERVICE_TABLE_ENTRY dispatchTable[] = { { "", service_nt_main_fn }, { NULL, NULL } }; /* ###: utf-ize */ if (!StartServiceCtrlDispatcher(dispatchTable)) { /* This is a genuine failure of the SCM. */ rv = apr_get_os_error(); ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "Error starting service control dispatcher"); } return (rv); } apr_status_t mpm_service_set_name(apr_pool_t *p, const char **display_name, const char *set_name) { char key_name[MAX_PATH]; ap_regkey_t *key; apr_status_t rv; /* ### Needs improvement, on Win2K the user can _easily_ * change the display name to a string that doesn't reflect * the internal service name + whitespace! */ mpm_service_name = apr_palloc(p, strlen(set_name) + 1); apr_collapse_spaces((char*) mpm_service_name, set_name); apr_snprintf(key_name, sizeof(key_name), SERVICECONFIG, mpm_service_name); rv = ap_regkey_open(&key, AP_REGKEY_LOCAL_MACHINE, key_name, APR_READ, pconf); if (rv == APR_SUCCESS) { rv = ap_regkey_value_get(&mpm_display_name, key, "DisplayName", pconf); ap_regkey_close(key); } if (rv != APR_SUCCESS) { /* Take the given literal name if there is no service entry */ mpm_display_name = apr_pstrdup(p, set_name); } *display_name = mpm_display_name; return rv; } apr_status_t mpm_merge_service_args(apr_pool_t *p, apr_array_header_t *args, int fixed_args) { apr_array_header_t *svc_args = NULL; char conf_key[MAX_PATH]; char **cmb_data; apr_status_t rv; ap_regkey_t *key; apr_snprintf(conf_key, sizeof(conf_key), SERVICEPARAMS, mpm_service_name); rv = ap_regkey_open(&key, AP_REGKEY_LOCAL_MACHINE, conf_key, APR_READ, p); if (rv == APR_SUCCESS) { rv = ap_regkey_value_array_get(&svc_args, key, "ConfigArgs", p); ap_regkey_close(key); } if (rv != APR_SUCCESS) { if (rv == ERROR_FILE_NOT_FOUND) { ap_log_error(APLOG_MARK, APLOG_INFO, 0, NULL, "No ConfigArgs registered for %s, perhaps " "this service is not installed?", mpm_service_name); return APR_SUCCESS; } else return (rv); } if (!svc_args || svc_args->nelts == 0) { return (APR_SUCCESS); } /* Now we have the mpm_service_name arg, and the mpm_runservice_nt() * call appended the arguments passed by StartService(), so it's * time to _prepend_ the default arguments for the server from * the service's default arguments (all others override them)... */ args->nalloc = args->nelts + svc_args->nelts; cmb_data = malloc(args->nalloc * sizeof(const char *)); /* First three args (argv[0], -f, path) remain first */ memcpy(cmb_data, args->elts, args->elt_size * fixed_args); /* Service args follow from service registry array */ memcpy(cmb_data + fixed_args, svc_args->elts, svc_args->elt_size * svc_args->nelts); /* Remaining new args follow */ memcpy(cmb_data + fixed_args + svc_args->nelts, (const char **)args->elts + fixed_args, args->elt_size * (args->nelts - fixed_args)); args->elts = (char *)cmb_data; args->nelts = args->nalloc; return APR_SUCCESS; } void service_stopped(void) { /* Still have a thread & window to clean up, so signal now */ if (globdat.service_thread) { if (osver.dwPlatformId == VER_PLATFORM_WIN32_NT) { /* Stop logging to the event log */ mpm_nt_eventlog_stderr_flush(); /* Cause the service_nt_main_fn to complete */ ReleaseMutex(globdat.service_term); ReportStatusToSCMgr(SERVICE_STOPPED, // service state NO_ERROR, // exit code 0); // wait hint } else /* osver.dwPlatformId != VER_PLATFORM_WIN32_NT */ { RegisterServiceProcess(0, 0); PostThreadMessage(globdat.service_thread_id, WM_CLOSE, 0, 0); } WaitForSingleObject(globdat.service_thread, 5000); CloseHandle(globdat.service_thread); } } apr_status_t mpm_service_to_start(const char **display_name, apr_pool_t *p) { HANDLE hProc = GetCurrentProcess(); HANDLE hThread = GetCurrentThread(); HANDLE waitfor[2]; /* Prevent holding open the (hidden) console */ ap_real_exit_code = 0; /* GetCurrentThread returns a psuedo-handle, we need * a real handle for another thread to wait upon. */ if (!DuplicateHandle(hProc, hThread, hProc, &(globdat.mpm_thread), 0, FALSE, DUPLICATE_SAME_ACCESS)) { return APR_ENOTHREAD; } if (osver.dwPlatformId == VER_PLATFORM_WIN32_NT) { globdat.service_init = CreateEvent(NULL, FALSE, FALSE, NULL); globdat.service_term = CreateMutex(NULL, TRUE, NULL); if (!globdat.service_init || !globdat.service_term) { return APR_EGENERAL; } globdat.service_thread = CreateThread(NULL, 0, service_nt_dispatch_thread, NULL, 0, &globdat.service_thread_id); } else /* osver.dwPlatformId != VER_PLATFORM_WIN32_NT */ { if (!RegisterServiceProcess(0, 1)) return GetLastError(); globdat.service_init = CreateEvent(NULL, FALSE, FALSE, NULL); if (!globdat.service_init) { return APR_EGENERAL; } globdat.service_thread = CreateThread(NULL, 0, monitor_service_9x_thread, (LPVOID) mpm_service_name, 0, &globdat.service_thread_id); } if (!globdat.service_thread) { return APR_ENOTHREAD; } waitfor[0] = globdat.service_init; waitfor[1] = globdat.service_thread; /* Wait for controlling thread init or termination */ if (WaitForMultipleObjects(2, waitfor, FALSE, 10000) != WAIT_OBJECT_0) { return APR_ENOTHREAD; } atexit(service_stopped); *display_name = mpm_display_name; return APR_SUCCESS; } apr_status_t mpm_service_started(void) { set_service_description(); if (osver.dwPlatformId == VER_PLATFORM_WIN32_NT) { ReportStatusToSCMgr(SERVICE_RUNNING, // service state NO_ERROR, // exit code 0); // wait hint } return APR_SUCCESS; } void mpm_service_stopping(void) { if (osver.dwPlatformId == VER_PLATFORM_WIN32_NT) ReportStatusToSCMgr(SERVICE_STOP_PENDING, // service state NO_ERROR, // exit code 30000); // wait hint } apr_status_t mpm_service_install(apr_pool_t *ptemp, int argc, const char * const * argv, int reconfig) { char key_name[MAX_PATH]; char exe_path[MAX_PATH]; char *launch_cmd; ap_regkey_t *key; apr_status_t rv; fprintf(stderr,reconfig ? "Reconfiguring the %s service\n" : "Installing the %s service\n", mpm_display_name); /* ###: utf-ize */ if (GetModuleFileName(NULL, exe_path, sizeof(exe_path)) == 0) { apr_status_t rv = apr_get_os_error(); ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "GetModuleFileName failed"); return rv; } if (osver.dwPlatformId == VER_PLATFORM_WIN32_NT) { SC_HANDLE schService; SC_HANDLE schSCManager; schSCManager = OpenSCManager(NULL, NULL, /* local, default database */ SC_MANAGER_CREATE_SERVICE); if (!schSCManager) { rv = apr_get_os_error(); ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "Failed to open the WinNT service manager"); return (rv); } launch_cmd = apr_psprintf(ptemp, "\"%s\" -k runservice", exe_path); if (reconfig) { /* ###: utf-ize */ schService = OpenService(schSCManager, mpm_service_name, SERVICE_CHANGE_CONFIG); if (!schService) { ap_log_error(APLOG_MARK, APLOG_ERR|APLOG_ERR, apr_get_os_error(), NULL, "OpenService failed"); } /* ###: utf-ize */ else if (!ChangeServiceConfig(schService, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, launch_cmd, NULL, NULL, "Tcpip\0Afd\0", NULL, NULL, mpm_display_name)) { ap_log_error(APLOG_MARK, APLOG_ERR|APLOG_ERR, apr_get_os_error(), NULL, "ChangeServiceConfig failed"); /* !schService aborts configuration below */ CloseServiceHandle(schService); schService = NULL; } } else { /* RPCSS is the Remote Procedure Call (RPC) Locator required * for DCOM communication pipes. I am far from convinced we * should add this to the default service dependencies, but * be warned that future apache modules or ISAPI dll's may * depend on it. */ /* ###: utf-ize */ schService = CreateService(schSCManager, // SCManager database mpm_service_name, // name of service mpm_display_name, // name to display SERVICE_ALL_ACCESS, // access required SERVICE_WIN32_OWN_PROCESS, // service type SERVICE_AUTO_START, // start type SERVICE_ERROR_NORMAL, // error control type launch_cmd, // service's binary NULL, // no load svc group NULL, // no tag identifier "Tcpip\0Afd\0", // dependencies NULL, // use SYSTEM account NULL); // no password if (!schService) { rv = apr_get_os_error(); ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "Failed to create WinNT Service Profile"); CloseServiceHandle(schSCManager); return (rv); } } CloseServiceHandle(schService); CloseServiceHandle(schSCManager); } else /* osver.dwPlatformId != VER_PLATFORM_WIN32_NT */ { /* Store the launch command in the registry */ launch_cmd = apr_psprintf(ptemp, "\"%s\" -n %s -k runservice", exe_path, mpm_service_name); rv = ap_regkey_open(&key, AP_REGKEY_LOCAL_MACHINE, SERVICECONFIG9X, APR_READ | APR_WRITE | APR_CREATE, pconf); if (rv == APR_SUCCESS) { rv = ap_regkey_value_set(key, mpm_service_name, launch_cmd, 0, pconf); ap_regkey_close(key); } if (rv != APR_SUCCESS) { ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "%s: Failed to add the RunServices registry entry.", mpm_display_name); return (rv); } apr_snprintf(key_name, sizeof(key_name), SERVICECONFIG, mpm_service_name); rv = ap_regkey_open(&key, AP_REGKEY_LOCAL_MACHINE, key_name, APR_READ | APR_WRITE | APR_CREATE, pconf); if (rv != APR_SUCCESS) { ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "%s: Failed to create the registry service key.", mpm_display_name); return (rv); } rv = ap_regkey_value_set(key, "ImagePath", launch_cmd, 0, pconf); if (rv != APR_SUCCESS) { ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "%s: Failed to store ImagePath in the registry.", mpm_display_name); ap_regkey_close(key); return (rv); } rv = ap_regkey_value_set(key, "DisplayName", mpm_display_name, 0, pconf); ap_regkey_close(key); if (rv != APR_SUCCESS) { ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "%s: Failed to store DisplayName in the registry.", mpm_display_name); return (rv); } } set_service_description(); /* For both WinNT & Win9x store the service ConfigArgs in the registry... */ apr_snprintf(key_name, sizeof(key_name), SERVICEPARAMS, mpm_service_name); rv = ap_regkey_open(&key, AP_REGKEY_LOCAL_MACHINE, key_name, APR_READ | APR_WRITE | APR_CREATE, pconf); if (rv == APR_SUCCESS) { rv = ap_regkey_value_array_set(key, "ConfigArgs", argc, argv, pconf); ap_regkey_close(key); } if (rv != APR_SUCCESS) { ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "%s: Failed to store the ConfigArgs in the registry.", mpm_display_name); return (rv); } fprintf(stderr,"The %s service is successfully installed.\n", mpm_display_name); return APR_SUCCESS; } apr_status_t mpm_service_uninstall(void) { char key_name[MAX_PATH]; apr_status_t rv; if (osver.dwPlatformId == VER_PLATFORM_WIN32_NT) { SC_HANDLE schService; SC_HANDLE schSCManager; fprintf(stderr,"Removing the %s service\n", mpm_display_name); schSCManager = OpenSCManager(NULL, NULL, /* local, default database */ SC_MANAGER_CONNECT); if (!schSCManager) { rv = apr_get_os_error(); ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "Failed to open the WinNT service manager."); return (rv); } /* ###: utf-ize */ schService = OpenService(schSCManager, mpm_service_name, DELETE); if (!schService) { rv = apr_get_os_error(); ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "%s: OpenService failed", mpm_display_name); return (rv); } /* assure the service is stopped before continuing * * This may be out of order... we might not be able to be * granted all access if the service is running anyway. * * And do we want to make it *this easy* for them * to uninstall their service unintentionally? */ // ap_stop_service(schService); if (DeleteService(schService) == 0) { rv = apr_get_os_error(); ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "%s: Failed to delete the service.", mpm_display_name); return (rv); } CloseServiceHandle(schService); CloseServiceHandle(schSCManager); } else /* osver.dwPlatformId != VER_PLATFORM_WIN32_NT */ { apr_status_t rv2, rv3; ap_regkey_t *key; fprintf(stderr,"Removing the %s service\n", mpm_display_name); /* TODO: assure the service is stopped before continuing */ rv = ap_regkey_open(&key, AP_REGKEY_LOCAL_MACHINE, SERVICECONFIG9X, APR_READ | APR_WRITE | APR_CREATE, pconf); if (rv == APR_SUCCESS) { rv = ap_regkey_value_remove(key, mpm_service_name, pconf); ap_regkey_close(key); } if (rv != APR_SUCCESS) { ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "%s: Failed to remove the RunServices registry " "entry.", mpm_display_name); } /* we blast Services/us, not just the Services/us/Parameters branch */ apr_snprintf(key_name, sizeof(key_name), SERVICEPARAMS, mpm_service_name); rv2 = ap_regkey_remove(AP_REGKEY_LOCAL_MACHINE, key_name, pconf); apr_snprintf(key_name, sizeof(key_name), SERVICECONFIG, mpm_service_name); rv3 = ap_regkey_remove(AP_REGKEY_LOCAL_MACHINE, key_name, pconf); rv2 = (rv2 != APR_SUCCESS) ? rv2 : rv3; if (rv2 != APR_SUCCESS) { ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv2, NULL, "%s: Failed to remove the service config from the " "registry.", mpm_display_name); } rv = (rv != APR_SUCCESS) ? rv : rv2; if (rv != APR_SUCCESS) return rv; } fprintf(stderr,"The %s service has been removed successfully.\n", mpm_display_name); return APR_SUCCESS; } /* signal_service_transition is a simple thunk to signal the service * and monitor its successful transition. If the signal passed is 0, * then the caller is assumed to already have performed some service * operation to be monitored (such as StartService), and no actual * ControlService signal is sent. */ static int signal_service_transition(SC_HANDLE schService, DWORD signal, DWORD pending, DWORD complete) { if (signal && !ControlService(schService, signal, &globdat.ssStatus)) return FALSE; do { Sleep(1000); if (!QueryServiceStatus(schService, &globdat.ssStatus)) return FALSE; } while (globdat.ssStatus.dwCurrentState == pending); return (globdat.ssStatus.dwCurrentState == complete); } apr_status_t mpm_service_start(apr_pool_t *ptemp, int argc, const char * const * argv) { apr_status_t rv; fprintf(stderr,"Starting the %s service\n", mpm_display_name); if (osver.dwPlatformId == VER_PLATFORM_WIN32_NT) { char **start_argv; SC_HANDLE schService; SC_HANDLE schSCManager; schSCManager = OpenSCManager(NULL, NULL, /* local, default database */ SC_MANAGER_CONNECT); if (!schSCManager) { rv = apr_get_os_error(); ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "Failed to open the WinNT service manager"); return (rv); } /* ###: utf-ize */ schService = OpenService(schSCManager, mpm_service_name, SERVICE_START | SERVICE_QUERY_STATUS); if (!schService) { rv = apr_get_os_error(); ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "%s: Failed to open the service.", mpm_display_name); CloseServiceHandle(schSCManager); return (rv); } if (QueryServiceStatus(schService, &globdat.ssStatus) && (globdat.ssStatus.dwCurrentState == SERVICE_RUNNING)) { ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, 0, NULL, "Service %s is already started!", mpm_display_name); CloseServiceHandle(schService); CloseServiceHandle(schSCManager); return 0; } start_argv = malloc((argc + 1) * sizeof(const char **)); memcpy(start_argv, argv, argc * sizeof(const char **)); start_argv[argc] = NULL; rv = APR_EINIT; /* ###: utf-ize */ if (StartService(schService, argc, start_argv) && signal_service_transition(schService, 0, /* test only */ SERVICE_START_PENDING, SERVICE_RUNNING)) rv = APR_SUCCESS; if (rv != APR_SUCCESS) rv = apr_get_os_error(); CloseServiceHandle(schService); CloseServiceHandle(schSCManager); } else /* osver.dwPlatformId != VER_PLATFORM_WIN32_NT */ { STARTUPINFO si; /* Filled in prior to call to CreateProcess */ PROCESS_INFORMATION pi; /* filled in on call to CreateProcess */ char exe_path[MAX_PATH]; char exe_cmd[MAX_PATH * 4]; char *next_arg; int i; /* Locate the active top level window named service_name * provided the class is ApacheWin95ServiceMonitor */ if (FindWindow("ApacheWin95ServiceMonitor", mpm_service_name)) { ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, 0, NULL, "Service %s is already started!", mpm_display_name); return 0; } /* This may not appear intuitive, but Win9x will not allow a process * to detach from the console without releasing the entire console. * Ergo, we must spawn a new process for the service to get back our * console window. * The config is pre-flighted, so there should be no danger of failure. */ if (GetModuleFileName(NULL, exe_path, sizeof(exe_path)) == 0) { apr_status_t rv = apr_get_os_error(); ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, rv, NULL, "GetModuleFileName failed"); return rv; } apr_snprintf(exe_cmd, sizeof(exe_cmd), "\"%s\" -n %s -k runservice", exe_path, mpm_service_name); next_arg = strchr(exe_cmd, '\0'); for (i = 0; i < argc; ++i) { apr_snprintf(next_arg, sizeof(exe_cmd) - (next_arg - exe_cmd), " \"%s\"", argv[i]); next_arg = strchr(exe_cmd, '\0'); } memset(&si, 0, sizeof(si)); memset(&pi, 0, sizeof(pi)); si.cb = sizeof(si); si.dwFlags = STARTF_USESHOWWINDOW; si.wShowWindow = SW_HIDE; /* This might be redundant */ rv = APR_EINIT; if (CreateProcess(NULL, exe_cmd, NULL, NULL, FALSE, DETACHED_PROCESS, /* Creation flags */ NULL, NULL, &si, &pi)) { DWORD code; while (GetExitCodeProcess(pi.hProcess, &code) == STILL_ACTIVE) { if (FindWindow("ApacheWin95ServiceMonitor", mpm_service_name)) { rv = APR_SUCCESS; break; } Sleep (1000); } } if (rv != APR_SUCCESS) rv = apr_get_os_error(); CloseHandle(pi.hProcess); CloseHandle(pi.hThread); } if (rv == APR_SUCCESS) fprintf(stderr,"The %s service is running.\n", mpm_display_name); else ap_log_error(APLOG_MARK, APLOG_CRIT, rv, NULL, "%s: Failed to start the service process.", mpm_display_name); return rv; } /* signal is zero to stop, non-zero for restart */ void mpm_signal_service(apr_pool_t *ptemp, int signal) { int success = FALSE; if (osver.dwPlatformId == VER_PLATFORM_WIN32_NT) { SC_HANDLE schService; SC_HANDLE schSCManager; schSCManager = OpenSCManager(NULL, NULL, // default machine & database SC_MANAGER_CONNECT); if (!schSCManager) { ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, apr_get_os_error(), NULL, "Failed to open the NT Service Manager"); return; } /* ###: utf-ize */ schService = OpenService(schSCManager, mpm_service_name, SERVICE_INTERROGATE | SERVICE_QUERY_STATUS | SERVICE_USER_DEFINED_CONTROL | SERVICE_START | SERVICE_STOP); if (schService == NULL) { /* Could not open the service */ ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, apr_get_os_error(), NULL, "Failed to open the %s Service", mpm_display_name); CloseServiceHandle(schSCManager); return; } if (!QueryServiceStatus(schService, &globdat.ssStatus)) { ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, apr_get_os_error(), NULL, "Query of Service %s failed", mpm_display_name); CloseServiceHandle(schService); CloseServiceHandle(schSCManager); return; } if (!signal && (globdat.ssStatus.dwCurrentState == SERVICE_STOPPED)) { fprintf(stderr,"The %s service is not started.\n", mpm_display_name); CloseServiceHandle(schService); CloseServiceHandle(schSCManager); return; } fprintf(stderr,"The %s service is %s.\n", mpm_display_name, signal ? "restarting" : "stopping"); if (!signal) success = signal_service_transition(schService, SERVICE_CONTROL_STOP, SERVICE_STOP_PENDING, SERVICE_STOPPED); else if (globdat.ssStatus.dwCurrentState == SERVICE_STOPPED) { mpm_service_start(ptemp, 0, NULL); CloseServiceHandle(schService); CloseServiceHandle(schSCManager); return; } else success = signal_service_transition(schService, SERVICE_APACHE_RESTART, SERVICE_START_PENDING, SERVICE_RUNNING); CloseServiceHandle(schService); CloseServiceHandle(schSCManager); } else /* !isWindowsNT() */ { DWORD service_pid; HANDLE hwnd; char prefix[20]; /* Locate the active top level window named service_name * provided the class is ApacheWin95ServiceMonitor */ hwnd = FindWindow("ApacheWin95ServiceMonitor", mpm_service_name); if (hwnd && GetWindowThreadProcessId(hwnd, &service_pid)) globdat.ssStatus.dwCurrentState = SERVICE_RUNNING; else { globdat.ssStatus.dwCurrentState = SERVICE_STOPPED; if (!signal) { fprintf(stderr,"The %s service is not started.\n", mpm_display_name); return; } } fprintf(stderr,"The %s service is %s.\n", mpm_display_name, signal ? "restarting" : "stopping"); apr_snprintf(prefix, sizeof(prefix), "ap%ld", (long)service_pid); setup_signal_names(prefix); if (!signal) { int ticks = 60; ap_signal_parent(SIGNAL_PARENT_SHUTDOWN); while (--ticks) { if (!IsWindow(hwnd)) { success = TRUE; break; } Sleep(1000); } } else /* !stop */ { /* TODO: Aught to add a little test to the restart logic, and * store the restart counter in the window's user dword. * Then we can hang on and report a successful restart. But * that's a project for another day. */ if (globdat.ssStatus.dwCurrentState == SERVICE_STOPPED) { mpm_service_start(ptemp, 0, NULL); return; } else { success = TRUE; ap_signal_parent(SIGNAL_PARENT_RESTART); } } } if (success) fprintf(stderr,"The %s service has %s.\n", mpm_display_name, signal ? "restarted" : "stopped"); else fprintf(stderr,"Failed to %s the %s service.\n", signal ? "restart" : "stop", mpm_display_name); }