programs/services/rpc.c

   1 /*
   2  * Services.exe - RPC functions
   3  *
   4  * Copyright 2007 Google (Mikolaj Zalewski)
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define WIN32_LEAN_AND_MEAN
  22 #define NONAMELESSUNION
  23
  24 #include <stdarg.h>
  25 #include <windows.h>
  26 #include <winternl.h>
  27 #include <winsvc.h>
  28 #include <ntsecapi.h>
  29 #include <rpc.h>
  30
  31 #include "wine/list.h"
  32 #include "wine/unicode.h"
  33 #include "wine/debug.h"
  34
  35 #include "services.h"
  36 #include "svcctl.h"
  37
  38 extern HANDLE CDECL __wine_make_process_system(void);
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(service);
  41
  42 static const GENERIC_MAPPING g_scm_generic =
  43 {
  44     (STANDARD_RIGHTS_READ | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_QUERY_LOCK_STATUS),
  45     (STANDARD_RIGHTS_WRITE | SC_MANAGER_CREATE_SERVICE | SC_MANAGER_MODIFY_BOOT_CONFIG),
  46     (STANDARD_RIGHTS_EXECUTE | SC_MANAGER_CONNECT | SC_MANAGER_LOCK),
  47     SC_MANAGER_ALL_ACCESS
  48 };
  49
  50 static const GENERIC_MAPPING g_svc_generic =
  51 {
  52     (STANDARD_RIGHTS_READ | SERVICE_QUERY_CONFIG | SERVICE_QUERY_STATUS | SERVICE_INTERROGATE | SERVICE_ENUMERATE_DEPENDENTS),
  53     (STANDARD_RIGHTS_WRITE | SERVICE_CHANGE_CONFIG),
  54     (STANDARD_RIGHTS_EXECUTE | SERVICE_START | SERVICE_STOP | SERVICE_PAUSE_CONTINUE | SERVICE_USER_DEFINED_CONTROL),
  55     SERVICE_ALL_ACCESS
  56 };
  57
  58 typedef enum
  59 {
  60     SC_HTYPE_DONT_CARE = 0,
  61     SC_HTYPE_MANAGER,
  62     SC_HTYPE_SERVICE
  63 } SC_HANDLE_TYPE;
  64
  65 struct sc_handle
  66 {
  67     SC_HANDLE_TYPE type;
  68     DWORD access;
  69 };
  70
  71 struct sc_manager_handle       /* service control manager handle */
  72 {
  73     struct sc_handle hdr;
  74     struct scmdatabase *db;
  75 };
  76
  77 struct sc_service_handle       /* service handle */
  78 {
  79     struct sc_handle hdr;
  80     struct service_entry *service_entry;
  81 };
  82
  83 struct sc_lock
  84 {
  85     struct scmdatabase *db;
  86 };
  87
  88 static const WCHAR emptyW[] = {0};
  89 static PTP_CLEANUP_GROUP cleanup_group;
  90 HANDLE exit_event;
  91
  92 static void CALLBACK group_cancel_callback(void *object, void *userdata)
  93 {
  94     struct process_entry *process = object;
  95     release_process(process);
  96 }
  97
  98 static void CALLBACK terminate_callback(TP_CALLBACK_INSTANCE *instance, void *context,
  99                                         TP_WAIT *wait, TP_WAIT_RESULT result)
 100 {
 101     struct process_entry *process = context;
 102     if (result == WAIT_TIMEOUT) process_terminate(process);
 103     release_process(process);
 104     CloseThreadpoolWait(wait);
 105 }
 106
 107 static void terminate_after_timeout(struct process_entry *process, DWORD timeout)
 108 {
 109     TP_CALLBACK_ENVIRON environment;
 110     LARGE_INTEGER timestamp;
 111     TP_WAIT *wait;
 112     FILETIME ft;
 113
 114     memset(&environment, 0, sizeof(environment));
 115     environment.Version = 1;
 116     environment.CleanupGroup = cleanup_group;
 117     environment.CleanupGroupCancelCallback = group_cancel_callback;
 118
 119     timestamp.QuadPart = (ULONGLONG)timeout * -10000;
 120     ft.dwLowDateTime   = timestamp.u.LowPart;
 121     ft.dwHighDateTime  = timestamp.u.HighPart;
 122
 123     if ((wait = CreateThreadpoolWait(terminate_callback, grab_process(process), &environment)))
 124         SetThreadpoolWait(wait, process->process, &ft);
 125     else
 126         release_process(process);
 127 }
 128
 129 static void CALLBACK shutdown_callback(TP_CALLBACK_INSTANCE *instance, void *context)
 130 {
 131     struct process_entry *process = context;
 132     DWORD result;
 133
 134     result = WaitForSingleObject(process->control_mutex, 30000);
 135     if (result == WAIT_OBJECT_0)
 136     {
 137         process_send_control(process, FALSE, emptyW, SERVICE_CONTROL_STOP, NULL, 0, &result);
 138         ReleaseMutex(process->control_mutex);
 139     }
 140
 141     release_process(process);
 142 }
 143
 144 static void shutdown_shared_process(struct process_entry *process)
 145 {
 146     TP_CALLBACK_ENVIRON environment;
 147     struct service_entry *service;
 148     struct scmdatabase *db = process->db;
 149
 150     scmdatabase_lock(db);
 151     LIST_FOR_EACH_ENTRY(service, &db->services, struct service_entry, entry)
 152     {
 153         if (service->process != process) continue;
 154         service->status.dwCurrentState = SERVICE_STOP_PENDING;
 155     }
 156     scmdatabase_unlock(db);
 157
 158     memset(&environment, 0, sizeof(environment));
 159     environment.Version = 1;
 160     environment.CleanupGroup = cleanup_group;
 161     environment.CleanupGroupCancelCallback = group_cancel_callback;
 162
 163     if (!TrySubmitThreadpoolCallback(shutdown_callback, grab_process(process), &environment))
 164         release_process(process);
 165 }
 166
 167 static void free_service_strings(struct service_entry *old, struct service_entry *new)
 168 {
 169     QUERY_SERVICE_CONFIGW *old_cfg = &old->config;
 170     QUERY_SERVICE_CONFIGW *new_cfg = &new->config;
 171
 172     if (old_cfg->lpBinaryPathName != new_cfg->lpBinaryPathName)
 173         HeapFree(GetProcessHeap(), 0, old_cfg->lpBinaryPathName);
 174
 175     if (old_cfg->lpLoadOrderGroup != new_cfg->lpLoadOrderGroup)
 176         HeapFree(GetProcessHeap(), 0, old_cfg->lpLoadOrderGroup);
 177
 178     if (old_cfg->lpServiceStartName != new_cfg->lpServiceStartName)
 179         HeapFree(GetProcessHeap(), 0, old_cfg->lpServiceStartName);
 180
 181     if (old_cfg->lpDisplayName != new_cfg->lpDisplayName)
 182         HeapFree(GetProcessHeap(), 0, old_cfg->lpDisplayName);
 183
 184     if (old->dependOnServices != new->dependOnServices)
 185         HeapFree(GetProcessHeap(), 0, old->dependOnServices);
 186
 187     if (old->dependOnGroups != new->dependOnGroups)
 188         HeapFree(GetProcessHeap(), 0, old->dependOnGroups);
 189 }
 190
 191 /* Check if the given handle is of the required type and allows the requested access. */
 192 static DWORD validate_context_handle(SC_RPC_HANDLE handle, DWORD type, DWORD needed_access, struct sc_handle **out_hdr)
 193 {
 194     struct sc_handle *hdr = handle;
 195
 196     if (type != SC_HTYPE_DONT_CARE && hdr->type != type)
 197     {
 198         WINE_ERR("Handle is of an invalid type (%d, %d)\n", hdr->type, type);
 199         return ERROR_INVALID_HANDLE;
 200     }
 201
 202     if ((needed_access & hdr->access) != needed_access)
 203     {
 204         WINE_ERR("Access denied - handle created with access %x, needed %x\n", hdr->access, needed_access);
 205         return ERROR_ACCESS_DENIED;
 206     }
 207
 208     *out_hdr = hdr;
 209     return ERROR_SUCCESS;
 210 }
 211
 212 static DWORD validate_scm_handle(SC_RPC_HANDLE handle, DWORD needed_access, struct sc_manager_handle **manager)
 213 {
 214     struct sc_handle *hdr;
 215     DWORD err = validate_context_handle(handle, SC_HTYPE_MANAGER, needed_access, &hdr);
 216     if (err == ERROR_SUCCESS)
 217         *manager = (struct sc_manager_handle *)hdr;
 218     return err;
 219 }
 220
 221 static DWORD validate_service_handle(SC_RPC_HANDLE handle, DWORD needed_access, struct sc_service_handle **service)
 222 {
 223     struct sc_handle *hdr;
 224     DWORD err = validate_context_handle(handle, SC_HTYPE_SERVICE, needed_access, &hdr);
 225     if (err == ERROR_SUCCESS)
 226         *service = (struct sc_service_handle *)hdr;
 227     return err;
 228 }
 229
 230 DWORD __cdecl svcctl_OpenSCManagerW(
 231     MACHINE_HANDLEW MachineName, /* Note: this parameter is ignored */
 232     LPCWSTR DatabaseName,
 233     DWORD dwAccessMask,
 234     SC_RPC_HANDLE *handle)
 235 {
 236     struct sc_manager_handle *manager;
 237
 238     WINE_TRACE("(%s, %s, %x)\n", wine_dbgstr_w(MachineName), wine_dbgstr_w(DatabaseName), dwAccessMask);
 239
 240     if (DatabaseName != NULL && DatabaseName[0])
 241     {
 242         if (strcmpW(DatabaseName, SERVICES_FAILED_DATABASEW) == 0)
 243             return ERROR_DATABASE_DOES_NOT_EXIST;
 244         if (strcmpW(DatabaseName, SERVICES_ACTIVE_DATABASEW) != 0)
 245             return ERROR_INVALID_NAME;
 246     }
 247
 248     if (!(manager = HeapAlloc(GetProcessHeap(), 0, sizeof(*manager))))
 249         return ERROR_NOT_ENOUGH_SERVER_MEMORY;
 250
 251     manager->hdr.type = SC_HTYPE_MANAGER;
 252
 253     if (dwAccessMask & MAXIMUM_ALLOWED)
 254         dwAccessMask |= SC_MANAGER_ALL_ACCESS;
 255     manager->hdr.access = dwAccessMask;
 256     RtlMapGenericMask(&manager->hdr.access, &g_scm_generic);
 257     manager->db = active_database;
 258     *handle = &manager->hdr;
 259
 260     return ERROR_SUCCESS;
 261 }
 262
 263 static void SC_RPC_HANDLE_destroy(SC_RPC_HANDLE handle)
 264 {
 265     struct sc_handle *hdr = handle;
 266     switch (hdr->type)
 267     {
 268         case SC_HTYPE_MANAGER:
 269         {
 270             struct sc_manager_handle *manager = (struct sc_manager_handle *)hdr;
 271             HeapFree(GetProcessHeap(), 0, manager);
 272             break;
 273         }
 274         case SC_HTYPE_SERVICE:
 275         {
 276             struct sc_service_handle *service = (struct sc_service_handle *)hdr;
 277             release_service(service->service_entry);
 278             HeapFree(GetProcessHeap(), 0, service);
 279             break;
 280         }
 281         default:
 282             WINE_ERR("invalid handle type %d\n", hdr->type);
 283             RpcRaiseException(ERROR_INVALID_HANDLE);
 284     }
 285 }
 286
 287 DWORD __cdecl svcctl_GetServiceDisplayNameW(
 288     SC_RPC_HANDLE hSCManager,
 289     LPCWSTR lpServiceName,
 290     WCHAR *lpBuffer,
 291     DWORD *cchBufSize)
 292 {
 293     struct sc_manager_handle *manager;
 294     struct service_entry *entry;
 295     DWORD err;
 296
 297     WINE_TRACE("(%s, %d)\n", wine_dbgstr_w(lpServiceName), *cchBufSize);
 298
 299     if ((err = validate_scm_handle(hSCManager, 0, &manager)) != ERROR_SUCCESS)
 300         return err;
 301
 302     scmdatabase_lock(manager->db);
 303
 304     entry = scmdatabase_find_service(manager->db, lpServiceName);
 305     if (entry != NULL)
 306     {
 307         LPCWSTR name;
 308         int len;
 309         name = get_display_name(entry);
 310         len = strlenW(name);
 311         if (len <= *cchBufSize)
 312         {
 313             err = ERROR_SUCCESS;
 314             memcpy(lpBuffer, name, (len + 1)*sizeof(*name));
 315         }
 316         else
 317             err = ERROR_INSUFFICIENT_BUFFER;
 318         *cchBufSize = len;
 319     }
 320     else
 321         err = ERROR_SERVICE_DOES_NOT_EXIST;
 322
 323     scmdatabase_unlock(manager->db);
 324
 325     if (err != ERROR_SUCCESS)
 326         lpBuffer[0] = 0;
 327
 328     return err;
 329 }
 330
 331 DWORD __cdecl svcctl_GetServiceKeyNameW(
 332     SC_RPC_HANDLE hSCManager,
 333     LPCWSTR lpServiceDisplayName,
 334     WCHAR *lpBuffer,
 335     DWORD *cchBufSize)
 336 {
 337     struct service_entry *entry;
 338     struct sc_manager_handle *manager;
 339     DWORD err;
 340
 341     WINE_TRACE("(%s, %d)\n", wine_dbgstr_w(lpServiceDisplayName), *cchBufSize);
 342
 343     if ((err = validate_scm_handle(hSCManager, 0, &manager)) != ERROR_SUCCESS)
 344         return err;
 345
 346     scmdatabase_lock(manager->db);
 347
 348     entry = scmdatabase_find_service_by_displayname(manager->db, lpServiceDisplayName);
 349     if (entry != NULL)
 350     {
 351         int len;
 352         len = strlenW(entry->name);
 353         if (len <= *cchBufSize)
 354         {
 355             err = ERROR_SUCCESS;
 356             memcpy(lpBuffer, entry->name, (len + 1)*sizeof(*entry->name));
 357         }
 358         else
 359             err = ERROR_INSUFFICIENT_BUFFER;
 360         *cchBufSize = len;
 361     }
 362     else
 363         err = ERROR_SERVICE_DOES_NOT_EXIST;
 364
 365     scmdatabase_unlock(manager->db);
 366
 367     if (err != ERROR_SUCCESS)
 368         lpBuffer[0] = 0;
 369
 370     return err;
 371 }
 372
 373 static DWORD create_handle_for_service(struct service_entry *entry, DWORD dwDesiredAccess, SC_RPC_HANDLE *phService)
 374 {
 375     struct sc_service_handle *service;
 376
 377     if (!(service = HeapAlloc(GetProcessHeap(), 0, sizeof(*service))))
 378     {
 379         release_service(entry);
 380         return ERROR_NOT_ENOUGH_SERVER_MEMORY;
 381     }
 382
 383     if (dwDesiredAccess & MAXIMUM_ALLOWED)
 384         dwDesiredAccess |= SERVICE_ALL_ACCESS;
 385
 386     service->hdr.type = SC_HTYPE_SERVICE;
 387     service->hdr.access = dwDesiredAccess;
 388     RtlMapGenericMask(&service->hdr.access, &g_svc_generic);
 389     service->service_entry = entry;
 390
 391     *phService = &service->hdr;
 392     return ERROR_SUCCESS;
 393 }
 394
 395 DWORD __cdecl svcctl_OpenServiceW(
 396     SC_RPC_HANDLE hSCManager,
 397     LPCWSTR lpServiceName,
 398     DWORD dwDesiredAccess,
 399     SC_RPC_HANDLE *phService)
 400 {
 401     struct sc_manager_handle *manager;
 402     struct service_entry *entry;
 403     DWORD err;
 404
 405     WINE_TRACE("(%s, 0x%x)\n", wine_dbgstr_w(lpServiceName), dwDesiredAccess);
 406
 407     if ((err = validate_scm_handle(hSCManager, 0, &manager)) != ERROR_SUCCESS)
 408         return err;
 409     if (!validate_service_name(lpServiceName))
 410         return ERROR_INVALID_NAME;
 411
 412     scmdatabase_lock(manager->db);
 413     entry = grab_service(scmdatabase_find_service(manager->db, lpServiceName));
 414     scmdatabase_unlock(manager->db);
 415
 416     if (entry == NULL)
 417         return ERROR_SERVICE_DOES_NOT_EXIST;
 418
 419     return create_handle_for_service(entry, dwDesiredAccess, phService);
 420 }
 421
 422 static DWORD parse_dependencies(const WCHAR *dependencies, struct service_entry *entry)
 423 {
 424     WCHAR *services = NULL, *groups, *s;
 425     DWORD len, len_services = 0, len_groups = 0;
 426     const WCHAR *ptr = dependencies;
 427
 428     if (!dependencies || !dependencies[0])
 429     {
 430         entry->dependOnServices = NULL;
 431         entry->dependOnGroups = NULL;
 432         return ERROR_SUCCESS;
 433     }
 434
 435     while (*ptr)
 436     {
 437         len = strlenW(ptr) + 1;
 438         if (ptr[0] == '+' && ptr[1])
 439             len_groups += len - 1;
 440         else
 441             len_services += len;
 442         ptr += len;
 443     }
 444     if (!len_services) entry->dependOnServices = NULL;
 445     else
 446     {
 447         services = HeapAlloc(GetProcessHeap(), 0, (len_services + 1) * sizeof(WCHAR));
 448         if (!services)
 449             return ERROR_OUTOFMEMORY;
 450
 451         s = services;
 452         ptr = dependencies;
 453         while (*ptr)
 454         {
 455             len = strlenW(ptr) + 1;
 456             if (*ptr != '+')
 457             {
 458                 strcpyW(s, ptr);
 459                 s += len;
 460             }
 461             ptr += len;
 462         }
 463         *s = 0;
 464         entry->dependOnServices = services;
 465     }
 466     if (!len_groups) entry->dependOnGroups = NULL;
 467     else
 468     {
 469         groups = HeapAlloc(GetProcessHeap(), 0, (len_groups + 1) * sizeof(WCHAR));
 470         if (!groups)
 471         {
 472             HeapFree(GetProcessHeap(), 0, services);
 473             return ERROR_OUTOFMEMORY;
 474         }
 475         s = groups;
 476         ptr = dependencies;
 477         while (*ptr)
 478         {
 479             len = strlenW(ptr) + 1;
 480             if (ptr[0] == '+' && ptr[1])
 481             {
 482                 strcpyW(s, ptr + 1);
 483                 s += len - 1;
 484             }
 485             ptr += len;
 486         }
 487         *s = 0;
 488         entry->dependOnGroups = groups;
 489     }
 490
 491     return ERROR_SUCCESS;
 492 }
 493
 494 static DWORD create_serviceW(
 495     SC_RPC_HANDLE hSCManager,
 496     LPCWSTR lpServiceName,
 497     LPCWSTR lpDisplayName,
 498     DWORD dwDesiredAccess,
 499     DWORD dwServiceType,
 500     DWORD dwStartType,
 501     DWORD dwErrorControl,
 502     LPCWSTR lpBinaryPathName,
 503     LPCWSTR lpLoadOrderGroup,
 504     DWORD *lpdwTagId,
 505     const BYTE *lpDependencies,
 506     DWORD dwDependenciesSize,
 507     LPCWSTR lpServiceStartName,
 508     const BYTE *lpPassword,
 509     DWORD dwPasswordSize,
 510     SC_RPC_HANDLE *phService,
 511     BOOL is_wow64)
 512 {
 513     struct service_entry *entry, *found;
 514     struct sc_manager_handle *manager;
 515     DWORD err;
 516
 517     WINE_TRACE("(%s, %s, 0x%x, %s)\n", wine_dbgstr_w(lpServiceName), wine_dbgstr_w(lpDisplayName), dwDesiredAccess, wine_dbgstr_w(lpBinaryPathName));
 518
 519     if ((err = validate_scm_handle(hSCManager, SC_MANAGER_CREATE_SERVICE, &manager)) != ERROR_SUCCESS)
 520         return err;
 521
 522     if (!validate_service_name(lpServiceName))
 523         return ERROR_INVALID_NAME;
 524     if (!check_multisz((LPCWSTR)lpDependencies, dwDependenciesSize) || !lpServiceName[0] || !lpBinaryPathName[0])
 525         return ERROR_INVALID_PARAMETER;
 526
 527     if (lpPassword)
 528         WINE_FIXME("Don't know how to add a password\n");   /* I always get ERROR_GEN_FAILURE */
 529
 530     err = service_create(lpServiceName, &entry);
 531     if (err != ERROR_SUCCESS)
 532         return err;
 533
 534     err = parse_dependencies((LPCWSTR)lpDependencies, entry);
 535     if (err != ERROR_SUCCESS) {
 536         free_service_entry(entry);
 537         return err;
 538     }
 539
 540     entry->is_wow64 = is_wow64;
 541     entry->config.dwServiceType = entry->status.dwServiceType = dwServiceType;
 542     entry->config.dwStartType = dwStartType;
 543     entry->config.dwErrorControl = dwErrorControl;
 544     entry->config.lpBinaryPathName = strdupW(lpBinaryPathName);
 545     entry->config.lpLoadOrderGroup = strdupW(lpLoadOrderGroup);
 546     entry->config.lpServiceStartName = strdupW(lpServiceStartName);
 547     entry->config.lpDisplayName = strdupW(lpDisplayName);
 548
 549     if (lpdwTagId)      /* TODO: In most situations a non-NULL TagId will generate an ERROR_INVALID_PARAMETER. */
 550         entry->config.dwTagId = *lpdwTagId;
 551     else
 552         entry->config.dwTagId = 0;
 553
 554     /* other fields NULL*/
 555
 556     if (!validate_service_config(entry))
 557     {
 558         WINE_ERR("Invalid data while trying to create service\n");
 559         free_service_entry(entry);
 560         return ERROR_INVALID_PARAMETER;
 561     }
 562
 563     scmdatabase_lock(manager->db);
 564
 565     if ((found = scmdatabase_find_service(manager->db, lpServiceName)))
 566     {
 567         err = is_marked_for_delete(found) ? ERROR_SERVICE_MARKED_FOR_DELETE : ERROR_SERVICE_EXISTS;
 568         scmdatabase_unlock(manager->db);
 569         free_service_entry(entry);
 570         return err;
 571     }
 572
 573     if (scmdatabase_find_service_by_displayname(manager->db, get_display_name(entry)))
 574     {
 575         scmdatabase_unlock(manager->db);
 576         free_service_entry(entry);
 577         return ERROR_DUPLICATE_SERVICE_NAME;
 578     }
 579
 580     err = scmdatabase_add_service(manager->db, entry);
 581     if (err != ERROR_SUCCESS)
 582     {
 583         scmdatabase_unlock(manager->db);
 584         free_service_entry(entry);
 585         return err;
 586     }
 587     scmdatabase_unlock(manager->db);
 588
 589     return create_handle_for_service(entry, dwDesiredAccess, phService);
 590 }
 591
 592 DWORD __cdecl svcctl_CreateServiceW(
 593     SC_RPC_HANDLE hSCManager,
 594     LPCWSTR lpServiceName,
 595     LPCWSTR lpDisplayName,
 596     DWORD dwDesiredAccess,
 597     DWORD dwServiceType,
 598     DWORD dwStartType,
 599     DWORD dwErrorControl,
 600     LPCWSTR lpBinaryPathName,
 601     LPCWSTR lpLoadOrderGroup,
 602     DWORD *lpdwTagId,
 603     const BYTE *lpDependencies,
 604     DWORD dwDependenciesSize,
 605     LPCWSTR lpServiceStartName,
 606     const BYTE *lpPassword,
 607     DWORD dwPasswordSize,
 608     SC_RPC_HANDLE *phService)
 609 {
 610     WINE_TRACE("(%s, %s, 0x%x, %s)\n", wine_dbgstr_w(lpServiceName), wine_dbgstr_w(lpDisplayName), dwDesiredAccess, wine_dbgstr_w(lpBinaryPathName));
 611     return create_serviceW(hSCManager, lpServiceName, lpDisplayName, dwDesiredAccess, dwServiceType, dwStartType,
 612         dwErrorControl, lpBinaryPathName, lpLoadOrderGroup, lpdwTagId, lpDependencies, dwDependenciesSize, lpServiceStartName,
 613         lpPassword, dwPasswordSize, phService, FALSE);
 614 }
 615
 616 DWORD __cdecl svcctl_DeleteService(
 617     SC_RPC_HANDLE hService)
 618 {
 619     struct sc_service_handle *service;
 620     DWORD err;
 621
 622     if ((err = validate_service_handle(hService, DELETE, &service)) != ERROR_SUCCESS)
 623         return err;
 624
 625     service_lock(service->service_entry);
 626
 627     if (!is_marked_for_delete(service->service_entry))
 628         err = mark_for_delete(service->service_entry);
 629     else
 630         err = ERROR_SERVICE_MARKED_FOR_DELETE;
 631
 632     service_unlock(service->service_entry);
 633
 634     return err;
 635 }
 636
 637 DWORD __cdecl svcctl_QueryServiceConfigW(
 638         SC_RPC_HANDLE hService,
 639         QUERY_SERVICE_CONFIGW *config,
 640         DWORD buf_size,
 641         DWORD *needed_size)
 642 {
 643     struct sc_service_handle *service;
 644     DWORD err;
 645
 646     WINE_TRACE("(%p)\n", config);
 647
 648     if ((err = validate_service_handle(hService, SERVICE_QUERY_CONFIG, &service)) != 0)
 649         return err;
 650
 651     service_lock(service->service_entry);
 652     config->dwServiceType = service->service_entry->config.dwServiceType;
 653     config->dwStartType = service->service_entry->config.dwStartType;
 654     config->dwErrorControl = service->service_entry->config.dwErrorControl;
 655     config->lpBinaryPathName = strdupW(service->service_entry->config.lpBinaryPathName);
 656     config->lpLoadOrderGroup = strdupW(service->service_entry->config.lpLoadOrderGroup);
 657     config->dwTagId = service->service_entry->config.dwTagId;
 658     config->lpDependencies = NULL; /* TODO */
 659     config->lpServiceStartName = strdupW(service->service_entry->config.lpServiceStartName);
 660     config->lpDisplayName = strdupW(service->service_entry->config.lpDisplayName);
 661     service_unlock(service->service_entry);
 662
 663     return ERROR_SUCCESS;
 664 }
 665
 666 DWORD __cdecl svcctl_ChangeServiceConfigW(
 667         SC_RPC_HANDLE hService,
 668         DWORD dwServiceType,
 669         DWORD dwStartType,
 670         DWORD dwErrorControl,
 671         LPCWSTR lpBinaryPathName,
 672         LPCWSTR lpLoadOrderGroup,
 673         DWORD *lpdwTagId,
 674         const BYTE *lpDependencies,
 675         DWORD dwDependenciesSize,
 676         LPCWSTR lpServiceStartName,
 677         const BYTE *lpPassword,
 678         DWORD dwPasswordSize,
 679         LPCWSTR lpDisplayName)
 680 {
 681     struct service_entry new_entry, *entry;
 682     struct sc_service_handle *service;
 683     DWORD err;
 684
 685     WINE_TRACE("\n");
 686
 687     if ((err = validate_service_handle(hService, SERVICE_CHANGE_CONFIG, &service)) != 0)
 688         return err;
 689
 690     if (!check_multisz((LPCWSTR)lpDependencies, dwDependenciesSize))
 691         return ERROR_INVALID_PARAMETER;
 692
 693     /* first check if the new configuration is correct */
 694     service_lock(service->service_entry);
 695
 696     if (is_marked_for_delete(service->service_entry))
 697     {
 698         service_unlock(service->service_entry);
 699         return ERROR_SERVICE_MARKED_FOR_DELETE;
 700     }
 701
 702     if (lpDisplayName != NULL &&
 703         (entry = scmdatabase_find_service_by_displayname(service->service_entry->db, lpDisplayName)) &&
 704         (entry != service->service_entry))
 705     {
 706         service_unlock(service->service_entry);
 707         return ERROR_DUPLICATE_SERVICE_NAME;
 708     }
 709
 710     new_entry = *service->service_entry;
 711
 712     if (dwServiceType != SERVICE_NO_CHANGE)
 713         new_entry.config.dwServiceType = dwServiceType;
 714
 715     if (dwStartType != SERVICE_NO_CHANGE)
 716         new_entry.config.dwStartType = dwStartType;
 717
 718     if (dwErrorControl != SERVICE_NO_CHANGE)
 719         new_entry.config.dwErrorControl = dwErrorControl;
 720
 721     if (lpBinaryPathName != NULL)
 722         new_entry.config.lpBinaryPathName = (LPWSTR)lpBinaryPathName;
 723
 724     if (lpLoadOrderGroup != NULL)
 725         new_entry.config.lpLoadOrderGroup = (LPWSTR)lpLoadOrderGroup;
 726
 727     if (lpdwTagId != NULL)
 728         WINE_FIXME("Changing tag id not supported\n");
 729
 730     if (lpServiceStartName != NULL)
 731         new_entry.config.lpServiceStartName = (LPWSTR)lpServiceStartName;
 732
 733     if (lpPassword != NULL)
 734         WINE_FIXME("Setting password not supported\n");
 735
 736     if (lpDisplayName != NULL)
 737         new_entry.config.lpDisplayName = (LPWSTR)lpDisplayName;
 738
 739     err = parse_dependencies((LPCWSTR)lpDependencies, &new_entry);
 740     if (err != ERROR_SUCCESS)
 741     {
 742         service_unlock(service->service_entry);
 743         return err;
 744     }
 745
 746     if (!validate_service_config(&new_entry))
 747     {
 748         WINE_ERR("The configuration after the change wouldn't be valid\n");
 749         service_unlock(service->service_entry);
 750         return ERROR_INVALID_PARAMETER;
 751     }
 752
 753     /* configuration OK. The strings needs to be duplicated */
 754     if (lpBinaryPathName != NULL)
 755         new_entry.config.lpBinaryPathName = strdupW(lpBinaryPathName);
 756
 757     if (lpLoadOrderGroup != NULL)
 758         new_entry.config.lpLoadOrderGroup = strdupW(lpLoadOrderGroup);
 759
 760     if (lpServiceStartName != NULL)
 761         new_entry.config.lpServiceStartName = strdupW(lpServiceStartName);
 762
 763     if (lpDisplayName != NULL)
 764         new_entry.config.lpDisplayName = strdupW(lpDisplayName);
 765
 766     /* try to save to Registry, commit or rollback depending on success */
 767     err = save_service_config(&new_entry);
 768     if (ERROR_SUCCESS == err)
 769     {
 770         free_service_strings(service->service_entry, &new_entry);
 771         *service->service_entry = new_entry;
 772     }
 773     else free_service_strings(&new_entry, service->service_entry);
 774     service_unlock(service->service_entry);
 775
 776     return err;
 777 }
 778
 779 DWORD __cdecl svcctl_SetServiceStatus(
 780     SC_RPC_HANDLE hServiceStatus,
 781     LPSERVICE_STATUS lpServiceStatus)
 782 {
 783     struct sc_service_handle *service;
 784     struct process_entry *process;
 785     DWORD err;
 786
 787     WINE_TRACE("(%p, %p)\n", hServiceStatus, lpServiceStatus);
 788
 789     if ((err = validate_service_handle(hServiceStatus, SERVICE_SET_STATUS, &service)) != 0)
 790         return err;
 791
 792     service_lock(service->service_entry);
 793
 794     /* FIXME: be a bit more discriminant about what parts of the status we set
 795      * and check that fields are valid */
 796     service->service_entry->status = *lpServiceStatus;
 797     SetEvent(service->service_entry->status_changed_event);
 798
 799     if ((process = service->service_entry->process) &&
 800         lpServiceStatus->dwCurrentState == SERVICE_STOPPED)
 801     {
 802         service->service_entry->process = NULL;
 803         if (!--process->use_count)
 804             terminate_after_timeout(process, service_kill_timeout);
 805         if (service->service_entry->shared_process && process->use_count <= 1)
 806             shutdown_shared_process(process);
 807         release_process(process);
 808     }
 809
 810     service_unlock(service->service_entry);
 811
 812     return ERROR_SUCCESS;
 813 }
 814
 815 DWORD __cdecl svcctl_ChangeServiceConfig2W( SC_RPC_HANDLE hService, SC_RPC_CONFIG_INFOW config )
 816 {
 817     struct sc_service_handle *service;
 818     DWORD err;
 819
 820     if ((err = validate_service_handle(hService, SERVICE_CHANGE_CONFIG, &service)) != 0)
 821         return err;
 822
 823     switch (config.dwInfoLevel)
 824     {
 825     case SERVICE_CONFIG_DESCRIPTION:
 826         {
 827             WCHAR *descr = NULL;
 828
 829             if (config.u.descr->lpDescription[0])
 830             {
 831                 if (!(descr = strdupW( config.u.descr->lpDescription )))
 832                     return ERROR_NOT_ENOUGH_MEMORY;
 833             }
 834
 835             WINE_TRACE( "changing service %p descr to %s\n", service, wine_dbgstr_w(descr) );
 836             service_lock( service->service_entry );
 837             HeapFree( GetProcessHeap(), 0, service->service_entry->description );
 838             service->service_entry->description = descr;
 839             save_service_config( service->service_entry );
 840             service_unlock( service->service_entry );
 841         }
 842         break;
 843     case SERVICE_CONFIG_FAILURE_ACTIONS:
 844         WINE_FIXME( "SERVICE_CONFIG_FAILURE_ACTIONS not implemented: period %u msg %s cmd %s\n",
 845                     config.u.actions->dwResetPeriod,
 846                     wine_dbgstr_w(config.u.actions->lpRebootMsg),
 847                     wine_dbgstr_w(config.u.actions->lpCommand) );
 848         break;
 849     case SERVICE_CONFIG_PRESHUTDOWN_INFO:
 850         WINE_TRACE( "changing service %p preshutdown timeout to %d\n",
 851                 service, config.u.preshutdown->dwPreshutdownTimeout );
 852         service_lock( service->service_entry );
 853         service->service_entry->preshutdown_timeout = config.u.preshutdown->dwPreshutdownTimeout;
 854         save_service_config( service->service_entry );
 855         service_unlock( service->service_entry );
 856         break;
 857     default:
 858         WINE_FIXME("level %u not implemented\n", config.dwInfoLevel);
 859         err = ERROR_INVALID_LEVEL;
 860         break;
 861     }
 862     return err;
 863 }
 864
 865 DWORD __cdecl svcctl_QueryServiceConfig2W( SC_RPC_HANDLE hService, DWORD level,
 866                                            BYTE *buffer, DWORD size, LPDWORD needed )
 867 {
 868     struct sc_service_handle *service;
 869     DWORD err;
 870
 871     memset(buffer, 0, size);
 872
 873     if ((err = validate_service_handle(hService, SERVICE_QUERY_STATUS, &service)) != 0)
 874         return err;
 875
 876     switch (level)
 877     {
 878     case SERVICE_CONFIG_DESCRIPTION:
 879         {
 880             SERVICE_DESCRIPTIONW *descr = (SERVICE_DESCRIPTIONW *)buffer;
 881
 882             service_lock(service->service_entry);
 883             *needed = sizeof(*descr);
 884             if (service->service_entry->description)
 885                 *needed += (strlenW(service->service_entry->description) + 1) * sizeof(WCHAR);
 886             if (size >= *needed)
 887             {
 888                 if (service->service_entry->description)
 889                 {
 890                     /* store a buffer offset instead of a pointer */
 891                     descr->lpDescription = (WCHAR *)((BYTE *)(descr + 1) - buffer);
 892                     strcpyW( (WCHAR *)(descr + 1), service->service_entry->description );
 893                 }
 894                 else descr->lpDescription = NULL;
 895             }
 896             else err = ERROR_INSUFFICIENT_BUFFER;
 897             service_unlock(service->service_entry);
 898         }
 899         break;
 900
 901     case SERVICE_CONFIG_PRESHUTDOWN_INFO:
 902         service_lock(service->service_entry);
 903
 904         *needed = sizeof(SERVICE_PRESHUTDOWN_INFO);
 905         if (size >= *needed)
 906             ((LPSERVICE_PRESHUTDOWN_INFO)buffer)->dwPreshutdownTimeout =
 907                 service->service_entry->preshutdown_timeout;
 908         else err = ERROR_INSUFFICIENT_BUFFER;
 909
 910         service_unlock(service->service_entry);
 911         break;
 912
 913     default:
 914         WINE_FIXME("level %u not implemented\n", level);
 915         err = ERROR_INVALID_LEVEL;
 916         break;
 917     }
 918     return err;
 919 }
 920
 921 static void fill_status_process(SERVICE_STATUS_PROCESS *status, struct service_entry *service)
 922 {
 923     struct process_entry *process = service->process;
 924     memcpy(status, &service->status, sizeof(service->status));
 925     status->dwProcessId     = process ? process->process_id : 0;
 926     status->dwServiceFlags  = 0;
 927 }
 928
 929 DWORD __cdecl svcctl_QueryServiceStatusEx(
 930     SC_RPC_HANDLE hService,
 931     SC_STATUS_TYPE InfoLevel,
 932     BYTE *lpBuffer,
 933     DWORD cbBufSize,
 934     LPDWORD pcbBytesNeeded)
 935 {
 936     struct sc_service_handle *service;
 937     DWORD err;
 938     LPSERVICE_STATUS_PROCESS pSvcStatusData;
 939
 940     memset(lpBuffer, 0, cbBufSize);
 941
 942     if ((err = validate_service_handle(hService, SERVICE_QUERY_STATUS, &service)) != 0)
 943         return err;
 944
 945     if (InfoLevel != SC_STATUS_PROCESS_INFO)
 946         return ERROR_INVALID_LEVEL;
 947
 948     pSvcStatusData = (LPSERVICE_STATUS_PROCESS) lpBuffer;
 949     if (pSvcStatusData == NULL)
 950         return ERROR_INVALID_PARAMETER;
 951
 952     if (cbBufSize < sizeof(SERVICE_STATUS_PROCESS))
 953     {
 954         if( pcbBytesNeeded != NULL)
 955             *pcbBytesNeeded = sizeof(SERVICE_STATUS_PROCESS);
 956
 957         return ERROR_INSUFFICIENT_BUFFER;
 958     }
 959
 960     service_lock(service->service_entry);
 961     fill_status_process(pSvcStatusData, service->service_entry);
 962     service_unlock(service->service_entry);
 963
 964     return ERROR_SUCCESS;
 965 }
 966
 967 /******************************************************************************
 968  * service_accepts_control
 969  */
 970 static BOOL service_accepts_control(const struct service_entry *service, DWORD dwControl)
 971 {
 972     DWORD a = service->status.dwControlsAccepted;
 973
 974     if (dwControl >= 128 && dwControl <= 255)
 975         return TRUE;
 976
 977     switch (dwControl)
 978     {
 979     case SERVICE_CONTROL_INTERROGATE:
 980         return TRUE;
 981     case SERVICE_CONTROL_STOP:
 982         if (a&SERVICE_ACCEPT_STOP)
 983             return TRUE;
 984         break;
 985     case SERVICE_CONTROL_SHUTDOWN:
 986         if (a&SERVICE_ACCEPT_SHUTDOWN)
 987             return TRUE;
 988         break;
 989     case SERVICE_CONTROL_PAUSE:
 990     case SERVICE_CONTROL_CONTINUE:
 991         if (a&SERVICE_ACCEPT_PAUSE_CONTINUE)
 992             return TRUE;
 993         break;
 994     case SERVICE_CONTROL_PARAMCHANGE:
 995         if (a&SERVICE_ACCEPT_PARAMCHANGE)
 996             return TRUE;
 997         break;
 998     case SERVICE_CONTROL_NETBINDADD:
 999     case SERVICE_CONTROL_NETBINDREMOVE:
1000     case SERVICE_CONTROL_NETBINDENABLE:
1001     case SERVICE_CONTROL_NETBINDDISABLE:
1002         if (a&SERVICE_ACCEPT_NETBINDCHANGE)
1003             return TRUE;
1004     case SERVICE_CONTROL_HARDWAREPROFILECHANGE:
1005         if (a&SERVICE_ACCEPT_HARDWAREPROFILECHANGE)
1006             return TRUE;
1007         break;
1008     case SERVICE_CONTROL_POWEREVENT:
1009         if (a&SERVICE_ACCEPT_POWEREVENT)
1010             return TRUE;
1011         break;
1012     case SERVICE_CONTROL_SESSIONCHANGE:
1013         if (a&SERVICE_ACCEPT_SESSIONCHANGE)
1014             return TRUE;
1015         break;
1016     }
1017     return FALSE;
1018 }
1019
1020 /******************************************************************************
1021  * process_send_command
1022  */
1023 static BOOL process_send_command(struct process_entry *process, const void *data, DWORD size, DWORD *result)
1024 {
1025     OVERLAPPED overlapped;
1026     DWORD count, ret;
1027     BOOL r;
1028
1029     overlapped.hEvent = process->overlapped_event;
1030     r = WriteFile(process->control_pipe, data, size, &count, &overlapped);
1031     if (!r && GetLastError() == ERROR_IO_PENDING)
1032     {
1033         ret = WaitForSingleObject(process->overlapped_event, service_pipe_timeout);
1034         if (ret == WAIT_TIMEOUT)
1035         {
1036             WINE_ERR("sending command timed out\n");
1037             *result = ERROR_SERVICE_REQUEST_TIMEOUT;
1038             return FALSE;
1039         }
1040         r = GetOverlappedResult(process->control_pipe, &overlapped, &count, FALSE);
1041     }
1042     if (!r || count != size)
1043     {
1044         WINE_ERR("service protocol error - failed to write pipe!\n");
1045         *result  = (!r ? GetLastError() : ERROR_WRITE_FAULT);
1046         return FALSE;
1047     }
1048     r = ReadFile(process->control_pipe, result, sizeof *result, &count, &overlapped);
1049     if (!r && GetLastError() == ERROR_IO_PENDING)
1050     {
1051         ret = WaitForSingleObject(process->overlapped_event, service_pipe_timeout);
1052         if (ret == WAIT_TIMEOUT)
1053         {
1054             WINE_ERR("receiving command result timed out\n");
1055             *result = ERROR_SERVICE_REQUEST_TIMEOUT;
1056             return FALSE;
1057         }
1058         r = GetOverlappedResult(process->control_pipe, &overlapped, &count, FALSE);
1059     }
1060     if (!r || count != sizeof *result)
1061     {
1062         WINE_ERR("service protocol error - failed to read pipe "
1063             "r = %d  count = %d!\n", r, count);
1064         *result = (!r ? GetLastError() : ERROR_READ_FAULT);
1065         return FALSE;
1066     }
1067
1068     return TRUE;
1069 }
1070
1071 /******************************************************************************
1072  * process_send_control
1073  */
1074 BOOL process_send_control(struct process_entry *process, BOOL shared_process, const WCHAR *name,
1075                           DWORD control, const BYTE *data, DWORD data_size, DWORD *result)
1076 {
1077     service_start_info *ssi;
1078     DWORD len;
1079     BOOL r;
1080
1081     if (shared_process)
1082     {
1083         control |= SERVICE_CONTROL_FORWARD_FLAG;
1084         data = (BYTE *)name;
1085         data_size = (strlenW(name) + 1) * sizeof(WCHAR);
1086         name = emptyW;
1087     }
1088
1089     /* calculate how much space we need to send the startup info */
1090     len = (strlenW(name) + 1) * sizeof(WCHAR) + data_size;
1091
1092     ssi = HeapAlloc(GetProcessHeap(),0,FIELD_OFFSET(service_start_info, data[len]));
1093     ssi->magic = SERVICE_PROTOCOL_MAGIC;
1094     ssi->control = control;
1095     ssi->total_size = FIELD_OFFSET(service_start_info, data[len]);
1096     ssi->name_size = strlenW(name) + 1;
1097     strcpyW((WCHAR *)ssi->data, name);
1098     if (data_size) memcpy(&ssi->data[ssi->name_size * sizeof(WCHAR)], data, data_size);
1099
1100     r = process_send_command(process, ssi, ssi->total_size, result);
1101     HeapFree( GetProcessHeap(), 0, ssi );
1102     return r;
1103 }
1104
1105 DWORD __cdecl svcctl_StartServiceW(
1106     SC_RPC_HANDLE hService,
1107     DWORD dwNumServiceArgs,
1108     LPCWSTR *lpServiceArgVectors)
1109 {
1110     struct sc_service_handle *service;
1111     DWORD err;
1112
1113     WINE_TRACE("(%p, %d, %p)\n", hService, dwNumServiceArgs, lpServiceArgVectors);
1114
1115     if ((err = validate_service_handle(hService, SERVICE_START, &service)) != 0)
1116         return err;
1117
1118     if (service->service_entry->config.dwStartType == SERVICE_DISABLED)
1119         return ERROR_SERVICE_DISABLED;
1120
1121     if (!scmdatabase_lock_startup(service->service_entry->db))
1122         return ERROR_SERVICE_DATABASE_LOCKED;
1123
1124     err = service_start(service->service_entry, dwNumServiceArgs, lpServiceArgVectors);
1125
1126     scmdatabase_unlock_startup(service->service_entry->db);
1127     return err;
1128 }
1129
1130 DWORD __cdecl svcctl_ControlService(
1131     SC_RPC_HANDLE hService,
1132     DWORD dwControl,
1133     SERVICE_STATUS *lpServiceStatus)
1134 {
1135     DWORD access_required;
1136     struct sc_service_handle *service;
1137     struct process_entry *process;
1138     BOOL shared_process;
1139     DWORD result;
1140
1141     WINE_TRACE("(%p, %d, %p)\n", hService, dwControl, lpServiceStatus);
1142
1143     switch (dwControl)
1144     {
1145     case SERVICE_CONTROL_CONTINUE:
1146     case SERVICE_CONTROL_NETBINDADD:
1147     case SERVICE_CONTROL_NETBINDDISABLE:
1148     case SERVICE_CONTROL_NETBINDENABLE:
1149     case SERVICE_CONTROL_NETBINDREMOVE:
1150     case SERVICE_CONTROL_PARAMCHANGE:
1151     case SERVICE_CONTROL_PAUSE:
1152         access_required = SERVICE_PAUSE_CONTINUE;
1153         break;
1154     case SERVICE_CONTROL_INTERROGATE:
1155         access_required = SERVICE_INTERROGATE;
1156         break;
1157     case SERVICE_CONTROL_STOP:
1158         access_required = SERVICE_STOP;
1159         break;
1160     default:
1161         if (dwControl >= 128 && dwControl <= 255)
1162             access_required = SERVICE_USER_DEFINED_CONTROL;
1163         else
1164             return ERROR_INVALID_PARAMETER;
1165     }
1166
1167     if ((result = validate_service_handle(hService, access_required, &service)) != 0)
1168         return result;
1169
1170     service_lock(service->service_entry);
1171
1172     result = ERROR_SUCCESS;
1173     switch (service->service_entry->status.dwCurrentState)
1174     {
1175     case SERVICE_STOPPED:
1176         result = ERROR_SERVICE_NOT_ACTIVE;
1177         break;
1178     case SERVICE_START_PENDING:
1179         if (dwControl==SERVICE_CONTROL_STOP)
1180             break;
1181         /* fall through */
1182     case SERVICE_STOP_PENDING:
1183         result = ERROR_SERVICE_CANNOT_ACCEPT_CTRL;
1184         break;
1185     }
1186
1187     if (result == ERROR_SUCCESS && service->service_entry->force_shutdown)
1188     {
1189         result = ERROR_SERVICE_CANNOT_ACCEPT_CTRL;
1190         if ((process = service->service_entry->process))
1191         {
1192             service->service_entry->process = NULL;
1193             if (!--process->use_count) process_terminate(process);
1194             release_process(process);
1195         }
1196     }
1197
1198     if (result != ERROR_SUCCESS)
1199     {
1200         if (lpServiceStatus) *lpServiceStatus = service->service_entry->status;
1201         service_unlock(service->service_entry);
1202         return result;
1203     }
1204
1205     if (!service_accepts_control(service->service_entry, dwControl))
1206     {
1207         service_unlock(service->service_entry);
1208         return ERROR_INVALID_SERVICE_CONTROL;
1209     }
1210
1211     /* Remember that we tried to shutdown this service. When the service is
1212      * still running on the second invocation, it will be forcefully killed. */
1213     if (dwControl == SERVICE_CONTROL_STOP)
1214         service->service_entry->force_shutdown = TRUE;
1215
1216     /* Hold a reference to the process while sending the command. */
1217     process = grab_process(service->service_entry->process);
1218     shared_process = service->service_entry->shared_process;
1219     service_unlock(service->service_entry);
1220
1221     if (!process)
1222         return ERROR_SERVICE_CANNOT_ACCEPT_CTRL;
1223
1224     result = WaitForSingleObject(process->control_mutex, 30000);
1225     if (result != WAIT_OBJECT_0)
1226     {
1227         release_process(process);
1228         return ERROR_SERVICE_REQUEST_TIMEOUT;
1229     }
1230
1231     if (process_send_control(process, shared_process, service->service_entry->name,
1232                              dwControl, NULL, 0, &result))
1233         result = ERROR_SUCCESS;
1234
1235     if (lpServiceStatus)
1236     {
1237         service_lock(service->service_entry);
1238         *lpServiceStatus = service->service_entry->status;
1239         service_unlock(service->service_entry);
1240     }
1241
1242     ReleaseMutex(process->control_mutex);
1243     release_process(process);
1244     return result;
1245 }
1246
1247 DWORD __cdecl svcctl_CloseServiceHandle(
1248     SC_RPC_HANDLE *handle)
1249 {
1250     WINE_TRACE("(&%p)\n", *handle);
1251
1252     SC_RPC_HANDLE_destroy(*handle);
1253     *handle = NULL;
1254
1255     return ERROR_SUCCESS;
1256 }
1257
1258 static void SC_RPC_LOCK_destroy(SC_RPC_LOCK hLock)
1259 {
1260     struct sc_lock *lock = hLock;
1261     scmdatabase_unlock_startup(lock->db);
1262     HeapFree(GetProcessHeap(), 0, lock);
1263 }
1264
1265 void __RPC_USER SC_RPC_LOCK_rundown(SC_RPC_LOCK hLock)
1266 {
1267     SC_RPC_LOCK_destroy(hLock);
1268 }
1269
1270 DWORD __cdecl svcctl_LockServiceDatabase(
1271     SC_RPC_HANDLE hSCManager,
1272     SC_RPC_LOCK *phLock)
1273 {
1274     struct sc_manager_handle *manager;
1275     struct sc_lock *lock;
1276     DWORD err;
1277
1278     WINE_TRACE("(%p, %p)\n", hSCManager, phLock);
1279
1280     if ((err = validate_scm_handle(hSCManager, SC_MANAGER_LOCK, &manager)) != ERROR_SUCCESS)
1281         return err;
1282
1283     if (!scmdatabase_lock_startup(manager->db))
1284         return ERROR_SERVICE_DATABASE_LOCKED;
1285
1286     lock = HeapAlloc(GetProcessHeap(), 0, sizeof(struct sc_lock));
1287     if (!lock)
1288     {
1289         scmdatabase_unlock_startup(manager->db);
1290         return ERROR_NOT_ENOUGH_SERVER_MEMORY;
1291     }
1292
1293     lock->db = manager->db;
1294     *phLock = lock;
1295
1296     return ERROR_SUCCESS;
1297 }
1298
1299 DWORD __cdecl svcctl_UnlockServiceDatabase(
1300     SC_RPC_LOCK *phLock)
1301 {
1302     WINE_TRACE("(&%p)\n", *phLock);
1303
1304     SC_RPC_LOCK_destroy(*phLock);
1305     *phLock = NULL;
1306
1307     return ERROR_SUCCESS;
1308 }
1309
1310 static BOOL map_state(DWORD state, DWORD mask)
1311 {
1312     switch (state)
1313     {
1314     case SERVICE_START_PENDING:
1315     case SERVICE_STOP_PENDING:
1316     case SERVICE_RUNNING:
1317     case SERVICE_CONTINUE_PENDING:
1318     case SERVICE_PAUSE_PENDING:
1319     case SERVICE_PAUSED:
1320         if (SERVICE_ACTIVE & mask) return TRUE;
1321         break;
1322     case SERVICE_STOPPED:
1323         if (SERVICE_INACTIVE & mask) return TRUE;
1324         break;
1325     default:
1326         WINE_ERR("unknown state %u\n", state);
1327         break;
1328     }
1329     return FALSE;
1330 }
1331
1332 DWORD __cdecl svcctl_EnumServicesStatusW(
1333     SC_RPC_HANDLE hmngr,
1334     DWORD type,
1335     DWORD state,
1336     BYTE *buffer,
1337     DWORD size,
1338     LPDWORD needed,
1339     LPDWORD returned,
1340     LPDWORD resume)
1341 {
1342     DWORD err, sz, total_size, num_services;
1343     DWORD_PTR offset;
1344     struct sc_manager_handle *manager;
1345     struct service_entry *service;
1346     ENUM_SERVICE_STATUSW *s;
1347
1348     WINE_TRACE("(%p, 0x%x, 0x%x, %p, %u, %p, %p, %p)\n", hmngr, type, state, buffer, size, needed, returned, resume);
1349
1350     if (!type || !state)
1351         return ERROR_INVALID_PARAMETER;
1352
1353     if ((err = validate_scm_handle(hmngr, SC_MANAGER_ENUMERATE_SERVICE, &manager)) != ERROR_SUCCESS)
1354         return err;
1355
1356     if (resume)
1357         WINE_FIXME("resume index not supported\n");
1358
1359     scmdatabase_lock(manager->db);
1360
1361     total_size = num_services = 0;
1362     LIST_FOR_EACH_ENTRY(service, &manager->db->services, struct service_entry, entry)
1363     {
1364         if ((service->status.dwServiceType & type) && map_state(service->status.dwCurrentState, state))
1365         {
1366             total_size += sizeof(ENUM_SERVICE_STATUSW);
1367             total_size += (strlenW(service->name) + 1) * sizeof(WCHAR);
1368             if (service->config.lpDisplayName)
1369             {
1370                 total_size += (strlenW(service->config.lpDisplayName) + 1) * sizeof(WCHAR);
1371             }
1372             num_services++;
1373         }
1374     }
1375     *returned = 0;
1376     *needed = total_size;
1377     if (total_size > size)
1378     {
1379         scmdatabase_unlock(manager->db);
1380         return ERROR_MORE_DATA;
1381     }
1382     s = (ENUM_SERVICE_STATUSW *)buffer;
1383     offset = num_services * sizeof(ENUM_SERVICE_STATUSW);
1384     LIST_FOR_EACH_ENTRY(service, &manager->db->services, struct service_entry, entry)
1385     {
1386         if ((service->status.dwServiceType & type) && map_state(service->status.dwCurrentState, state))
1387         {
1388             sz = (strlenW(service->name) + 1) * sizeof(WCHAR);
1389             memcpy(buffer + offset, service->name, sz);
1390             s->lpServiceName = (WCHAR *)offset; /* store a buffer offset instead of a pointer */
1391             offset += sz;
1392
1393             if (!service->config.lpDisplayName) s->lpDisplayName = NULL;
1394             else
1395             {
1396                 sz = (strlenW(service->config.lpDisplayName) + 1) * sizeof(WCHAR);
1397                 memcpy(buffer + offset, service->config.lpDisplayName, sz);
1398                 s->lpDisplayName = (WCHAR *)offset;
1399                 offset += sz;
1400             }
1401             s->ServiceStatus = service->status;
1402             s++;
1403         }
1404     }
1405     *returned = num_services;
1406     *needed = 0;
1407     scmdatabase_unlock(manager->db);
1408     return ERROR_SUCCESS;
1409 }
1410
1411 static struct service_entry *find_service_by_group(struct scmdatabase *db, const WCHAR *group)
1412 {
1413     struct service_entry *service;
1414     LIST_FOR_EACH_ENTRY(service, &db->services, struct service_entry, entry)
1415     {
1416         if (service->config.lpLoadOrderGroup && !strcmpiW(group, service->config.lpLoadOrderGroup))
1417             return service;
1418     }
1419     return NULL;
1420 }
1421
1422 static BOOL match_group(const WCHAR *g1, const WCHAR *g2)
1423 {
1424     if (!g2) return TRUE;
1425     if (!g2[0] && (!g1 || !g1[0])) return TRUE;
1426     if (g1 && !strcmpW(g1, g2)) return TRUE;
1427     return FALSE;
1428 }
1429
1430 DWORD __cdecl svcctl_EnumServicesStatusExA(
1431     SC_RPC_HANDLE scmanager,
1432     SC_ENUM_TYPE info_level,
1433     DWORD service_type,
1434     DWORD service_state,
1435     BYTE *buffer,
1436     DWORD buf_size,
1437     DWORD *needed_size,
1438     DWORD *services_count,
1439     DWORD *resume_index,
1440     LPCSTR groupname)
1441 {
1442     WINE_FIXME("\n");
1443     return ERROR_CALL_NOT_IMPLEMENTED;
1444 }
1445
1446 DWORD __cdecl svcctl_EnumServicesStatusExW(
1447     SC_RPC_HANDLE hmngr,
1448     SC_ENUM_TYPE info_level,
1449     DWORD type,
1450     DWORD state,
1451     BYTE *buffer,
1452     DWORD size,
1453     LPDWORD needed,
1454     LPDWORD returned,
1455     DWORD *resume_handle,
1456     LPCWSTR group)
1457 {
1458     DWORD err, sz, total_size, num_services;
1459     DWORD_PTR offset;
1460     struct sc_manager_handle *manager;
1461     struct service_entry *service;
1462     ENUM_SERVICE_STATUS_PROCESSW *s;
1463
1464     WINE_TRACE("(%p, 0x%x, 0x%x, %p, %u, %p, %p, %s)\n", hmngr, type, state, buffer, size,
1465                needed, returned, wine_dbgstr_w(group));
1466
1467     if (resume_handle)
1468         FIXME("resume handle not supported\n");
1469
1470     if (!type || !state)
1471         return ERROR_INVALID_PARAMETER;
1472
1473     if ((err = validate_scm_handle(hmngr, SC_MANAGER_ENUMERATE_SERVICE, &manager)) != ERROR_SUCCESS)
1474         return err;
1475
1476     scmdatabase_lock(manager->db);
1477
1478     if (group && !find_service_by_group(manager->db, group))
1479     {
1480         scmdatabase_unlock(manager->db);
1481         return ERROR_SERVICE_DOES_NOT_EXIST;
1482     }
1483
1484     total_size = num_services = 0;
1485     LIST_FOR_EACH_ENTRY(service, &manager->db->services, struct service_entry, entry)
1486     {
1487         if ((service->status.dwServiceType & type) && map_state(service->status.dwCurrentState, state)
1488             && match_group(service->config.lpLoadOrderGroup, group))
1489         {
1490             total_size += sizeof(ENUM_SERVICE_STATUS_PROCESSW);
1491             total_size += (strlenW(service->name) + 1) * sizeof(WCHAR);
1492             if (service->config.lpDisplayName)
1493             {
1494                 total_size += (strlenW(service->config.lpDisplayName) + 1) * sizeof(WCHAR);
1495             }
1496             num_services++;
1497         }
1498     }
1499     *returned = 0;
1500     *needed = total_size;
1501     if (total_size > size)
1502     {
1503         scmdatabase_unlock(manager->db);
1504         return ERROR_MORE_DATA;
1505     }
1506     s = (ENUM_SERVICE_STATUS_PROCESSW *)buffer;
1507     offset = num_services * sizeof(ENUM_SERVICE_STATUS_PROCESSW);
1508     LIST_FOR_EACH_ENTRY(service, &manager->db->services, struct service_entry, entry)
1509     {
1510         if ((service->status.dwServiceType & type) && map_state(service->status.dwCurrentState, state)
1511             && match_group(service->config.lpLoadOrderGroup, group))
1512         {
1513             sz = (strlenW(service->name) + 1) * sizeof(WCHAR);
1514             memcpy(buffer + offset, service->name, sz);
1515             s->lpServiceName = (WCHAR *)offset; /* store a buffer offset instead of a pointer */
1516             offset += sz;
1517
1518             if (!service->config.lpDisplayName) s->lpDisplayName = NULL;
1519             else
1520             {
1521                 sz = (strlenW(service->config.lpDisplayName) + 1) * sizeof(WCHAR);
1522                 memcpy(buffer + offset, service->config.lpDisplayName, sz);
1523                 s->lpDisplayName = (WCHAR *)offset;
1524                 offset += sz;
1525             }
1526             fill_status_process(&s->ServiceStatusProcess, service);
1527             s++;
1528         }
1529     }
1530     *returned = num_services;
1531     *needed = 0;
1532     scmdatabase_unlock(manager->db);
1533     return ERROR_SUCCESS;
1534 }
1535
1536 DWORD __cdecl svcctl_unknown43(void)
1537 {
1538     WINE_FIXME("\n");
1539     return ERROR_CALL_NOT_IMPLEMENTED;
1540 }
1541
1542 DWORD __cdecl svcctl_CreateServiceWOW64A(
1543     SC_RPC_HANDLE scmanager,
1544     LPCSTR servicename,
1545     LPCSTR displayname,
1546     DWORD accessmask,
1547     DWORD service_type,
1548     DWORD start_type,
1549     DWORD error_control,
1550     LPCSTR imagepath,
1551     LPCSTR loadordergroup,
1552     DWORD *tagid,
1553     const BYTE *dependencies,
1554     DWORD depend_size,
1555     LPCSTR start_name,
1556     const BYTE *password,
1557     DWORD password_size,
1558     SC_RPC_HANDLE *service)
1559 {
1560     WINE_FIXME("\n");
1561     return ERROR_CALL_NOT_IMPLEMENTED;
1562 }
1563
1564 DWORD __cdecl svcctl_CreateServiceWOW64W(
1565     SC_RPC_HANDLE scmanager,
1566     LPCWSTR servicename,
1567     LPCWSTR displayname,
1568     DWORD accessmask,
1569     DWORD service_type,
1570     DWORD start_type,
1571     DWORD error_control,
1572     LPCWSTR imagepath,
1573     LPCWSTR loadordergroup,
1574     DWORD *tagid,
1575     const BYTE *dependencies,
1576     DWORD depend_size,
1577     LPCWSTR start_name,
1578     const BYTE *password,
1579     DWORD password_size,
1580     SC_RPC_HANDLE *service)
1581 {
1582     WINE_TRACE("(%s, %s, 0x%x, %s)\n", wine_dbgstr_w(servicename), wine_dbgstr_w(displayname), accessmask, wine_dbgstr_w(imagepath));
1583     return create_serviceW(scmanager, servicename, displayname, accessmask, service_type, start_type, error_control, imagepath,
1584         loadordergroup, tagid, dependencies, depend_size, start_name, password, password_size, service, TRUE);
1585 }
1586
1587 DWORD __cdecl svcctl_unknown46(void)
1588 {
1589     WINE_FIXME("\n");
1590     return ERROR_CALL_NOT_IMPLEMENTED;
1591 }
1592
1593 DWORD __cdecl svcctl_NotifyServiceStatusChange(
1594     SC_RPC_HANDLE service,
1595     SC_RPC_NOTIFY_PARAMS params,
1596     GUID *clientprocessguid,
1597     GUID *scmprocessguid,
1598     BOOL *createremotequeue,
1599     SC_NOTIFY_RPC_HANDLE *notify)
1600 {
1601     WINE_FIXME("\n");
1602     return ERROR_CALL_NOT_IMPLEMENTED;
1603 }
1604
1605 DWORD __cdecl svcctl_GetNotifyResults(
1606     SC_NOTIFY_RPC_HANDLE notify,
1607     SC_RPC_NOTIFY_PARAMS_LIST **params)
1608 {
1609     WINE_FIXME("\n");
1610     return ERROR_CALL_NOT_IMPLEMENTED;
1611 }
1612
1613 DWORD __cdecl svcctl_CloseNotifyHandle(
1614     SC_NOTIFY_RPC_HANDLE *notify,
1615     BOOL *apc_fired)
1616 {
1617     WINE_FIXME("\n");
1618     return ERROR_CALL_NOT_IMPLEMENTED;
1619 }
1620
1621 DWORD __cdecl svcctl_ControlServiceExA(
1622     SC_RPC_HANDLE service,
1623     DWORD control,
1624     DWORD info_level,
1625     SC_RPC_SERVICE_CONTROL_IN_PARAMSA *in_params,
1626     SC_RPC_SERVICE_CONTROL_OUT_PARAMSA *out_params)
1627 {
1628     WINE_FIXME("\n");
1629     return ERROR_CALL_NOT_IMPLEMENTED;
1630 }
1631
1632 DWORD __cdecl svcctl_ControlServiceExW(
1633     SC_RPC_HANDLE service,
1634     DWORD control,
1635     DWORD info_level,
1636     SC_RPC_SERVICE_CONTROL_IN_PARAMSW *in_params,
1637     SC_RPC_SERVICE_CONTROL_OUT_PARAMSW *out_params)
1638 {
1639     WINE_FIXME("\n");
1640     return ERROR_CALL_NOT_IMPLEMENTED;
1641 }
1642
1643 DWORD __cdecl svcctl_unknown52(void)
1644 {
1645     WINE_FIXME("\n");
1646     return ERROR_CALL_NOT_IMPLEMENTED;
1647 }
1648
1649 DWORD __cdecl svcctl_unknown53(void)
1650 {
1651     WINE_FIXME("\n");
1652     return ERROR_CALL_NOT_IMPLEMENTED;
1653 }
1654
1655 DWORD __cdecl svcctl_unknown54(void)
1656 {
1657     WINE_FIXME("\n");
1658     return ERROR_CALL_NOT_IMPLEMENTED;
1659 }
1660
1661 DWORD __cdecl svcctl_unknown55(void)
1662 {
1663     WINE_FIXME("\n");
1664     return ERROR_CALL_NOT_IMPLEMENTED;
1665 }
1666
1667 DWORD __cdecl svcctl_QueryServiceConfigEx(
1668     SC_RPC_HANDLE service,
1669     DWORD info_level,
1670     SC_RPC_CONFIG_INFOW *info)
1671 {
1672     WINE_FIXME("\n");
1673     return ERROR_CALL_NOT_IMPLEMENTED;
1674 }
1675
1676 DWORD __cdecl svcctl_QueryServiceObjectSecurity(
1677     SC_RPC_HANDLE service,
1678     SECURITY_INFORMATION info,
1679     BYTE *descriptor,
1680     DWORD buf_size,
1681     DWORD *needed_size)
1682 {
1683     WINE_FIXME("\n");
1684     return ERROR_CALL_NOT_IMPLEMENTED;
1685 }
1686
1687 DWORD __cdecl svcctl_SetServiceObjectSecurity(
1688     SC_RPC_HANDLE service,
1689     SECURITY_INFORMATION info,
1690     BYTE *descriptor,
1691     DWORD buf_size)
1692 {
1693     WINE_FIXME("\n");
1694     return ERROR_CALL_NOT_IMPLEMENTED;
1695 }
1696
1697 DWORD __cdecl svcctl_QueryServiceStatus(
1698     SC_RPC_HANDLE service,
1699     SERVICE_STATUS *status)
1700 {
1701     WINE_FIXME("\n");
1702     return ERROR_CALL_NOT_IMPLEMENTED;
1703 }
1704
1705 DWORD __cdecl svcctl_NotifyBootConfigStatus(
1706     SVCCTL_HANDLEW machinename,
1707     DWORD boot_acceptable)
1708 {
1709     WINE_FIXME("\n");
1710     return ERROR_CALL_NOT_IMPLEMENTED;
1711 }
1712
1713 DWORD __cdecl svcctl_SCSetServiceBitsW(void)
1714 {
1715     WINE_FIXME("\n");
1716     return ERROR_CALL_NOT_IMPLEMENTED;
1717 }
1718
1719 DWORD __cdecl svcctl_EnumDependentServicesW(
1720     SC_RPC_HANDLE service,
1721     DWORD state,
1722     BYTE *services,
1723     DWORD buf_size,
1724     DWORD *needed_size,
1725     DWORD *services_ret)
1726 {
1727     WINE_FIXME("\n");
1728     return ERROR_CALL_NOT_IMPLEMENTED;
1729 }
1730
1731 DWORD __cdecl svcctl_QueryServiceLockStatusW(
1732     SC_RPC_HANDLE scmanager,
1733     QUERY_SERVICE_LOCK_STATUSW *status,
1734     DWORD buf_size,
1735     DWORD *needed_size)
1736 {
1737     WINE_FIXME("\n");
1738     return ERROR_CALL_NOT_IMPLEMENTED;
1739 }
1740
1741 DWORD __cdecl svcctl_SCSetServiceBitsA(void)
1742 {
1743     WINE_FIXME("\n");
1744     return ERROR_CALL_NOT_IMPLEMENTED;
1745 }
1746
1747 DWORD __cdecl svcctl_ChangeServiceConfigA(
1748     SC_RPC_HANDLE service,
1749     DWORD service_type,
1750     DWORD start_type,
1751     DWORD error_control,
1752     LPSTR binarypath,
1753     LPSTR loadordergroup,
1754     DWORD *tagid,
1755     BYTE *dependencies,
1756     DWORD depend_size,
1757     LPSTR startname,
1758     BYTE *password,
1759     DWORD password_size,
1760     LPSTR displayname)
1761 {
1762     WINE_FIXME("\n");
1763     return ERROR_CALL_NOT_IMPLEMENTED;
1764 }
1765
1766 DWORD __cdecl svcctl_CreateServiceA(
1767     SC_RPC_HANDLE scmanager,
1768     LPCSTR servicename,
1769     LPCSTR displayname,
1770     DWORD desiredaccess,
1771     DWORD service_type,
1772     DWORD start_type,
1773     DWORD error_control,
1774     LPCSTR binarypath,
1775     LPCSTR loadordergroup,
1776     DWORD *tagid,
1777     const BYTE *dependencies,
1778     DWORD depend_size,
1779     LPCSTR startname,
1780     const BYTE *password,
1781     DWORD password_size,
1782     SC_RPC_HANDLE *service)
1783 {
1784     WINE_FIXME("\n");
1785     return ERROR_CALL_NOT_IMPLEMENTED;
1786 }
1787
1788 DWORD __cdecl svcctl_EnumDependentServicesA(
1789     SC_RPC_HANDLE service,
1790     DWORD state,
1791     BYTE *services,
1792     DWORD buf_size,
1793     DWORD *needed_size,
1794     DWORD *services_ret)
1795 {
1796     WINE_FIXME("\n");
1797     return ERROR_CALL_NOT_IMPLEMENTED;
1798 }
1799
1800 DWORD __cdecl svcctl_EnumServicesStatusA(
1801     SC_RPC_HANDLE hmngr,
1802     DWORD type,
1803     DWORD state,
1804     BYTE *buffer,
1805     DWORD size,
1806     DWORD *needed,
1807     DWORD *returned,
1808     DWORD *resume)
1809 {
1810     WINE_FIXME("\n");
1811     return ERROR_CALL_NOT_IMPLEMENTED;
1812 }
1813
1814 DWORD __cdecl svcctl_OpenSCManagerA(
1815     MACHINE_HANDLEA MachineName,
1816     LPCSTR DatabaseName,
1817     DWORD dwAccessMask,
1818     SC_RPC_HANDLE *handle)
1819 {
1820     WINE_FIXME("\n");
1821     return ERROR_CALL_NOT_IMPLEMENTED;
1822 }
1823
1824 DWORD __cdecl svcctl_OpenServiceA(
1825     SC_RPC_HANDLE hSCManager,
1826     LPCSTR lpServiceName,
1827     DWORD dwDesiredAccess,
1828     SC_RPC_HANDLE *phService)
1829 {
1830     WINE_FIXME("\n");
1831     return ERROR_CALL_NOT_IMPLEMENTED;
1832 }
1833
1834 DWORD __cdecl svcctl_QueryServiceConfigA(
1835     SC_RPC_HANDLE hService,
1836     QUERY_SERVICE_CONFIGA *config,
1837     DWORD buf_size,
1838     DWORD *needed_size)
1839 {
1840     WINE_FIXME("\n");
1841     return ERROR_CALL_NOT_IMPLEMENTED;
1842 }
1843
1844 DWORD __cdecl svcctl_QueryServiceLockStatusA(
1845     SC_RPC_HANDLE scmanager,
1846     QUERY_SERVICE_LOCK_STATUSA *status,
1847     DWORD buf_size,
1848     DWORD *needed_size)
1849 {
1850     WINE_FIXME("\n");
1851     return ERROR_CALL_NOT_IMPLEMENTED;
1852 }
1853
1854 DWORD __cdecl svcctl_StartServiceA(
1855     SC_RPC_HANDLE service,
1856     DWORD argc,
1857     LPCSTR *args)
1858 {
1859     WINE_FIXME("\n");
1860     return ERROR_CALL_NOT_IMPLEMENTED;
1861 }
1862
1863 DWORD __cdecl svcctl_GetServiceDisplayNameA(
1864     SC_RPC_HANDLE hSCManager,
1865     LPCSTR servicename,
1866     CHAR buffer[],
1867     DWORD *buf_size)
1868 {
1869     WINE_FIXME("\n");
1870     return ERROR_CALL_NOT_IMPLEMENTED;
1871 }
1872
1873 DWORD __cdecl svcctl_GetServiceKeyNameA(
1874     SC_RPC_HANDLE hSCManager,
1875     LPCSTR servicename,
1876     CHAR buffer[],
1877     DWORD *buf_size)
1878 {
1879     WINE_FIXME("\n");
1880     return ERROR_CALL_NOT_IMPLEMENTED;
1881 }
1882
1883 DWORD __cdecl svcctl_GetCurrentGroupStateW(void)
1884 {
1885     WINE_FIXME("\n");
1886     return ERROR_CALL_NOT_IMPLEMENTED;
1887 }
1888
1889 DWORD __cdecl svcctl_EnumServiceGroupW(
1890     SC_RPC_HANDLE scmanager,
1891     DWORD service_type,
1892     DWORD service_state,
1893     BYTE *buffer,
1894     DWORD buf_size,
1895     DWORD *needed_size,
1896     DWORD *returned_size,
1897     DWORD *resume_index,
1898     LPCWSTR groupname)
1899 {
1900     WINE_FIXME("\n");
1901     return ERROR_CALL_NOT_IMPLEMENTED;
1902 }
1903
1904 DWORD __cdecl svcctl_ChangeServiceConfig2A(
1905     SC_RPC_HANDLE service,
1906     SC_RPC_CONFIG_INFOA info)
1907 {
1908     WINE_FIXME("\n");
1909     return ERROR_CALL_NOT_IMPLEMENTED;
1910 }
1911
1912 DWORD __cdecl svcctl_QueryServiceConfig2A(
1913     SC_RPC_HANDLE service,
1914     DWORD info_level,
1915     BYTE *buffer,
1916     DWORD buf_size,
1917     DWORD *needed_size)
1918 {
1919     WINE_FIXME("\n");
1920     return ERROR_CALL_NOT_IMPLEMENTED;
1921 }
1922
1923 DWORD RPC_Init(void)
1924 {
1925     WCHAR transport[] = SVCCTL_TRANSPORT;
1926     WCHAR endpoint[] = SVCCTL_ENDPOINT;
1927     DWORD err;
1928
1929     if (!(cleanup_group = CreateThreadpoolCleanupGroup()))
1930     {
1931         WINE_ERR("CreateThreadpoolCleanupGroup failed with error %u\n", GetLastError());
1932         return GetLastError();
1933     }
1934
1935     if ((err = RpcServerUseProtseqEpW(transport, 0, endpoint, NULL)) != ERROR_SUCCESS)
1936     {
1937         WINE_ERR("RpcServerUseProtseq failed with error %u\n", err);
1938         return err;
1939     }
1940
1941     if ((err = RpcServerRegisterIf(svcctl_v2_0_s_ifspec, 0, 0)) != ERROR_SUCCESS)
1942     {
1943         WINE_ERR("RpcServerRegisterIf failed with error %u\n", err);
1944         return err;
1945     }
1946
1947     if ((err = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, TRUE)) != ERROR_SUCCESS)
1948     {
1949         WINE_ERR("RpcServerListen failed with error %u\n", err);
1950         return err;
1951     }
1952
1953     exit_event = __wine_make_process_system();
1954     return ERROR_SUCCESS;
1955 }
1956
1957 void RPC_Stop(void)
1958 {
1959     RpcMgmtStopServerListening(NULL);
1960     RpcServerUnregisterIf(svcctl_v2_0_s_ifspec, NULL, TRUE);
1961     RpcMgmtWaitServerListen();
1962
1963     CloseThreadpoolCleanupGroupMembers(cleanup_group, TRUE, NULL);
1964     CloseThreadpoolCleanupGroup(cleanup_group);
1965     CloseHandle(exit_event);
1966 }
1967
1968 void __RPC_USER SC_RPC_HANDLE_rundown(SC_RPC_HANDLE handle)
1969 {
1970     SC_RPC_HANDLE_destroy(handle);
1971 }
1972
1973 void __RPC_USER SC_NOTIFY_RPC_HANDLE_rundown(SC_NOTIFY_RPC_HANDLE handle)
1974 {
1975 }
1976
1977 void  __RPC_FAR * __RPC_USER MIDL_user_allocate(SIZE_T len)
1978 {
1979     return HeapAlloc(GetProcessHeap(), 0, len);
1980 }
1981
1982 void __RPC_USER MIDL_user_free(void __RPC_FAR * ptr)
1983 {
1984     HeapFree(GetProcessHeap(), 0, ptr);
1985 }