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