programs/services/services.c

   1 /*
   2  * Services - controls services keeps track of their state
   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
  23 #include <stdarg.h>
  24 #include <windows.h>
  25 #include <winsvc.h>
  26 #include <rpc.h>
  27
  28 #include "wine/unicode.h"
  29 #include "wine/debug.h"
  30 #include "svcctl.h"
  31
  32 #include "services.h"
  33
  34 #define MAX_SERVICE_NAME 260
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(service);
  37
  38 HANDLE g_hStartedEvent;
  39 struct scmdatabase *active_database;
  40
  41 DWORD service_pipe_timeout = 10000;
  42 DWORD service_kill_timeout = 20000;
  43
  44 static const int is_win64 = (sizeof(void *) > sizeof(int));
  45
  46 static const WCHAR SZ_LOCAL_SYSTEM[] = {'L','o','c','a','l','S','y','s','t','e','m',0};
  47
  48 /* Registry constants */
  49 static const WCHAR SZ_SERVICES_KEY[] = { 'S','y','s','t','e','m','\\',
  50       'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
  51       'S','e','r','v','i','c','e','s',0 };
  52
  53 /* Service key values names */
  54 static const WCHAR SZ_DISPLAY_NAME[]      = {'D','i','s','p','l','a','y','N','a','m','e',0 };
  55 static const WCHAR SZ_TYPE[]              = {'T','y','p','e',0 };
  56 static const WCHAR SZ_START[]             = {'S','t','a','r','t',0 };
  57 static const WCHAR SZ_ERROR[]             = {'E','r','r','o','r','C','o','n','t','r','o','l',0 };
  58 static const WCHAR SZ_IMAGE_PATH[]        = {'I','m','a','g','e','P','a','t','h',0};
  59 static const WCHAR SZ_GROUP[]             = {'G','r','o','u','p',0};
  60 static const WCHAR SZ_DEPEND_ON_SERVICE[] = {'D','e','p','e','n','d','O','n','S','e','r','v','i','c','e',0};
  61 static const WCHAR SZ_DEPEND_ON_GROUP[]   = {'D','e','p','e','n','d','O','n','G','r','o','u','p',0};
  62 static const WCHAR SZ_OBJECT_NAME[]       = {'O','b','j','e','c','t','N','a','m','e',0};
  63 static const WCHAR SZ_TAG[]               = {'T','a','g',0};
  64 static const WCHAR SZ_DESCRIPTION[]       = {'D','e','s','c','r','i','p','t','i','o','n',0};
  65
  66
  67 DWORD service_create(LPCWSTR name, struct service_entry **entry)
  68 {
  69     *entry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**entry));
  70     if (!*entry)
  71         return ERROR_NOT_ENOUGH_SERVER_MEMORY;
  72     (*entry)->name = strdupW(name);
  73     if (!(*entry)->name)
  74     {
  75         HeapFree(GetProcessHeap(), 0, *entry);
  76         return ERROR_NOT_ENOUGH_SERVER_MEMORY;
  77     }
  78     (*entry)->control_pipe = INVALID_HANDLE_VALUE;
  79     (*entry)->status.dwCurrentState = SERVICE_STOPPED;
  80     (*entry)->status.dwWin32ExitCode = ERROR_SERVICE_NEVER_STARTED;
  81     /* all other fields are zero */
  82     return ERROR_SUCCESS;
  83 }
  84
  85 void free_service_entry(struct service_entry *entry)
  86 {
  87     HeapFree(GetProcessHeap(), 0, entry->name);
  88     HeapFree(GetProcessHeap(), 0, entry->config.lpBinaryPathName);
  89     HeapFree(GetProcessHeap(), 0, entry->config.lpDependencies);
  90     HeapFree(GetProcessHeap(), 0, entry->config.lpLoadOrderGroup);
  91     HeapFree(GetProcessHeap(), 0, entry->config.lpServiceStartName);
  92     HeapFree(GetProcessHeap(), 0, entry->config.lpDisplayName);
  93     HeapFree(GetProcessHeap(), 0, entry->description);
  94     HeapFree(GetProcessHeap(), 0, entry->dependOnServices);
  95     HeapFree(GetProcessHeap(), 0, entry->dependOnGroups);
  96     CloseHandle(entry->control_mutex);
  97     CloseHandle(entry->control_pipe);
  98     CloseHandle(entry->overlapped_event);
  99     CloseHandle(entry->status_changed_event);
 100     HeapFree(GetProcessHeap(), 0, entry);
 101 }
 102
 103 static DWORD load_service_config(HKEY hKey, struct service_entry *entry)
 104 {
 105     DWORD err;
 106     WCHAR *wptr;
 107
 108     if ((err = load_reg_string(hKey, SZ_IMAGE_PATH,   TRUE, &entry->config.lpBinaryPathName)) != 0)
 109         return err;
 110     if ((err = load_reg_string(hKey, SZ_GROUP,        0,    &entry->config.lpLoadOrderGroup)) != 0)
 111         return err;
 112     if ((err = load_reg_string(hKey, SZ_OBJECT_NAME,  TRUE, &entry->config.lpServiceStartName)) != 0)
 113         return err;
 114     if ((err = load_reg_string(hKey, SZ_DISPLAY_NAME, 0,    &entry->config.lpDisplayName)) != 0)
 115         return err;
 116     if ((err = load_reg_string(hKey, SZ_DESCRIPTION,  0,    &entry->description)) != 0)
 117         return err;
 118     if ((err = load_reg_multisz(hKey, SZ_DEPEND_ON_SERVICE, TRUE, &entry->dependOnServices)) != 0)
 119         return err;
 120     if ((err = load_reg_multisz(hKey, SZ_DEPEND_ON_GROUP, FALSE, &entry->dependOnGroups)) != 0)
 121         return err;
 122
 123     if ((err = load_reg_dword(hKey, SZ_TYPE,  &entry->config.dwServiceType)) != 0)
 124         return err;
 125     if ((err = load_reg_dword(hKey, SZ_START, &entry->config.dwStartType)) != 0)
 126         return err;
 127     if ((err = load_reg_dword(hKey, SZ_ERROR, &entry->config.dwErrorControl)) != 0)
 128         return err;
 129     if ((err = load_reg_dword(hKey, SZ_TAG,   &entry->config.dwTagId)) != 0)
 130         return err;
 131
 132     WINE_TRACE("Image path           = %s\n", wine_dbgstr_w(entry->config.lpBinaryPathName) );
 133     WINE_TRACE("Group                = %s\n", wine_dbgstr_w(entry->config.lpLoadOrderGroup) );
 134     WINE_TRACE("Service account name = %s\n", wine_dbgstr_w(entry->config.lpServiceStartName) );
 135     WINE_TRACE("Display name         = %s\n", wine_dbgstr_w(entry->config.lpDisplayName) );
 136     WINE_TRACE("Service dependencies : %s\n", entry->dependOnServices[0] ? "" : "(none)");
 137     for (wptr = entry->dependOnServices; *wptr; wptr += strlenW(wptr) + 1)
 138         WINE_TRACE("    * %s\n", wine_dbgstr_w(wptr));
 139     WINE_TRACE("Group dependencies   : %s\n", entry->dependOnGroups[0] ? "" : "(none)");
 140     for (wptr = entry->dependOnGroups; *wptr; wptr += strlenW(wptr) + 1)
 141         WINE_TRACE("    * %s\n", wine_dbgstr_w(wptr));
 142
 143     return ERROR_SUCCESS;
 144 }
 145
 146 static DWORD reg_set_string_value(HKEY hKey, LPCWSTR value_name, LPCWSTR string)
 147 {
 148     if (!string)
 149     {
 150         DWORD err;
 151         err = RegDeleteValueW(hKey, value_name);
 152         if (err != ERROR_FILE_NOT_FOUND)
 153             return err;
 154
 155         return ERROR_SUCCESS;
 156     }
 157
 158     return RegSetValueExW(hKey, value_name, 0, REG_SZ, (const BYTE*)string, sizeof(WCHAR)*(strlenW(string) + 1));
 159 }
 160
 161 static DWORD reg_set_multisz_value(HKEY hKey, LPCWSTR value_name, LPCWSTR string)
 162 {
 163     const WCHAR *ptr;
 164
 165     if (!string)
 166     {
 167         DWORD err;
 168         err = RegDeleteValueW(hKey, value_name);
 169         if (err != ERROR_FILE_NOT_FOUND)
 170             return err;
 171
 172         return ERROR_SUCCESS;
 173     }
 174
 175     ptr = string;
 176     while (*ptr) ptr += strlenW(ptr) + 1;
 177     return RegSetValueExW(hKey, value_name, 0, REG_MULTI_SZ, (const BYTE*)string, sizeof(WCHAR)*(ptr - string + 1));
 178 }
 179
 180 DWORD save_service_config(struct service_entry *entry)
 181 {
 182     DWORD err;
 183     HKEY hKey = NULL;
 184
 185     err = RegCreateKeyW(entry->db->root_key, entry->name, &hKey);
 186     if (err != ERROR_SUCCESS)
 187         goto cleanup;
 188
 189     if ((err = reg_set_string_value(hKey, SZ_DISPLAY_NAME, entry->config.lpDisplayName)) != 0)
 190         goto cleanup;
 191     if ((err = reg_set_string_value(hKey, SZ_IMAGE_PATH, entry->config.lpBinaryPathName)) != 0)
 192         goto cleanup;
 193     if ((err = reg_set_string_value(hKey, SZ_GROUP, entry->config.lpLoadOrderGroup)) != 0)
 194         goto cleanup;
 195     if ((err = reg_set_string_value(hKey, SZ_OBJECT_NAME, entry->config.lpServiceStartName)) != 0)
 196         goto cleanup;
 197     if ((err = reg_set_string_value(hKey, SZ_DESCRIPTION, entry->description)) != 0)
 198         goto cleanup;
 199     if ((err = reg_set_multisz_value(hKey, SZ_DEPEND_ON_SERVICE, entry->dependOnServices)) != 0)
 200         goto cleanup;
 201     if ((err = reg_set_multisz_value(hKey, SZ_DEPEND_ON_GROUP, entry->dependOnGroups)) != 0)
 202         goto cleanup;
 203     if ((err = RegSetValueExW(hKey, SZ_START, 0, REG_DWORD, (LPBYTE)&entry->config.dwStartType, sizeof(DWORD))) != 0)
 204         goto cleanup;
 205     if ((err = RegSetValueExW(hKey, SZ_ERROR, 0, REG_DWORD, (LPBYTE)&entry->config.dwErrorControl, sizeof(DWORD))) != 0)
 206         goto cleanup;
 207
 208     if ((err = RegSetValueExW(hKey, SZ_TYPE, 0, REG_DWORD, (LPBYTE)&entry->config.dwServiceType, sizeof(DWORD))) != 0)
 209         goto cleanup;
 210
 211     if (entry->config.dwTagId)
 212         err = RegSetValueExW(hKey, SZ_TAG, 0, REG_DWORD, (LPBYTE)&entry->config.dwTagId, sizeof(DWORD));
 213     else
 214         err = RegDeleteValueW(hKey, SZ_TAG);
 215
 216     if (err != 0 && err != ERROR_FILE_NOT_FOUND)
 217         goto cleanup;
 218
 219     err = ERROR_SUCCESS;
 220 cleanup:
 221     RegCloseKey(hKey);
 222     return err;
 223 }
 224
 225 DWORD scmdatabase_add_service(struct scmdatabase *db, struct service_entry *service)
 226 {
 227     int err;
 228     service->db = db;
 229     if ((err = save_service_config(service)) != ERROR_SUCCESS)
 230     {
 231         WINE_ERR("Couldn't store service configuration: error %u\n", err);
 232         return ERROR_GEN_FAILURE;
 233     }
 234
 235     list_add_tail(&db->services, &service->entry);
 236     return ERROR_SUCCESS;
 237 }
 238
 239 DWORD scmdatabase_remove_service(struct scmdatabase *db, struct service_entry *service)
 240 {
 241     int err;
 242
 243     err = RegDeleteTreeW(db->root_key, service->name);
 244
 245     if (err != 0)
 246         return err;
 247
 248     list_remove(&service->entry);
 249     service->entry.next = service->entry.prev = NULL;
 250     return ERROR_SUCCESS;
 251 }
 252
 253 static void scmdatabase_autostart_services(struct scmdatabase *db)
 254 {
 255     struct service_entry **services_list;
 256     unsigned int i = 0;
 257     unsigned int size = 32;
 258     struct service_entry *service;
 259
 260     services_list = HeapAlloc(GetProcessHeap(), 0, size * sizeof(services_list[0]));
 261     if (!services_list)
 262         return;
 263
 264     scmdatabase_lock_shared(db);
 265
 266     LIST_FOR_EACH_ENTRY(service, &db->services, struct service_entry, entry)
 267     {
 268         if (service->config.dwStartType == SERVICE_BOOT_START ||
 269             service->config.dwStartType == SERVICE_SYSTEM_START ||
 270             service->config.dwStartType == SERVICE_AUTO_START)
 271         {
 272             if (i+1 >= size)
 273             {
 274                 struct service_entry **slist_new;
 275                 size *= 2;
 276                 slist_new = HeapReAlloc(GetProcessHeap(), 0, services_list, size * sizeof(services_list[0]));
 277                 if (!slist_new)
 278                     break;
 279                 services_list = slist_new;
 280             }
 281             services_list[i] = service;
 282             service->ref_count++;
 283             i++;
 284         }
 285     }
 286
 287     scmdatabase_unlock(db);
 288
 289     size = i;
 290     for (i = 0; i < size; i++)
 291     {
 292         DWORD err;
 293         const WCHAR *argv[2];
 294         service = services_list[i];
 295         argv[0] = service->name;
 296         argv[1] = NULL;
 297         err = service_start(service, 1, argv);
 298         if (err != ERROR_SUCCESS)
 299             WINE_FIXME("Auto-start service %s failed to start: %d\n",
 300                        wine_dbgstr_w(service->name), err);
 301         release_service(service);
 302     }
 303
 304     HeapFree(GetProcessHeap(), 0, services_list);
 305 }
 306
 307 BOOL validate_service_name(LPCWSTR name)
 308 {
 309     return (name && name[0] && !strchrW(name, '/') && !strchrW(name, '\\'));
 310 }
 311
 312 BOOL validate_service_config(struct service_entry *entry)
 313 {
 314     if (entry->config.dwServiceType & SERVICE_WIN32 && (entry->config.lpBinaryPathName == NULL || !entry->config.lpBinaryPathName[0]))
 315     {
 316         WINE_ERR("Service %s is Win32 but has no image path set\n", wine_dbgstr_w(entry->name));
 317         return FALSE;
 318     }
 319
 320     switch (entry->config.dwServiceType)
 321     {
 322     case SERVICE_KERNEL_DRIVER:
 323     case SERVICE_FILE_SYSTEM_DRIVER:
 324     case SERVICE_WIN32_OWN_PROCESS:
 325     case SERVICE_WIN32_SHARE_PROCESS:
 326         /* No problem */
 327         break;
 328     case SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS:
 329     case SERVICE_WIN32_SHARE_PROCESS | SERVICE_INTERACTIVE_PROCESS:
 330         /* These can be only run as LocalSystem */
 331         if (entry->config.lpServiceStartName && strcmpiW(entry->config.lpServiceStartName, SZ_LOCAL_SYSTEM) != 0)
 332         {
 333             WINE_ERR("Service %s is interactive but has a start name\n", wine_dbgstr_w(entry->name));
 334             return FALSE;
 335         }
 336         break;
 337     default:
 338         WINE_ERR("Service %s has an unknown service type (0x%x)\n", wine_dbgstr_w(entry->name), entry->config.dwServiceType);
 339         return FALSE;
 340     }
 341
 342     /* StartType can only be a single value (if several values are mixed the result is probably not what was intended) */
 343     if (entry->config.dwStartType > SERVICE_DISABLED)
 344     {
 345         WINE_ERR("Service %s has an unknown start type\n", wine_dbgstr_w(entry->name));
 346         return FALSE;
 347     }
 348
 349     /* SERVICE_BOOT_START and SERVICE_SYSTEM_START are only allowed for driver services */
 350     if (((entry->config.dwStartType == SERVICE_BOOT_START) || (entry->config.dwStartType == SERVICE_SYSTEM_START)) &&
 351         ((entry->config.dwServiceType & SERVICE_WIN32_OWN_PROCESS) || (entry->config.dwServiceType & SERVICE_WIN32_SHARE_PROCESS)))
 352     {
 353         WINE_ERR("Service %s - SERVICE_BOOT_START and SERVICE_SYSTEM_START are only allowed for driver services\n", wine_dbgstr_w(entry->name));
 354         return FALSE;
 355     }
 356
 357     if (entry->config.lpServiceStartName == NULL)
 358         entry->config.lpServiceStartName = strdupW(SZ_LOCAL_SYSTEM);
 359
 360     return TRUE;
 361 }
 362
 363
 364 struct service_entry *scmdatabase_find_service(struct scmdatabase *db, LPCWSTR name)
 365 {
 366     struct service_entry *service;
 367
 368     LIST_FOR_EACH_ENTRY(service, &db->services, struct service_entry, entry)
 369     {
 370         if (strcmpiW(name, service->name) == 0)
 371             return service;
 372     }
 373
 374     return NULL;
 375 }
 376
 377 struct service_entry *scmdatabase_find_service_by_displayname(struct scmdatabase *db, LPCWSTR name)
 378 {
 379     struct service_entry *service;
 380
 381     LIST_FOR_EACH_ENTRY(service, &db->services, struct service_entry, entry)
 382     {
 383         if (service->config.lpDisplayName && strcmpiW(name, service->config.lpDisplayName) == 0)
 384             return service;
 385     }
 386
 387     return NULL;
 388 }
 389
 390 void release_service(struct service_entry *service)
 391 {
 392     if (InterlockedDecrement(&service->ref_count) == 0 && is_marked_for_delete(service))
 393         free_service_entry(service);
 394 }
 395
 396 static DWORD scmdatabase_create(struct scmdatabase **db)
 397 {
 398     DWORD err;
 399
 400     *db = HeapAlloc(GetProcessHeap(), 0, sizeof(**db));
 401     if (!*db)
 402         return ERROR_NOT_ENOUGH_SERVER_MEMORY;
 403
 404     (*db)->service_start_lock = FALSE;
 405     list_init(&(*db)->services);
 406
 407     InitializeCriticalSection(&(*db)->cs);
 408
 409     err = RegCreateKeyExW(HKEY_LOCAL_MACHINE, SZ_SERVICES_KEY, 0, NULL,
 410                           REG_OPTION_NON_VOLATILE, MAXIMUM_ALLOWED, NULL,
 411                           &(*db)->root_key, NULL);
 412     if (err != ERROR_SUCCESS)
 413         HeapFree(GetProcessHeap(), 0, *db);
 414
 415     return err;
 416 }
 417
 418 static void scmdatabase_destroy(struct scmdatabase *db)
 419 {
 420     RegCloseKey(db->root_key);
 421     DeleteCriticalSection(&db->cs);
 422     HeapFree(GetProcessHeap(), 0, db);
 423 }
 424
 425 static DWORD scmdatabase_load_services(struct scmdatabase *db)
 426 {
 427     DWORD err;
 428     int i;
 429
 430     for (i = 0; TRUE; i++)
 431     {
 432         WCHAR szName[MAX_SERVICE_NAME];
 433         struct service_entry *entry;
 434         HKEY hServiceKey;
 435
 436         err = RegEnumKeyW(db->root_key, i, szName, MAX_SERVICE_NAME);
 437         if (err == ERROR_NO_MORE_ITEMS)
 438             break;
 439
 440         if (err != 0)
 441         {
 442             WINE_ERR("Error %d reading key %d name - skipping\n", err, i);
 443             continue;
 444         }
 445
 446         err = service_create(szName, &entry);
 447         if (err != ERROR_SUCCESS)
 448             break;
 449
 450         WINE_TRACE("Loading service %s\n", wine_dbgstr_w(szName));
 451         err = RegOpenKeyExW(db->root_key, szName, 0, KEY_READ, &hServiceKey);
 452         if (err == ERROR_SUCCESS)
 453         {
 454             err = load_service_config(hServiceKey, entry);
 455             RegCloseKey(hServiceKey);
 456         }
 457
 458         if (err != ERROR_SUCCESS)
 459         {
 460             WINE_ERR("Error %d reading registry key for service %s - skipping\n", err, wine_dbgstr_w(szName));
 461             free_service_entry(entry);
 462             continue;
 463         }
 464
 465         if (entry->config.dwServiceType == 0)
 466         {
 467             /* Maybe an application only wrote some configuration in the service key. Continue silently */
 468             WINE_TRACE("Even the service type not set for service %s - skipping\n", wine_dbgstr_w(szName));
 469             free_service_entry(entry);
 470             continue;
 471         }
 472
 473         if (!validate_service_config(entry))
 474         {
 475             WINE_ERR("Invalid configuration of service %s - skipping\n", wine_dbgstr_w(szName));
 476             free_service_entry(entry);
 477             continue;
 478         }
 479
 480         entry->status.dwServiceType = entry->config.dwServiceType;
 481         entry->db = db;
 482
 483         list_add_tail(&db->services, &entry->entry);
 484     }
 485     return ERROR_SUCCESS;
 486 }
 487
 488 DWORD scmdatabase_lock_startup(struct scmdatabase *db)
 489 {
 490     if (InterlockedCompareExchange(&db->service_start_lock, TRUE, FALSE))
 491         return ERROR_SERVICE_DATABASE_LOCKED;
 492     return ERROR_SUCCESS;
 493 }
 494
 495 void scmdatabase_unlock_startup(struct scmdatabase *db)
 496 {
 497     InterlockedCompareExchange(&db->service_start_lock, FALSE, TRUE);
 498 }
 499
 500 void scmdatabase_lock_shared(struct scmdatabase *db)
 501 {
 502     EnterCriticalSection(&db->cs);
 503 }
 504
 505 void scmdatabase_lock_exclusive(struct scmdatabase *db)
 506 {
 507     EnterCriticalSection(&db->cs);
 508 }
 509
 510 void scmdatabase_unlock(struct scmdatabase *db)
 511 {
 512     LeaveCriticalSection(&db->cs);
 513 }
 514
 515 void service_lock_shared(struct service_entry *service)
 516 {
 517     EnterCriticalSection(&service->db->cs);
 518 }
 519
 520 void service_lock_exclusive(struct service_entry *service)
 521 {
 522     EnterCriticalSection(&service->db->cs);
 523 }
 524
 525 void service_unlock(struct service_entry *service)
 526 {
 527     LeaveCriticalSection(&service->db->cs);
 528 }
 529
 530 /* only one service started at a time, so there is no race on the registry
 531  * value here */
 532 static LPWSTR service_get_pipe_name(void)
 533 {
 534     static const WCHAR format[] = { '\\','\\','.','\\','p','i','p','e','\\',
 535         'n','e','t','\\','N','t','C','o','n','t','r','o','l','P','i','p','e','%','u',0};
 536     static const WCHAR service_current_key_str[] = { 'S','Y','S','T','E','M','\\',
 537         'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 538         'C','o','n','t','r','o','l','\\',
 539         'S','e','r','v','i','c','e','C','u','r','r','e','n','t',0};
 540     LPWSTR name;
 541     DWORD len;
 542     HKEY service_current_key;
 543     DWORD service_current = -1;
 544     LONG ret;
 545     DWORD type;
 546
 547     ret = RegCreateKeyExW(HKEY_LOCAL_MACHINE, service_current_key_str, 0,
 548         NULL, REG_OPTION_VOLATILE, KEY_SET_VALUE | KEY_QUERY_VALUE, NULL,
 549         &service_current_key, NULL);
 550     if (ret != ERROR_SUCCESS)
 551         return NULL;
 552     len = sizeof(service_current);
 553     ret = RegQueryValueExW(service_current_key, NULL, NULL, &type,
 554         (BYTE *)&service_current, &len);
 555     if ((ret == ERROR_SUCCESS && type == REG_DWORD) || ret == ERROR_FILE_NOT_FOUND)
 556     {
 557         service_current++;
 558         RegSetValueExW(service_current_key, NULL, 0, REG_DWORD,
 559             (BYTE *)&service_current, sizeof(service_current));
 560     }
 561     RegCloseKey(service_current_key);
 562     if ((ret != ERROR_SUCCESS || type != REG_DWORD) && (ret != ERROR_FILE_NOT_FOUND))
 563         return NULL;
 564     len = sizeof(format)/sizeof(WCHAR) + 10 /* strlenW("4294967295") */;
 565     name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 566     if (!name)
 567         return NULL;
 568     snprintfW(name, len, format, service_current);
 569     return name;
 570 }
 571
 572 static DWORD service_start_process(struct service_entry *service_entry, HANDLE *process)
 573 {
 574     PROCESS_INFORMATION pi;
 575     STARTUPINFOW si;
 576     LPWSTR path = NULL;
 577     DWORD size;
 578     BOOL r;
 579
 580     service_lock_exclusive(service_entry);
 581
 582     size = ExpandEnvironmentStringsW(service_entry->config.lpBinaryPathName,NULL,0);
 583     path = HeapAlloc(GetProcessHeap(),0,size*sizeof(WCHAR));
 584     if (!path)
 585     {
 586         service_unlock(service_entry);
 587         return ERROR_NOT_ENOUGH_SERVER_MEMORY;
 588     }
 589     ExpandEnvironmentStringsW(service_entry->config.lpBinaryPathName,path,size);
 590
 591     if (service_entry->config.dwServiceType == SERVICE_KERNEL_DRIVER)
 592     {
 593         static const WCHAR winedeviceW[] = {'\\','w','i','n','e','d','e','v','i','c','e','.','e','x','e',' ',0};
 594         WCHAR system_dir[MAX_PATH];
 595         DWORD type, len;
 596
 597         GetSystemDirectoryW( system_dir, MAX_PATH );
 598         if (is_win64)
 599         {
 600             if (!GetBinaryTypeW( path, &type ))
 601             {
 602                 HeapFree( GetProcessHeap(), 0, path );
 603                 service_unlock(service_entry);
 604                 return GetLastError();
 605             }
 606             if (type == SCS_32BIT_BINARY) GetSystemWow64DirectoryW( system_dir, MAX_PATH );
 607         }
 608
 609         len = strlenW( system_dir ) + sizeof(winedeviceW)/sizeof(WCHAR) + strlenW(service_entry->name);
 610         HeapFree( GetProcessHeap(), 0, path );
 611         if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
 612         {
 613             service_unlock(service_entry);
 614             return ERROR_NOT_ENOUGH_SERVER_MEMORY;
 615         }
 616         lstrcpyW( path, system_dir );
 617         lstrcatW( path, winedeviceW );
 618         lstrcatW( path, service_entry->name );
 619     }
 620
 621     ZeroMemory(&si, sizeof(STARTUPINFOW));
 622     si.cb = sizeof(STARTUPINFOW);
 623     if (!(service_entry->config.dwServiceType & SERVICE_INTERACTIVE_PROCESS))
 624     {
 625         static WCHAR desktopW[] = {'_','_','w','i','n','e','s','e','r','v','i','c','e','_','w','i','n','s','t','a','t','i','o','n','\\','D','e','f','a','u','l','t',0};
 626         si.lpDesktop = desktopW;
 627     }
 628
 629     service_entry->status.dwCurrentState = SERVICE_START_PENDING;
 630
 631     service_unlock(service_entry);
 632
 633     r = CreateProcessW(NULL, path, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
 634     HeapFree(GetProcessHeap(),0,path);
 635     if (!r)
 636     {
 637         service_lock_exclusive(service_entry);
 638         service_entry->status.dwCurrentState = SERVICE_STOPPED;
 639         service_unlock(service_entry);
 640         return GetLastError();
 641     }
 642
 643     service_entry->status.dwProcessId = pi.dwProcessId;
 644     *process = pi.hProcess;
 645     CloseHandle( pi.hThread );
 646
 647     return ERROR_SUCCESS;
 648 }
 649
 650 static DWORD service_wait_for_startup(struct service_entry *service_entry, HANDLE process_handle)
 651 {
 652     WINE_TRACE("%p\n", service_entry);
 653
 654     for (;;)
 655     {
 656         DWORD dwCurrentStatus;
 657         HANDLE handles[2] = { service_entry->status_changed_event, process_handle };
 658         DWORD ret;
 659         ret = WaitForMultipleObjects( 2, handles, FALSE, service_pipe_timeout );
 660         if (ret != WAIT_OBJECT_0)
 661             return ERROR_SERVICE_REQUEST_TIMEOUT;
 662         service_lock_shared(service_entry);
 663         dwCurrentStatus = service_entry->status.dwCurrentState;
 664         service_unlock(service_entry);
 665         if (dwCurrentStatus == SERVICE_RUNNING)
 666         {
 667             WINE_TRACE("Service started successfully\n");
 668             return ERROR_SUCCESS;
 669         }
 670         if (dwCurrentStatus != SERVICE_START_PENDING)
 671             return ERROR_SERVICE_REQUEST_TIMEOUT;
 672     }
 673 }
 674
 675 /******************************************************************************
 676  * service_send_start_message
 677  */
 678 static BOOL service_send_start_message(struct service_entry *service, HANDLE process_handle,
 679                                        LPCWSTR *argv, DWORD argc)
 680 {
 681     OVERLAPPED overlapped;
 682     DWORD i, len, result;
 683     service_start_info *ssi;
 684     LPWSTR p;
 685     BOOL r;
 686
 687     WINE_TRACE("%s %p %d\n", wine_dbgstr_w(service->name), argv, argc);
 688
 689     overlapped.hEvent = service->overlapped_event;
 690     if (!ConnectNamedPipe(service->control_pipe, &overlapped))
 691     {
 692         if (GetLastError() == ERROR_IO_PENDING)
 693         {
 694             HANDLE handles[2];
 695             handles[0] = service->overlapped_event;
 696             handles[1] = process_handle;
 697             if (WaitForMultipleObjects( 2, handles, FALSE, service_pipe_timeout ) != WAIT_OBJECT_0)
 698                 CancelIo( service->control_pipe );
 699             if (!HasOverlappedCompleted( &overlapped ))
 700             {
 701                 WINE_ERR( "service %s failed to start\n", wine_dbgstr_w( service->name ));
 702                 return FALSE;
 703             }
 704         }
 705         else if (GetLastError() != ERROR_PIPE_CONNECTED)
 706         {
 707             WINE_ERR("pipe connect failed\n");
 708             return FALSE;
 709         }
 710     }
 711
 712     /* calculate how much space do we need to send the startup info */
 713     len = strlenW(service->name) + 1;
 714     for (i=0; i<argc; i++)
 715         len += strlenW(argv[i])+1;
 716     len++;
 717
 718     ssi = HeapAlloc(GetProcessHeap(),0,FIELD_OFFSET(service_start_info, data[len]));
 719     ssi->cmd = WINESERV_STARTINFO;
 720     ssi->control = 0;
 721     ssi->total_size = FIELD_OFFSET(service_start_info, data[len]);
 722     ssi->name_size = strlenW(service->name) + 1;
 723     strcpyW( ssi->data, service->name );
 724
 725     /* copy service args into a single buffer*/
 726     p = &ssi->data[ssi->name_size];
 727     for (i=0; i<argc; i++)
 728     {
 729         strcpyW(p, argv[i]);
 730         p += strlenW(p) + 1;
 731     }
 732     *p=0;
 733
 734     r = service_send_command( service, service->control_pipe, ssi, ssi->total_size, &result );
 735     if (r && result)
 736     {
 737         SetLastError(result);
 738         r = FALSE;
 739     }
 740
 741     HeapFree(GetProcessHeap(),0,ssi);
 742
 743     return r;
 744 }
 745
 746 DWORD service_start(struct service_entry *service, DWORD service_argc, LPCWSTR *service_argv)
 747 {
 748     DWORD err;
 749     LPWSTR name;
 750     HANDLE process_handle = NULL;
 751
 752     err = scmdatabase_lock_startup(service->db);
 753     if (err != ERROR_SUCCESS)
 754         return err;
 755
 756     if (service->control_pipe != INVALID_HANDLE_VALUE)
 757     {
 758         scmdatabase_unlock_startup(service->db);
 759         return ERROR_SERVICE_ALREADY_RUNNING;
 760     }
 761
 762     service->control_mutex = CreateMutexW(NULL, TRUE, NULL);
 763
 764     if (!service->status_changed_event)
 765         service->status_changed_event = CreateEventW(NULL, FALSE, FALSE, NULL);
 766     if (!service->overlapped_event)
 767         service->overlapped_event = CreateEventW(NULL, TRUE, FALSE, NULL);
 768
 769     name = service_get_pipe_name();
 770     service->control_pipe = CreateNamedPipeW(name, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
 771                   PIPE_TYPE_BYTE|PIPE_WAIT, 1, 256, 256, 10000, NULL );
 772     HeapFree(GetProcessHeap(), 0, name);
 773     if (service->control_pipe==INVALID_HANDLE_VALUE)
 774     {
 775         WINE_ERR("failed to create pipe for %s, error = %d\n",
 776             wine_dbgstr_w(service->name), GetLastError());
 777         err = GetLastError();
 778     }
 779     else
 780     {
 781         err = service_start_process(service, &process_handle);
 782         if (err == ERROR_SUCCESS)
 783         {
 784             if (!service_send_start_message(service, process_handle, service_argv, service_argc))
 785                 err = ERROR_SERVICE_REQUEST_TIMEOUT;
 786         }
 787
 788         if (err == ERROR_SUCCESS)
 789             err = service_wait_for_startup(service, process_handle);
 790
 791         if (process_handle)
 792             CloseHandle(process_handle);
 793     }
 794
 795     if (err == ERROR_SUCCESS)
 796         ReleaseMutex(service->control_mutex);
 797     else
 798     {
 799         CloseHandle(service->overlapped_event);
 800         service->overlapped_event = NULL;
 801         CloseHandle(service->status_changed_event);
 802         service->status_changed_event = NULL;
 803         CloseHandle(service->control_mutex);
 804         service->control_mutex = NULL;
 805         if (service->control_pipe != INVALID_HANDLE_VALUE)
 806             CloseHandle(service->control_pipe);
 807         service->control_pipe = INVALID_HANDLE_VALUE;
 808
 809         service->status.dwProcessId = 0;
 810         service_lock_exclusive(service);
 811         service->status.dwCurrentState = SERVICE_STOPPED;
 812         service_unlock(service);
 813     }
 814     scmdatabase_unlock_startup(service->db);
 815
 816     WINE_TRACE("returning %d\n", err);
 817
 818     return err;
 819 }
 820
 821 static void load_registry_parameters(void)
 822 {
 823     static const WCHAR controlW[] =
 824         { 'S','y','s','t','e','m','\\',
 825           'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 826           'C','o','n','t','r','o','l',0 };
 827     static const WCHAR pipetimeoutW[] =
 828         {'S','e','r','v','i','c','e','s','P','i','p','e','T','i','m','e','o','u','t',0};
 829     static const WCHAR killtimeoutW[] =
 830         {'W','a','i','t','T','o','K','i','l','l','S','e','r','v','i','c','e','T','i','m','e','o','u','t',0};
 831     HKEY key;
 832     WCHAR buffer[64];
 833     DWORD type, count, val;
 834
 835     if (RegOpenKeyW( HKEY_LOCAL_MACHINE, controlW, &key )) return;
 836
 837     count = sizeof(buffer);
 838     if (!RegQueryValueExW( key, pipetimeoutW, NULL, &type, (BYTE *)buffer, &count ) &&
 839         type == REG_SZ && (val = atoiW( buffer )))
 840         service_pipe_timeout = val;
 841
 842     count = sizeof(buffer);
 843     if (!RegQueryValueExW( key, killtimeoutW, NULL, &type, (BYTE *)buffer, &count ) &&
 844         type == REG_SZ && (val = atoiW( buffer )))
 845         service_kill_timeout = val;
 846
 847     RegCloseKey( key );
 848 }
 849
 850 int main(int argc, char *argv[])
 851 {
 852     static const WCHAR svcctl_started_event[] = SVCCTL_STARTED_EVENT;
 853     DWORD err;
 854
 855     g_hStartedEvent = CreateEventW(NULL, TRUE, FALSE, svcctl_started_event);
 856     load_registry_parameters();
 857     err = scmdatabase_create(&active_database);
 858     if (err != ERROR_SUCCESS)
 859         return err;
 860     if ((err = scmdatabase_load_services(active_database)) != ERROR_SUCCESS)
 861         return err;
 862     if ((err = RPC_Init()) == ERROR_SUCCESS)
 863     {
 864         scmdatabase_autostart_services(active_database);
 865         RPC_MainLoop();
 866     }
 867     scmdatabase_destroy(active_database);
 868     return err;
 869 }