ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/programs/services/rpc.c

1388 lines
39 KiB
C
Raw Blame History

/*
* Services.exe - RPC functions
*
* Copyright 2007 Google (Mikolaj Zalewski)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#define WIN32_LEAN_AND_MEAN
#include <stdarg.h>
#include <windows.h>
#include <winternl.h>
#include <winsvc.h>
#include <ntsecapi.h>
#include <rpc.h>
#include "wine/list.h"
#include "wine/unicode.h"
#include "wine/debug.h"
#include "services.h"
#include "svcctl.h"
extern HANDLE __wine_make_process_system(void);
WINE_DEFAULT_DEBUG_CHANNEL(service);
static const GENERIC_MAPPING g_scm_generic =
{
(STANDARD_RIGHTS_READ | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_QUERY_LOCK_STATUS),
(STANDARD_RIGHTS_WRITE | SC_MANAGER_CREATE_SERVICE | SC_MANAGER_MODIFY_BOOT_CONFIG),
(STANDARD_RIGHTS_EXECUTE | SC_MANAGER_CONNECT | SC_MANAGER_LOCK),
SC_MANAGER_ALL_ACCESS
};
static const GENERIC_MAPPING g_svc_generic =
{
(STANDARD_RIGHTS_READ | SERVICE_QUERY_CONFIG | SERVICE_QUERY_STATUS | SERVICE_INTERROGATE | SERVICE_ENUMERATE_DEPENDENTS),
(STANDARD_RIGHTS_WRITE | SERVICE_CHANGE_CONFIG),
(STANDARD_RIGHTS_EXECUTE | SERVICE_START | SERVICE_STOP | SERVICE_PAUSE_CONTINUE | SERVICE_USER_DEFINED_CONTROL),
SERVICE_ALL_ACCESS
};
typedef enum
{
SC_HTYPE_DONT_CARE = 0,
SC_HTYPE_MANAGER,
SC_HTYPE_SERVICE
} SC_HANDLE_TYPE;
struct sc_handle
{
SC_HANDLE_TYPE type;
DWORD access;
};
struct sc_manager_handle /* service control manager handle */
{
struct sc_handle hdr;
struct scmdatabase *db;
};
struct sc_service_handle /* service handle */
{
struct sc_handle hdr;
struct service_entry *service_entry;
};
struct sc_lock
{
struct scmdatabase *db;
};
/* Check if the given handle is of the required type and allows the requested access. */
static DWORD validate_context_handle(SC_RPC_HANDLE handle, DWORD type, DWORD needed_access, struct sc_handle **out_hdr)
{
struct sc_handle *hdr = (struct sc_handle *)handle;
if (type != SC_HTYPE_DONT_CARE && hdr->type != type)
{
WINE_ERR("Handle is of an invalid type (%d, %d)\n", hdr->type, type);
return ERROR_INVALID_HANDLE;
}
if ((needed_access & hdr->access) != needed_access)
{
WINE_ERR("Access denied - handle created with access %x, needed %x\n", hdr->access, needed_access);
return ERROR_ACCESS_DENIED;
}
*out_hdr = hdr;
return ERROR_SUCCESS;
}
static DWORD validate_scm_handle(SC_RPC_HANDLE handle, DWORD needed_access, struct sc_manager_handle **manager)
{
struct sc_handle *hdr;
DWORD err = validate_context_handle(handle, SC_HTYPE_MANAGER, needed_access, &hdr);
if (err == ERROR_SUCCESS)
*manager = (struct sc_manager_handle *)hdr;
return err;
}
static DWORD validate_service_handle(SC_RPC_HANDLE handle, DWORD needed_access, struct sc_service_handle **service)
{
struct sc_handle *hdr;
DWORD err = validate_context_handle(handle, SC_HTYPE_SERVICE, needed_access, &hdr);
if (err == ERROR_SUCCESS)
*service = (struct sc_service_handle *)hdr;
return err;
}
DWORD svcctl_OpenSCManagerW(
MACHINE_HANDLEW MachineName, /* Note: this parameter is ignored */
LPCWSTR DatabaseName,
DWORD dwAccessMask,
SC_RPC_HANDLE *handle)
{
struct sc_manager_handle *manager;
WINE_TRACE("(%s, %s, %x)\n", wine_dbgstr_w(MachineName), wine_dbgstr_w(DatabaseName), dwAccessMask);
if (DatabaseName != NULL && DatabaseName[0])
{
if (strcmpW(DatabaseName, SERVICES_FAILED_DATABASEW) == 0)
return ERROR_DATABASE_DOES_NOT_EXIST;
if (strcmpW(DatabaseName, SERVICES_ACTIVE_DATABASEW) != 0)
return ERROR_INVALID_NAME;
}
if (!(manager = HeapAlloc(GetProcessHeap(), 0, sizeof(*manager))))
return ERROR_NOT_ENOUGH_SERVER_MEMORY;
manager->hdr.type = SC_HTYPE_MANAGER;
if (dwAccessMask & MAXIMUM_ALLOWED)
dwAccessMask |= SC_MANAGER_ALL_ACCESS;
manager->hdr.access = dwAccessMask;
RtlMapGenericMask(&manager->hdr.access, &g_scm_generic);
manager->db = active_database;
*handle = &manager->hdr;
return ERROR_SUCCESS;
}
static void SC_RPC_HANDLE_destroy(SC_RPC_HANDLE handle)
{
struct sc_handle *hdr = (struct sc_handle *)handle;
switch (hdr->type)
{
case SC_HTYPE_MANAGER:
{
struct sc_manager_handle *manager = (struct sc_manager_handle *)hdr;
HeapFree(GetProcessHeap(), 0, manager);
break;
}
case SC_HTYPE_SERVICE:
{
struct sc_service_handle *service = (struct sc_service_handle *)hdr;
release_service(service->service_entry);
HeapFree(GetProcessHeap(), 0, service);
break;
}
default:
WINE_ERR("invalid handle type %d\n", hdr->type);
RpcRaiseException(ERROR_INVALID_HANDLE);
}
}
DWORD svcctl_GetServiceDisplayNameW(
SC_RPC_HANDLE hSCManager,
LPCWSTR lpServiceName,
WCHAR *lpBuffer,
DWORD cchBufSize,
DWORD *cchLength)
{
struct sc_manager_handle *manager;
struct service_entry *entry;
DWORD err;
WINE_TRACE("(%s, %d)\n", wine_dbgstr_w(lpServiceName), cchBufSize);
if ((err = validate_scm_handle(hSCManager, 0, &manager)) != ERROR_SUCCESS)
return err;
scmdatabase_lock_shared(manager->db);
entry = scmdatabase_find_service(manager->db, lpServiceName);
if (entry != NULL)
{
LPCWSTR name;
service_lock_shared(entry);
name = get_display_name(entry);
*cchLength = strlenW(name);
if (*cchLength < cchBufSize)
{
err = ERROR_SUCCESS;
lstrcpyW(lpBuffer, name);
}
else
err = ERROR_INSUFFICIENT_BUFFER;
service_unlock(entry);
}
else
{
*cchLength = 1;
err = ERROR_SERVICE_DOES_NOT_EXIST;
}
scmdatabase_unlock(manager->db);
if (err != ERROR_SUCCESS && cchBufSize > 0)
lpBuffer[0] = 0;
return err;
}
DWORD svcctl_GetServiceKeyNameW(
SC_RPC_HANDLE hSCManager,
LPCWSTR lpServiceDisplayName,
WCHAR *lpBuffer,
DWORD cchBufSize,
DWORD *cchLength)
{
struct service_entry *entry;
struct sc_manager_handle *manager;
DWORD err;
WINE_TRACE("(%s, %d)\n", wine_dbgstr_w(lpServiceDisplayName), cchBufSize);
if ((err = validate_scm_handle(hSCManager, 0, &manager)) != ERROR_SUCCESS)
return err;
scmdatabase_lock_shared(manager->db);
entry = scmdatabase_find_service_by_displayname(manager->db, lpServiceDisplayName);
if (entry != NULL)
{
service_lock_shared(entry);
*cchLength = strlenW(entry->name);
if (*cchLength < cchBufSize)
{
err = ERROR_SUCCESS;
lstrcpyW(lpBuffer, entry->name);
}
else
err = ERROR_INSUFFICIENT_BUFFER;
service_unlock(entry);
}
else
{
*cchLength = 1;
err = ERROR_SERVICE_DOES_NOT_EXIST;
}
scmdatabase_unlock(manager->db);
if (err != ERROR_SUCCESS && cchBufSize > 0)
lpBuffer[0] = 0;
return err;
}
static DWORD create_handle_for_service(struct service_entry *entry, DWORD dwDesiredAccess, SC_RPC_HANDLE *phService)
{
struct sc_service_handle *service;
if (!(service = HeapAlloc(GetProcessHeap(), 0, sizeof(*service))))
{
release_service(entry);
return ERROR_NOT_ENOUGH_SERVER_MEMORY;
}
service->hdr.type = SC_HTYPE_SERVICE;
service->hdr.access = dwDesiredAccess;
RtlMapGenericMask(&service->hdr.access, &g_svc_generic);
service->service_entry = entry;
if (dwDesiredAccess & MAXIMUM_ALLOWED)
dwDesiredAccess |= SERVICE_ALL_ACCESS;
*phService = &service->hdr;
return ERROR_SUCCESS;
}
DWORD svcctl_OpenServiceW(
SC_RPC_HANDLE hSCManager,
LPCWSTR lpServiceName,
DWORD dwDesiredAccess,
SC_RPC_HANDLE *phService)
{
struct sc_manager_handle *manager;
struct service_entry *entry;
DWORD err;
WINE_TRACE("(%s, 0x%x)\n", wine_dbgstr_w(lpServiceName), dwDesiredAccess);
if ((err = validate_scm_handle(hSCManager, 0, &manager)) != ERROR_SUCCESS)
return err;
if (!validate_service_name(lpServiceName))
return ERROR_INVALID_NAME;
scmdatabase_lock_shared(manager->db);
entry = scmdatabase_find_service(manager->db, lpServiceName);
if (entry != NULL)
entry->ref_count++;
scmdatabase_unlock(manager->db);
if (entry == NULL)
return ERROR_SERVICE_DOES_NOT_EXIST;
return create_handle_for_service(entry, dwDesiredAccess, phService);
}
DWORD svcctl_CreateServiceW(
SC_RPC_HANDLE hSCManager,
LPCWSTR lpServiceName,
LPCWSTR lpDisplayName,
DWORD dwDesiredAccess,
DWORD dwServiceType,
DWORD dwStartType,
DWORD dwErrorControl,
LPCWSTR lpBinaryPathName,
LPCWSTR lpLoadOrderGroup,
DWORD *lpdwTagId,
const BYTE *lpDependencies,
DWORD dwDependenciesSize,
LPCWSTR lpServiceStartName,
const BYTE *lpPassword,
DWORD dwPasswordSize,
SC_RPC_HANDLE *phService)
{
struct sc_manager_handle *manager;
struct service_entry *entry;
DWORD err;
WINE_TRACE("(%s, %s, 0x%x, %s)\n", wine_dbgstr_w(lpServiceName), wine_dbgstr_w(lpDisplayName), dwDesiredAccess, wine_dbgstr_w(lpBinaryPathName));
if ((err = validate_scm_handle(hSCManager, SC_MANAGER_CREATE_SERVICE, &manager)) != ERROR_SUCCESS)
return err;
if (!validate_service_name(lpServiceName))
return ERROR_INVALID_NAME;
if (!check_multisz((LPCWSTR)lpDependencies, dwDependenciesSize) || !lpServiceName[0] || !lpBinaryPathName[0])
return ERROR_INVALID_PARAMETER;
if (lpPassword)
WINE_FIXME("Don't know how to add a password\n"); /* I always get ERROR_GEN_FAILURE */
if (lpDependencies)
WINE_FIXME("Dependencies not supported yet\n");
err = service_create(lpServiceName, &entry);
if (err != ERROR_SUCCESS)
return err;
entry->config.dwServiceType = dwServiceType;
entry->config.dwStartType = dwStartType;
entry->config.dwErrorControl = dwErrorControl;
entry->config.lpBinaryPathName = strdupW(lpBinaryPathName);
entry->config.lpLoadOrderGroup = strdupW(lpLoadOrderGroup);
entry->config.lpServiceStartName = strdupW(lpServiceStartName);
entry->config.lpDisplayName = strdupW(lpDisplayName);
if (lpdwTagId) /* TODO: in most situations a non-NULL tagid will generate a ERROR_INVALID_PARAMETER */
entry->config.dwTagId = *lpdwTagId;
else
entry->config.dwTagId = 0;
/* other fields NULL*/
if (!validate_service_config(entry))
{
WINE_ERR("Invalid data while trying to create service\n");
free_service_entry(entry);
return ERROR_INVALID_PARAMETER;
}
scmdatabase_lock_exclusive(manager->db);
if (scmdatabase_find_service(manager->db, lpServiceName))
{
scmdatabase_unlock(manager->db);
free_service_entry(entry);
return ERROR_SERVICE_EXISTS;
}
if (scmdatabase_find_service_by_displayname(manager->db, get_display_name(entry)))
{
scmdatabase_unlock(manager->db);
free_service_entry(entry);
return ERROR_DUPLICATE_SERVICE_NAME;
}
err = scmdatabase_add_service(manager->db, entry);
if (err != ERROR_SUCCESS)
{
scmdatabase_unlock(manager->db);
free_service_entry(entry);
return err;
}
scmdatabase_unlock(manager->db);
return create_handle_for_service(entry, dwDesiredAccess, phService);
}
DWORD svcctl_DeleteService(
SC_RPC_HANDLE hService)
{
struct sc_service_handle *service;
DWORD err;
if ((err = validate_service_handle(hService, DELETE, &service)) != ERROR_SUCCESS)
return err;
scmdatabase_lock_exclusive(service->service_entry->db);
service_lock_exclusive(service->service_entry);
if (!is_marked_for_delete(service->service_entry))
err = scmdatabase_remove_service(service->service_entry->db, service->service_entry);
else
err = ERROR_SERVICE_MARKED_FOR_DELETE;
service_unlock(service->service_entry);
scmdatabase_unlock(service->service_entry->db);
return err;
}
DWORD svcctl_QueryServiceConfigW(
SC_RPC_HANDLE hService,
QUERY_SERVICE_CONFIGW *config)
{
struct sc_service_handle *service;
DWORD err;
WINE_TRACE("(%p)\n", config);
if ((err = validate_service_handle(hService, SERVICE_QUERY_CONFIG, &service)) != 0)
return err;
service_lock_shared(service->service_entry);
config->dwServiceType = service->service_entry->config.dwServiceType;
config->dwStartType = service->service_entry->config.dwStartType;
config->dwErrorControl = service->service_entry->config.dwErrorControl;
config->lpBinaryPathName = strdupW(service->service_entry->config.lpBinaryPathName);
config->lpLoadOrderGroup = strdupW(service->service_entry->config.lpLoadOrderGroup);
config->dwTagId = service->service_entry->config.dwTagId;
config->lpDependencies = NULL; /* TODO */
config->lpServiceStartName = strdupW(service->service_entry->config.lpServiceStartName);
config->lpDisplayName = strdupW(service->service_entry->config.lpDisplayName);
service_unlock(service->service_entry);
return ERROR_SUCCESS;
}
DWORD svcctl_ChangeServiceConfigW(
SC_RPC_HANDLE hService,
DWORD dwServiceType,
DWORD dwStartType,
DWORD dwErrorControl,
LPCWSTR lpBinaryPathName,
LPCWSTR lpLoadOrderGroup,
DWORD *lpdwTagId,
const BYTE *lpDependencies,
DWORD dwDependenciesSize,
LPCWSTR lpServiceStartName,
const BYTE *lpPassword,
DWORD dwPasswordSize,
LPCWSTR lpDisplayName)
{
struct service_entry new_entry;
struct sc_service_handle *service;
DWORD err;
WINE_TRACE("\n");
if ((err = validate_service_handle(hService, SERVICE_CHANGE_CONFIG, &service)) != 0)
return err;
if (!check_multisz((LPCWSTR)lpDependencies, dwDependenciesSize))
return ERROR_INVALID_PARAMETER;
/* first check if the new configuration is correct */
service_lock_exclusive(service->service_entry);
if (is_marked_for_delete(service->service_entry))
{
service_unlock(service->service_entry);
return ERROR_SERVICE_MARKED_FOR_DELETE;
}
if (lpDisplayName != NULL &&
scmdatabase_find_service_by_displayname(service->service_entry->db, lpDisplayName))
{
service_unlock(service->service_entry);
return ERROR_DUPLICATE_SERVICE_NAME;
}
new_entry = *service->service_entry;
if (dwServiceType != SERVICE_NO_CHANGE)
new_entry.config.dwServiceType = dwServiceType;
if (dwStartType != SERVICE_NO_CHANGE)
new_entry.config.dwStartType = dwStartType;
if (dwErrorControl != SERVICE_NO_CHANGE)
new_entry.config.dwErrorControl = dwErrorControl;
if (lpBinaryPathName != NULL)
new_entry.config.lpBinaryPathName = (LPWSTR)lpBinaryPathName;
if (lpLoadOrderGroup != NULL)
new_entry.config.lpLoadOrderGroup = (LPWSTR)lpLoadOrderGroup;
if (lpdwTagId != NULL)
WINE_FIXME("Changing tag id not supported\n");
if (lpDependencies != NULL)
WINE_FIXME("Chainging dependencies not supported\n");
if (lpServiceStartName != NULL)
new_entry.config.lpServiceStartName = (LPWSTR)lpServiceStartName;
if (lpPassword != NULL)
WINE_FIXME("Setting password not supported\n");
if (lpDisplayName != NULL)
new_entry.config.lpDisplayName = (LPWSTR)lpDisplayName;
if (!validate_service_config(&new_entry))
{
WINE_ERR("The configuration after the change wouldn't be valid");
service_unlock(service->service_entry);
return ERROR_INVALID_PARAMETER;
}
/* configuration OK. The strings needs to be duplicated */
if (lpBinaryPathName != NULL)
{
HeapFree(GetProcessHeap(), 0, service->service_entry->config.lpBinaryPathName);
new_entry.config.lpBinaryPathName = strdupW(lpBinaryPathName);
}
if (lpLoadOrderGroup != NULL)
{
HeapFree(GetProcessHeap(), 0, service->service_entry->config.lpLoadOrderGroup);
new_entry.config.lpLoadOrderGroup = strdupW(lpLoadOrderGroup);
}
if (lpServiceStartName != NULL)
{
HeapFree(GetProcessHeap(), 0, service->service_entry->config.lpServiceStartName);
new_entry.config.lpServiceStartName = strdupW(lpServiceStartName);
}
if (lpDisplayName != NULL)
{
HeapFree(GetProcessHeap(), 0, service->service_entry->config.lpDisplayName);
new_entry.config.lpDisplayName = strdupW(lpDisplayName);
}
*service->service_entry = new_entry;
save_service_config(service->service_entry);
service_unlock(service->service_entry);
return ERROR_SUCCESS;
}
DWORD svcctl_SetServiceStatus(
SC_RPC_HANDLE hServiceStatus,
LPSERVICE_STATUS lpServiceStatus)
{
struct sc_service_handle *service;
DWORD err;
WINE_TRACE("(%p, %p)\n", hServiceStatus, lpServiceStatus);
if ((err = validate_service_handle(hServiceStatus, SERVICE_SET_STATUS, &service)) != 0)
return err;
service_lock_exclusive(service->service_entry);
/* FIXME: be a bit more discriminant about what parts of the status we set
* and check that fields are valid */
service->service_entry->status.dwServiceType = lpServiceStatus->dwServiceType;
service->service_entry->status.dwCurrentState = lpServiceStatus->dwCurrentState;
service->service_entry->status.dwControlsAccepted = lpServiceStatus->dwControlsAccepted;
service->service_entry->status.dwWin32ExitCode = lpServiceStatus->dwWin32ExitCode;
service->service_entry->status.dwServiceSpecificExitCode = lpServiceStatus->dwServiceSpecificExitCode;
service->service_entry->status.dwCheckPoint = lpServiceStatus->dwCheckPoint;
service->service_entry->status.dwWaitHint = lpServiceStatus->dwWaitHint;
service_unlock(service->service_entry);
if (service->service_entry->status_changed_event)
SetEvent(service->service_entry->status_changed_event);
return ERROR_SUCCESS;
}
DWORD svcctl_QueryServiceStatusEx(
SC_RPC_HANDLE hService,
SC_STATUS_TYPE InfoLevel,
BYTE *lpBuffer,
DWORD cbBufSize,
LPDWORD pcbBytesNeeded)
{
struct sc_service_handle *service;
DWORD err;
LPSERVICE_STATUS_PROCESS pSvcStatusData;
if ((err = validate_service_handle(hService, SERVICE_QUERY_STATUS, &service)) != 0)
return err;
if (InfoLevel != SC_STATUS_PROCESS_INFO)
return ERROR_INVALID_LEVEL;
pSvcStatusData = (LPSERVICE_STATUS_PROCESS) lpBuffer;
if (pSvcStatusData == NULL)
return ERROR_INVALID_PARAMETER;
if (cbBufSize < sizeof(SERVICE_STATUS_PROCESS))
{
if( pcbBytesNeeded != NULL)
*pcbBytesNeeded = sizeof(SERVICE_STATUS_PROCESS);
return ERROR_INSUFFICIENT_BUFFER;
}
service_lock_shared(service->service_entry);
pSvcStatusData->dwServiceType = service->service_entry->status.dwServiceType;
pSvcStatusData->dwCurrentState = service->service_entry->status.dwCurrentState;
pSvcStatusData->dwControlsAccepted = service->service_entry->status.dwControlsAccepted;
pSvcStatusData->dwWin32ExitCode = service->service_entry->status.dwWin32ExitCode;
pSvcStatusData->dwServiceSpecificExitCode = service->service_entry->status.dwServiceSpecificExitCode;
pSvcStatusData->dwCheckPoint = service->service_entry->status.dwCheckPoint;
pSvcStatusData->dwWaitHint = service->service_entry->status.dwWaitHint;
pSvcStatusData->dwProcessId = service->service_entry->status.dwProcessId;
pSvcStatusData->dwServiceFlags = service->service_entry->status.dwServiceFlags;
service_unlock(service->service_entry);
return ERROR_SUCCESS;
}
/* only one service started at a time, so there is no race on the registry
* value here */
static LPWSTR service_get_pipe_name(void)
{
static const WCHAR format[] = { '\\','\\','.','\\','p','i','p','e','\\',
'n','e','t','\\','N','t','C','o','n','t','r','o','l','P','i','p','e','%','u',0};
static const WCHAR service_current_key_str[] = { 'S','Y','S','T','E','M','\\',
'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
'C','o','n','t','r','o','l','\\',
'S','e','r','v','i','c','e','C','u','r','r','e','n','t',0};
LPWSTR name;
DWORD len;
HKEY service_current_key;
DWORD service_current = -1;
LONG ret;
DWORD type;
ret = RegCreateKeyExW(HKEY_LOCAL_MACHINE, service_current_key_str, 0,
NULL, REG_OPTION_VOLATILE, KEY_SET_VALUE | KEY_QUERY_VALUE, NULL,
&service_current_key, NULL);
if (ret != ERROR_SUCCESS)
return NULL;
len = sizeof(service_current);
ret = RegQueryValueExW(service_current_key, NULL, NULL, &type,
(BYTE *)&service_current, &len);
if ((ret == ERROR_SUCCESS && type == REG_DWORD) || ret == ERROR_FILE_NOT_FOUND)
{
service_current++;
RegSetValueExW(service_current_key, NULL, 0, REG_DWORD,
(BYTE *)&service_current, sizeof(service_current));
}
RegCloseKey(service_current_key);
if ((ret != ERROR_SUCCESS || type != REG_DWORD) && (ret != ERROR_FILE_NOT_FOUND))
return NULL;
len = sizeof(format)/sizeof(WCHAR) + 10 /* strlenW("4294967295") */;
name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
if (!name)
return NULL;
snprintfW(name, len, format, service_current);
return name;
}
static DWORD service_start_process(struct service_entry *service_entry, HANDLE *process)
{
PROCESS_INFORMATION pi;
STARTUPINFOW si;
LPWSTR path = NULL;
DWORD size;
BOOL r;
service_lock_exclusive(service_entry);
if (service_entry->config.dwServiceType == SERVICE_KERNEL_DRIVER)
{
static const WCHAR winedeviceW[] = {'\\','w','i','n','e','d','e','v','i','c','e','.','e','x','e',' ',0};
DWORD len = GetSystemDirectoryW( NULL, 0 ) + sizeof(winedeviceW)/sizeof(WCHAR) + strlenW(service_entry->name);
if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
return ERROR_NOT_ENOUGH_SERVER_MEMORY;
GetSystemDirectoryW( path, len );
lstrcatW( path, winedeviceW );
lstrcatW( path, service_entry->name );
}
else
{
size = ExpandEnvironmentStringsW(service_entry->config.lpBinaryPathName,NULL,0);
path = HeapAlloc(GetProcessHeap(),0,size*sizeof(WCHAR));
if (!path)
return ERROR_NOT_ENOUGH_SERVER_MEMORY;
ExpandEnvironmentStringsW(service_entry->config.lpBinaryPathName,path,size);
}
ZeroMemory(&si, sizeof(STARTUPINFOW));
si.cb = sizeof(STARTUPINFOW);
if (!(service_entry->config.dwServiceType & SERVICE_INTERACTIVE_PROCESS))
{
static WCHAR desktopW[] = {'_','_','w','i','n','e','s','e','r','v','i','c','e','_','w','i','n','s','t','a','t','i','o','n','\\','D','e','f','a','u','l','t',0};
si.lpDesktop = desktopW;
}
service_entry->status.dwCurrentState = SERVICE_START_PENDING;
service_entry->status.dwProcessId = pi.dwProcessId;
service_unlock(service_entry);
r = CreateProcessW(NULL, path, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
HeapFree(GetProcessHeap(),0,path);
if (!r)
{
service_lock_exclusive(service_entry);
service_entry->status.dwCurrentState = SERVICE_STOPPED;
service_entry->status.dwProcessId = 0;
service_unlock(service_entry);
return GetLastError();
}
*process = pi.hProcess;
CloseHandle( pi.hThread );
return ERROR_SUCCESS;
}
static DWORD service_wait_for_startup(struct service_entry *service_entry, HANDLE process_handle)
{
WINE_TRACE("%p\n", service_entry);
for (;;)
{
DWORD dwCurrentStatus;
HANDLE handles[2] = { service_entry->status_changed_event, process_handle };
DWORD ret;
ret = WaitForMultipleObjects(sizeof(handles)/sizeof(handles[0]), handles, FALSE, 20000);
if (ret != WAIT_OBJECT_0)
return ERROR_SERVICE_REQUEST_TIMEOUT;
service_lock_shared(service_entry);
dwCurrentStatus = service_entry->status.dwCurrentState;
service_unlock(service_entry);
if (dwCurrentStatus == SERVICE_RUNNING)
{
WINE_TRACE("Service started successfully\n");
return ERROR_SUCCESS;
}
if (dwCurrentStatus != SERVICE_START_PENDING)
return ERROR_SERVICE_REQUEST_TIMEOUT;
}
}
/******************************************************************************
* service_send_start_message
*/
static BOOL service_send_start_message(HANDLE pipe, LPCWSTR *argv, DWORD argc)
{
DWORD i, len, count, result;
service_start_info *ssi;
LPWSTR p;
BOOL r;
WINE_TRACE("%p %p %d\n", pipe, argv, argc);
/* FIXME: this can block so should be done in another thread */
r = ConnectNamedPipe(pipe, NULL);
if (!r && GetLastError() != ERROR_PIPE_CONNECTED)
{
WINE_ERR("pipe connect failed\n");
return FALSE;
}
/* calculate how much space do we need to send the startup info */
len = 1;
for (i=0; i<argc; i++)
len += strlenW(argv[i])+1;
ssi = HeapAlloc(GetProcessHeap(),0,FIELD_OFFSET(service_start_info, str[len]));
ssi->cmd = WINESERV_STARTINFO;
ssi->size = len;
/* copy service args into a single buffer*/
p = &ssi->str[0];
for (i=0; i<argc; i++)
{
strcpyW(p, argv[i]);
p += strlenW(p) + 1;
}
*p=0;
r = WriteFile(pipe, ssi, FIELD_OFFSET(service_start_info, str[len]), &count, NULL);
if (r)
{
r = ReadFile(pipe, &result, sizeof result, &count, NULL);
if (r && result)
{
SetLastError(result);
r = FALSE;
}
}
HeapFree(GetProcessHeap(),0,ssi);
return r;
}
/******************************************************************************
* service_accepts_control
*/
static BOOL service_accepts_control(const struct service_entry *service, DWORD dwControl)
{
DWORD a = service->status.dwControlsAccepted;
switch (dwControl)
{
case SERVICE_CONTROL_INTERROGATE:
return TRUE;
case SERVICE_CONTROL_STOP:
if (a&SERVICE_ACCEPT_STOP)
return TRUE;
break;
case SERVICE_CONTROL_SHUTDOWN:
if (a&SERVICE_ACCEPT_SHUTDOWN)
return TRUE;
break;
case SERVICE_CONTROL_PAUSE:
case SERVICE_CONTROL_CONTINUE:
if (a&SERVICE_ACCEPT_PAUSE_CONTINUE)
return TRUE;
break;
case SERVICE_CONTROL_PARAMCHANGE:
if (a&SERVICE_ACCEPT_PARAMCHANGE)
return TRUE;
break;
case SERVICE_CONTROL_NETBINDADD:
case SERVICE_CONTROL_NETBINDREMOVE:
case SERVICE_CONTROL_NETBINDENABLE:
case SERVICE_CONTROL_NETBINDDISABLE:
if (a&SERVICE_ACCEPT_NETBINDCHANGE)
return TRUE;
case SERVICE_CONTROL_HARDWAREPROFILECHANGE:
if (a&SERVICE_ACCEPT_HARDWAREPROFILECHANGE)
return TRUE;
break;
case SERVICE_CONTROL_POWEREVENT:
if (a&SERVICE_ACCEPT_POWEREVENT)
return TRUE;
break;
case SERVICE_CONTROL_SESSIONCHANGE:
if (a&SERVICE_ACCEPT_SESSIONCHANGE)
return TRUE;
break;
}
return FALSE;
}
/******************************************************************************
* service_send_control
*/
static BOOL service_send_control(HANDLE pipe, DWORD dwControl, DWORD *result)
{
DWORD cmd[2], count = 0;
BOOL r;
cmd[0] = WINESERV_SENDCONTROL;
cmd[1] = dwControl;
r = WriteFile(pipe, cmd, sizeof cmd, &count, NULL);
if (!r || count != sizeof cmd)
{
WINE_ERR("service protocol error - failed to write pipe!\n");
return r;
}
r = ReadFile(pipe, result, sizeof *result, &count, NULL);
if (!r || count != sizeof *result)
WINE_ERR("service protocol error - failed to read pipe "
"r = %d count = %d!\n", r, count);
return r;
}
DWORD svcctl_StartServiceW(
SC_RPC_HANDLE hService,
DWORD dwNumServiceArgs,
LPCWSTR *lpServiceArgVectors)
{
struct sc_service_handle *service;
DWORD err;
LPWSTR name;
HANDLE process_handle = NULL;
WINE_TRACE("(%p, %d, %p)\n", hService, dwNumServiceArgs, lpServiceArgVectors);
if ((err = validate_service_handle(hService, SERVICE_START, &service)) != 0)
return err;
err = scmdatabase_lock_startup(service->service_entry->db);
if (err != ERROR_SUCCESS)
return err;
if (service->service_entry->control_pipe != INVALID_HANDLE_VALUE)
{
scmdatabase_unlock_startup(service->service_entry->db);
return ERROR_SERVICE_ALREADY_RUNNING;
}
service->service_entry->control_mutex = CreateMutexW(NULL, TRUE, NULL);
if (!service->service_entry->status_changed_event)
service->service_entry->status_changed_event = CreateEventW(NULL, TRUE, FALSE, NULL);
name = service_get_pipe_name();
service->service_entry->control_pipe = CreateNamedPipeW(name, PIPE_ACCESS_DUPLEX,
PIPE_TYPE_BYTE|PIPE_WAIT, 1, 256, 256, 10000, NULL );
HeapFree(GetProcessHeap(), 0, name);
if (service->service_entry->control_pipe==INVALID_HANDLE_VALUE)
{
WINE_ERR("failed to create pipe for %s, error = %d\n",
wine_dbgstr_w(service->service_entry->name), GetLastError());
scmdatabase_unlock_startup(service->service_entry->db);
return GetLastError();
}
err = service_start_process(service->service_entry, &process_handle);
if (err == ERROR_SUCCESS)
{
if (!service_send_start_message(service->service_entry->control_pipe,
lpServiceArgVectors, dwNumServiceArgs))
err = ERROR_SERVICE_REQUEST_TIMEOUT;
}
WINE_TRACE("returning %d\n", err);
if (err == ERROR_SUCCESS)
err = service_wait_for_startup(service->service_entry, process_handle);
if (process_handle)
CloseHandle(process_handle);
ReleaseMutex(service->service_entry->control_mutex);
scmdatabase_unlock_startup(service->service_entry->db);
return err;
}
DWORD svcctl_ControlService(
SC_RPC_HANDLE hService,
DWORD dwControl,
SERVICE_STATUS *lpServiceStatus)
{
DWORD access_required;
struct sc_service_handle *service;
DWORD err;
BOOL ret;
HANDLE control_mutex;
HANDLE control_pipe;
WINE_TRACE("(%p, %d, %p)\n", hService, dwControl, lpServiceStatus);
switch (dwControl)
{
case SERVICE_CONTROL_CONTINUE:
case SERVICE_CONTROL_NETBINDADD:
case SERVICE_CONTROL_NETBINDDISABLE:
case SERVICE_CONTROL_NETBINDENABLE:
case SERVICE_CONTROL_NETBINDREMOVE:
case SERVICE_CONTROL_PARAMCHANGE:
case SERVICE_CONTROL_PAUSE:
access_required = SERVICE_PAUSE_CONTINUE;
break;
case SERVICE_CONTROL_INTERROGATE:
access_required = SERVICE_INTERROGATE;
break;
case SERVICE_CONTROL_STOP:
access_required = SERVICE_STOP;
break;
default:
if (dwControl >= 128 && dwControl <= 255)
access_required = SERVICE_USER_DEFINED_CONTROL;
else
return ERROR_INVALID_PARAMETER;
}
if ((err = validate_service_handle(hService, access_required, &service)) != 0)
return err;
service_lock_exclusive(service->service_entry);
if (lpServiceStatus)
{
lpServiceStatus->dwServiceType = service->service_entry->status.dwServiceType;
lpServiceStatus->dwCurrentState = service->service_entry->status.dwCurrentState;
lpServiceStatus->dwControlsAccepted = service->service_entry->status.dwControlsAccepted;
lpServiceStatus->dwWin32ExitCode = service->service_entry->status.dwWin32ExitCode;
lpServiceStatus->dwServiceSpecificExitCode = service->service_entry->status.dwServiceSpecificExitCode;
lpServiceStatus->dwCheckPoint = service->service_entry->status.dwCheckPoint;
lpServiceStatus->dwWaitHint = service->service_entry->status.dwWaitHint;
}
if (!service_accepts_control(service->service_entry, dwControl))
{
service_unlock(service->service_entry);
return ERROR_INVALID_SERVICE_CONTROL;
}
switch (service->service_entry->status.dwCurrentState)
{
case SERVICE_STOPPED:
service_unlock(service->service_entry);
return ERROR_SERVICE_NOT_ACTIVE;
case SERVICE_START_PENDING:
if (dwControl==SERVICE_CONTROL_STOP)
break;
/* fall thru */
case SERVICE_STOP_PENDING:
service_unlock(service->service_entry);
return ERROR_SERVICE_CANNOT_ACCEPT_CTRL;
}
/* prevent races by caching these variables and clearing them on
* stop here instead of outside the services lock */
control_mutex = service->service_entry->control_mutex;
control_pipe = service->service_entry->control_pipe;
if (dwControl == SERVICE_CONTROL_STOP)
{
service->service_entry->control_mutex = NULL;
service->service_entry->control_pipe = NULL;
}
service_unlock(service->service_entry);
ret = WaitForSingleObject(control_mutex, 30000);
if (ret)
{
DWORD result = ERROR_SUCCESS;
ret = service_send_control(control_pipe, dwControl, &result);
if (dwControl == SERVICE_CONTROL_STOP)
{
CloseHandle(control_mutex);
CloseHandle(control_pipe);
}
else
ReleaseMutex(control_mutex);
return result;
}
else
{
if (dwControl == SERVICE_CONTROL_STOP)
{
CloseHandle(control_mutex);
CloseHandle(control_pipe);
}
return ERROR_SERVICE_REQUEST_TIMEOUT;
}
}
DWORD svcctl_CloseServiceHandle(
SC_RPC_HANDLE *handle)
{
WINE_TRACE("(&%p)\n", *handle);
SC_RPC_HANDLE_destroy(*handle);
*handle = NULL;
return ERROR_SUCCESS;
}
static void SC_RPC_LOCK_destroy(SC_RPC_LOCK hLock)
{
struct sc_lock *lock = hLock;
scmdatabase_unlock_startup(lock->db);
HeapFree(GetProcessHeap(), 0, lock);
}
void __RPC_USER SC_RPC_LOCK_rundown(SC_RPC_LOCK hLock)
{
SC_RPC_LOCK_destroy(hLock);
}
DWORD svcctl_LockServiceDatabase(
SC_RPC_HANDLE hSCManager,
SC_RPC_LOCK *phLock)
{
struct sc_manager_handle *manager;
DWORD err;
WINE_TRACE("(%p, %p)\n", hSCManager, phLock);
if ((err = validate_scm_handle(hSCManager, SC_MANAGER_LOCK, &manager)) != ERROR_SUCCESS)
return err;
err = scmdatabase_lock_startup(manager->db);
if (err != ERROR_SUCCESS)
return err;
*phLock = HeapAlloc(GetProcessHeap(), 0, sizeof(struct sc_lock));
if (!*phLock)
{
scmdatabase_unlock_startup(manager->db);
return ERROR_NOT_ENOUGH_SERVER_MEMORY;
}
return ERROR_SUCCESS;
}
DWORD svcctl_UnlockServiceDatabase(
SC_RPC_LOCK *phLock)
{
WINE_TRACE("(&%p)\n", *phLock);
SC_RPC_LOCK_destroy(*phLock);
*phLock = NULL;
return ERROR_SUCCESS;
}
DWORD svcctl_QueryServiceObjectSecurity(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_SetServiceObjectSecurity(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_QueryServiceStatus(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_NotifyBootConfigStatus(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_SCSetServiceBitsW(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_EnumDependentServicesW(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_EnumServicesStatusW(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_QueryServiceLockStatusW(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_SCSetServiceBitsA(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_ChangeServiceConfigA(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_CreateServiceA(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_EnumDependentServicesA(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_EnumServicesStatusA(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_OpenSCManagerA(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_OpenServiceA(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_QueryServiceConfigA(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_QueryServiceLockStatusA(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_StartServiceA(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_GetServiceDisplayNameA(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_GetServiceKeyNameA(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_GetCurrentGroupStateW(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_EnumServiceGroupW(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_ChangeServiceConfig2A(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_ChangeServiceConfig2W(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_QueryServiceConfig2A(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD svcctl_QueryServiceConfig2W(
void)
{
WINE_FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
DWORD RPC_MainLoop(void)
{
WCHAR transport[] = SVCCTL_TRANSPORT;
WCHAR endpoint[] = SVCCTL_ENDPOINT;
HANDLE hSleepHandle;
DWORD err;
if ((err = RpcServerUseProtseqEpW(transport, 0, endpoint, NULL)) != ERROR_SUCCESS)
{
WINE_ERR("RpcServerUseProtseq failed with error %u\n", err);
return err;
}
if ((err = RpcServerRegisterIf(svcctl_v2_0_s_ifspec, 0, 0)) != ERROR_SUCCESS)
{
WINE_ERR("RpcServerRegisterIf failed with error %u", err);
return err;
}
if ((err = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, TRUE)) != ERROR_SUCCESS)
{
WINE_ERR("RpcServerListen failed with error %u\n", err);
return err;
}
WINE_TRACE("Entered main loop\n");
hSleepHandle = __wine_make_process_system();
SetEvent(g_hStartedEvent);
do
{
err = WaitForSingleObjectEx(hSleepHandle, INFINITE, TRUE);
WINE_TRACE("Wait returned %d\n", err);
} while (err != WAIT_OBJECT_0);
WINE_TRACE("Object signaled - wine shutdown\n");
return ERROR_SUCCESS;
}
void __RPC_USER SC_RPC_HANDLE_rundown(SC_RPC_HANDLE handle)
{
SC_RPC_HANDLE_destroy(handle);
}
void __RPC_FAR * __RPC_USER MIDL_user_allocate(size_t len)
{
return HeapAlloc(GetProcessHeap(), 0, len);
}
void __RPC_USER MIDL_user_free(void __RPC_FAR * ptr)
{
HeapFree(GetProcessHeap(), 0, ptr);
}
Reference in New Issue View Git Blame Copy Permalink