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