dlls/advapi32/service.c

   1 /*
   2  * Win32 advapi functions
   3  *
   4  * Copyright 1995 Sven Verdoolaege
   5  * Copyright 2005 Mike McCormack
   6  * Copyright 2007 Rolf Kalbermatter
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <stdarg.h>
  27 #include <string.h>
  28 #include <time.h>
  29 #include <assert.h>
  30
  31 #include "ntstatus.h"
  32 #define WIN32_NO_STATUS
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "winsvc.h"
  36 #include "winerror.h"
  37 #include "winreg.h"
  38 #include "wine/unicode.h"
  39 #include "wine/debug.h"
  40 #include "winternl.h"
  41 #include "lmcons.h"
  42 #include "lmserver.h"
  43
  44 #include "svcctl.h"
  45
  46 #include "advapi32_misc.h"
  47
  48 #include "wine/exception.h"
  49
  50 WINE_DEFAULT_DEBUG_CHANNEL(service);
  51
  52 void  __RPC_FAR * __RPC_USER MIDL_user_allocate(SIZE_T len)
  53 {
  54     return HeapAlloc(GetProcessHeap(), 0, len);
  55 }
  56
  57 void __RPC_USER MIDL_user_free(void __RPC_FAR * ptr)
  58 {
  59     HeapFree(GetProcessHeap(), 0, ptr);
  60 }
  61
  62 typedef struct service_data_t
  63 {
  64     LPHANDLER_FUNCTION_EX handler;
  65     LPVOID context;
  66     HANDLE thread;
  67     SC_HANDLE handle;
  68     SC_HANDLE full_access_handle;
  69     BOOL unicode : 1;
  70     union {
  71         LPSERVICE_MAIN_FUNCTIONA a;
  72         LPSERVICE_MAIN_FUNCTIONW w;
  73     } proc;
  74     LPWSTR args;
  75     WCHAR name[1];
  76 } service_data;
  77
  78 typedef struct dispatcher_data_t
  79 {
  80     SC_HANDLE manager;
  81     HANDLE pipe;
  82 } dispatcher_data;
  83
  84 static CRITICAL_SECTION service_cs;
  85 static CRITICAL_SECTION_DEBUG service_cs_debug =
  86 {
  87     0, 0, &service_cs,
  88     { &service_cs_debug.ProcessLocksList,
  89       &service_cs_debug.ProcessLocksList },
  90       0, 0, { (DWORD_PTR)(__FILE__ ": service_cs") }
  91 };
  92 static CRITICAL_SECTION service_cs = { &service_cs_debug, -1, 0, 0, 0, 0 };
  93
  94 static service_data **services;
  95 static unsigned int nb_services;
  96 static HANDLE service_event;
  97 static HANDLE stop_event;
  98
  99 extern HANDLE CDECL __wine_make_process_system(void);
 100
 101 /******************************************************************************
 102  * String management functions (same behaviour as strdup)
 103  * NOTE: the caller of those functions is responsible for calling HeapFree
 104  * in order to release the memory allocated by those functions.
 105  */
 106 LPWSTR SERV_dup( LPCSTR str )
 107 {
 108     UINT len;
 109     LPWSTR wstr;
 110
 111     if( !str )
 112         return NULL;
 113     len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
 114     wstr = HeapAlloc( GetProcessHeap(), 0, len*sizeof (WCHAR) );
 115     MultiByteToWideChar( CP_ACP, 0, str, -1, wstr, len );
 116     return wstr;
 117 }
 118
 119 static inline LPWSTR SERV_dupmulti(LPCSTR str)
 120 {
 121     UINT len = 0, n = 0;
 122     LPWSTR wstr;
 123
 124     if( !str )
 125         return NULL;
 126     do {
 127         len += MultiByteToWideChar( CP_ACP, 0, &str[n], -1, NULL, 0 );
 128         n += (strlen( &str[n] ) + 1);
 129     } while (str[n]);
 130     len++;
 131     n++;
 132
 133     wstr = HeapAlloc( GetProcessHeap(), 0, len*sizeof (WCHAR) );
 134     MultiByteToWideChar( CP_ACP, 0, str, n, wstr, len );
 135     return wstr;
 136 }
 137
 138 static inline DWORD multisz_cb(LPCWSTR wmultisz)
 139 {
 140     const WCHAR *wptr = wmultisz;
 141
 142     if (wmultisz == NULL)
 143         return 0;
 144
 145     while (*wptr)
 146         wptr += lstrlenW(wptr)+1;
 147     return (wptr - wmultisz + 1)*sizeof(WCHAR);
 148 }
 149
 150 /******************************************************************************
 151  * RPC connection with services.exe
 152  */
 153
 154 DECLSPEC_HIDDEN handle_t __RPC_USER MACHINE_HANDLEW_bind(MACHINE_HANDLEW MachineName)
 155 {
 156     WCHAR transport[] = SVCCTL_TRANSPORT;
 157     WCHAR endpoint[] = SVCCTL_ENDPOINT;
 158     RPC_WSTR binding_str;
 159     RPC_STATUS status;
 160     handle_t rpc_handle;
 161
 162     status = RpcStringBindingComposeW(NULL, transport, (RPC_WSTR)MachineName, endpoint, NULL, &binding_str);
 163     if (status != RPC_S_OK)
 164     {
 165         ERR("RpcStringBindingComposeW failed (%d)\n", (DWORD)status);
 166         return NULL;
 167     }
 168
 169     status = RpcBindingFromStringBindingW(binding_str, &rpc_handle);
 170     RpcStringFreeW(&binding_str);
 171
 172     if (status != RPC_S_OK)
 173     {
 174         ERR("Couldn't connect to services.exe: error code %u\n", (DWORD)status);
 175         return NULL;
 176     }
 177
 178     return rpc_handle;
 179 }
 180
 181 DECLSPEC_HIDDEN void __RPC_USER MACHINE_HANDLEW_unbind(MACHINE_HANDLEW MachineName, handle_t h)
 182 {
 183     RpcBindingFree(&h);
 184 }
 185
 186 static LONG WINAPI rpc_filter(EXCEPTION_POINTERS *eptr)
 187 {
 188     return I_RpcExceptionFilter(eptr->ExceptionRecord->ExceptionCode);
 189 }
 190
 191 static DWORD map_exception_code(DWORD exception_code)
 192 {
 193     switch (exception_code)
 194     {
 195     case RPC_X_NULL_REF_POINTER:
 196         return ERROR_INVALID_ADDRESS;
 197     case RPC_X_ENUM_VALUE_OUT_OF_RANGE:
 198     case RPC_X_BYTE_COUNT_TOO_SMALL:
 199         return ERROR_INVALID_PARAMETER;
 200     case RPC_S_INVALID_BINDING:
 201     case RPC_X_SS_IN_NULL_CONTEXT:
 202         return ERROR_INVALID_HANDLE;
 203     default:
 204         return exception_code;
 205     }
 206 }
 207
 208 /******************************************************************************
 209  * Service IPC functions
 210  */
 211 static LPWSTR service_get_pipe_name(void)
 212 {
 213     static const WCHAR format[] = { '\\','\\','.','\\','p','i','p','e','\\',
 214         'n','e','t','\\','N','t','C','o','n','t','r','o','l','P','i','p','e','%','u',0};
 215     static const WCHAR service_current_key_str[] = { 'S','Y','S','T','E','M','\\',
 216         'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 217         'C','o','n','t','r','o','l','\\',
 218         'S','e','r','v','i','c','e','C','u','r','r','e','n','t',0};
 219     LPWSTR name;
 220     DWORD len;
 221     HKEY service_current_key;
 222     DWORD service_current;
 223     LONG ret;
 224     DWORD type;
 225
 226     ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, service_current_key_str, 0,
 227         KEY_QUERY_VALUE, &service_current_key);
 228     if (ret != ERROR_SUCCESS)
 229         return NULL;
 230     len = sizeof(service_current);
 231     ret = RegQueryValueExW(service_current_key, NULL, NULL, &type,
 232         (BYTE *)&service_current, &len);
 233     RegCloseKey(service_current_key);
 234     if (ret != ERROR_SUCCESS || type != REG_DWORD)
 235         return NULL;
 236     len = sizeof(format)/sizeof(WCHAR) + 10 /* strlenW("4294967295") */;
 237     name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 238     if (!name)
 239         return NULL;
 240     snprintfW(name, len, format, service_current);
 241     return name;
 242 }
 243
 244 static HANDLE service_open_pipe(void)
 245 {
 246     LPWSTR szPipe = service_get_pipe_name();
 247     HANDLE handle = INVALID_HANDLE_VALUE;
 248
 249     do {
 250         handle = CreateFileW(szPipe, GENERIC_READ|GENERIC_WRITE,
 251                          0, NULL, OPEN_ALWAYS, 0, NULL);
 252         if (handle != INVALID_HANDLE_VALUE)
 253             break;
 254         if (GetLastError() != ERROR_PIPE_BUSY)
 255             break;
 256     } while (WaitNamedPipeW(szPipe, NMPWAIT_USE_DEFAULT_WAIT));
 257     HeapFree(GetProcessHeap(), 0, szPipe);
 258
 259     return handle;
 260 }
 261
 262 static service_data *find_service_by_name( const WCHAR *name )
 263 {
 264     unsigned int i;
 265
 266     if (nb_services == 1)  /* only one service (FIXME: should depend on OWN_PROCESS etc.) */
 267         return services[0];
 268     for (i = 0; i < nb_services; i++)
 269         if (!strcmpiW( name, services[i]->name )) return services[i];
 270     return NULL;
 271 }
 272
 273 /******************************************************************************
 274  * service_thread
 275  *
 276  * Call into the main service routine provided by StartServiceCtrlDispatcher.
 277  */
 278 static DWORD WINAPI service_thread(LPVOID arg)
 279 {
 280     service_data *info = arg;
 281     LPWSTR str = info->args;
 282     DWORD argc = 0, len = 0;
 283
 284     TRACE("%p\n", arg);
 285
 286     while (str[len])
 287     {
 288         len += strlenW(&str[len]) + 1;
 289         argc++;
 290     }
 291     len++;
 292
 293     if (info->unicode)
 294     {
 295         LPWSTR *argv, p;
 296
 297         argv = HeapAlloc(GetProcessHeap(), 0, (argc+1)*sizeof(LPWSTR));
 298         for (argc=0, p=str; *p; p += strlenW(p) + 1)
 299             argv[argc++] = p;
 300         argv[argc] = NULL;
 301
 302         info->proc.w(argc, argv);
 303         HeapFree(GetProcessHeap(), 0, argv);
 304     }
 305     else
 306     {
 307         LPSTR strA, *argv, p;
 308         DWORD lenA;
 309
 310         lenA = WideCharToMultiByte(CP_ACP,0, str, len, NULL, 0, NULL, NULL);
 311         strA = HeapAlloc(GetProcessHeap(), 0, lenA);
 312         WideCharToMultiByte(CP_ACP,0, str, len, strA, lenA, NULL, NULL);
 313
 314         argv = HeapAlloc(GetProcessHeap(), 0, (argc+1)*sizeof(LPSTR));
 315         for (argc=0, p=strA; *p; p += strlen(p) + 1)
 316             argv[argc++] = p;
 317         argv[argc] = NULL;
 318
 319         info->proc.a(argc, argv);
 320         HeapFree(GetProcessHeap(), 0, argv);
 321         HeapFree(GetProcessHeap(), 0, strA);
 322     }
 323     return 0;
 324 }
 325
 326 /******************************************************************************
 327  * service_handle_start
 328  */
 329 static DWORD service_handle_start(service_data *service, const WCHAR *data, DWORD count)
 330 {
 331     TRACE("%s argsize %u\n", debugstr_w(service->name), count);
 332
 333     if (service->thread)
 334     {
 335         WARN("service is not stopped\n");
 336         return ERROR_SERVICE_ALREADY_RUNNING;
 337     }
 338
 339     HeapFree(GetProcessHeap(), 0, service->args);
 340     service->args = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WCHAR));
 341     memcpy( service->args, data, count * sizeof(WCHAR) );
 342     service->thread = CreateThread( NULL, 0, service_thread,
 343                                     service, 0, NULL );
 344     SetEvent( service_event );  /* notify the main loop */
 345     return 0;
 346 }
 347
 348 /******************************************************************************
 349  * service_handle_control
 350  */
 351 static DWORD service_handle_control(const service_data *service, DWORD dwControl)
 352 {
 353     DWORD ret = ERROR_INVALID_SERVICE_CONTROL;
 354
 355     TRACE("%s control %u\n", debugstr_w(service->name), dwControl);
 356
 357     if (service->handler)
 358         ret = service->handler(dwControl, 0, NULL, service->context);
 359     return ret;
 360 }
 361
 362 /******************************************************************************
 363  * service_control_dispatcher
 364  */
 365 static DWORD WINAPI service_control_dispatcher(LPVOID arg)
 366 {
 367     dispatcher_data *disp = arg;
 368
 369     /* dispatcher loop */
 370     while (1)
 371     {
 372         service_data *service;
 373         service_start_info info;
 374         WCHAR *data = NULL;
 375         BOOL r;
 376         DWORD data_size = 0, count, result;
 377
 378         r = ReadFile( disp->pipe, &info, FIELD_OFFSET(service_start_info,data), &count, NULL );
 379         if (!r)
 380         {
 381             if (GetLastError() != ERROR_BROKEN_PIPE)
 382                 ERR( "pipe read failed error %u\n", GetLastError() );
 383             break;
 384         }
 385         if (count != FIELD_OFFSET(service_start_info,data))
 386         {
 387             ERR( "partial pipe read %u\n", count );
 388             break;
 389         }
 390         if (count < info.total_size)
 391         {
 392             data_size = info.total_size - FIELD_OFFSET(service_start_info,data);
 393             data = HeapAlloc( GetProcessHeap(), 0, data_size );
 394             r = ReadFile( disp->pipe, data, data_size, &count, NULL );
 395             if (!r)
 396             {
 397                 if (GetLastError() != ERROR_BROKEN_PIPE)
 398                     ERR( "pipe read failed error %u\n", GetLastError() );
 399                 HeapFree( GetProcessHeap(), 0, data );
 400                 break;
 401             }
 402             if (count != data_size)
 403             {
 404                 ERR( "partial pipe read %u/%u\n", count, data_size );
 405                 HeapFree( GetProcessHeap(), 0, data );
 406                 break;
 407             }
 408         }
 409
 410         /* find the service */
 411
 412         if (!(service = find_service_by_name( data )))
 413         {
 414             FIXME( "got request %u for unknown service %s\n", info.cmd, debugstr_w(data));
 415             result = ERROR_INVALID_PARAMETER;
 416             goto done;
 417         }
 418
 419         TRACE( "got request %u for service %s\n", info.cmd, debugstr_w(data) );
 420
 421         /* handle the request */
 422         switch (info.cmd)
 423         {
 424         case WINESERV_STARTINFO:
 425             if (!service->handle)
 426             {
 427                 if (!(service->handle = OpenServiceW( disp->manager, data, SERVICE_SET_STATUS )) ||
 428                     !(service->full_access_handle = OpenServiceW( disp->manager, data,
 429                             GENERIC_READ|GENERIC_WRITE )))
 430                     FIXME( "failed to open service %s\n", debugstr_w(data) );
 431             }
 432             result = service_handle_start(service, data, data_size / sizeof(WCHAR));
 433             break;
 434         case WINESERV_SENDCONTROL:
 435             result = service_handle_control(service, info.control);
 436             break;
 437         default:
 438             ERR("received invalid command %u\n", info.cmd);
 439             result = ERROR_INVALID_PARAMETER;
 440             break;
 441         }
 442
 443     done:
 444         WriteFile( disp->pipe, &result, sizeof(result), &count, NULL );
 445         HeapFree( GetProcessHeap(), 0, data );
 446     }
 447
 448     CloseHandle( disp->pipe );
 449     CloseServiceHandle( disp->manager );
 450     HeapFree( GetProcessHeap(), 0, disp );
 451     return 1;
 452 }
 453
 454 /******************************************************************************
 455  * service_run_main_thread
 456  */
 457 static BOOL service_run_main_thread(void)
 458 {
 459     DWORD i, n, ret;
 460     HANDLE wait_handles[MAXIMUM_WAIT_OBJECTS];
 461     UINT wait_services[MAXIMUM_WAIT_OBJECTS];
 462     dispatcher_data *disp = HeapAlloc( GetProcessHeap(), 0, sizeof(*disp) );
 463
 464     disp->manager = OpenSCManagerW( NULL, NULL, SC_MANAGER_CONNECT );
 465     if (!disp->manager)
 466     {
 467         ERR("failed to open service manager error %u\n", GetLastError());
 468         HeapFree( GetProcessHeap(), 0, disp );
 469         return FALSE;
 470     }
 471
 472     disp->pipe = service_open_pipe();
 473     if (disp->pipe == INVALID_HANDLE_VALUE)
 474     {
 475         WARN("failed to create control pipe error %u\n", GetLastError());
 476         CloseServiceHandle( disp->manager );
 477         HeapFree( GetProcessHeap(), 0, disp );
 478         SetLastError( ERROR_FAILED_SERVICE_CONTROLLER_CONNECT );
 479         return FALSE;
 480     }
 481
 482     service_event = CreateEventW( NULL, FALSE, FALSE, NULL );
 483     stop_event = CreateEventW( NULL, FALSE, FALSE, NULL );
 484
 485     /* FIXME: service_control_dispatcher should be merged into the main thread */
 486     wait_handles[0] = __wine_make_process_system();
 487     wait_handles[1] = CreateThread( NULL, 0, service_control_dispatcher, disp, 0, NULL );
 488     wait_handles[2] = service_event;
 489     wait_handles[3] = stop_event;
 490
 491     TRACE("Starting %d services running as process %d\n",
 492           nb_services, GetCurrentProcessId());
 493
 494     /* wait for all the threads to pack up and exit */
 495     for (;;)
 496     {
 497         EnterCriticalSection( &service_cs );
 498         for (i = 0, n = 4; i < nb_services && n < MAXIMUM_WAIT_OBJECTS; i++)
 499         {
 500             if (!services[i]->thread) continue;
 501             wait_services[n] = i;
 502             wait_handles[n++] = services[i]->thread;
 503         }
 504         LeaveCriticalSection( &service_cs );
 505
 506         ret = WaitForMultipleObjects( n, wait_handles, FALSE, INFINITE );
 507         if (!ret)  /* system process event */
 508         {
 509             SERVICE_STATUS st;
 510             SERVICE_PRESHUTDOWN_INFO spi;
 511             DWORD timeout = 5000;
 512             BOOL res;
 513
 514             EnterCriticalSection( &service_cs );
 515             n = 0;
 516             for (i = 0; i < nb_services && n < MAXIMUM_WAIT_OBJECTS; i++)
 517             {
 518                 if (!services[i]->thread) continue;
 519
 520                 res = QueryServiceStatus(services[i]->full_access_handle, &st);
 521                 ret = ERROR_SUCCESS;
 522                 if (res && (st.dwControlsAccepted & SERVICE_ACCEPT_PRESHUTDOWN))
 523                 {
 524                     res = QueryServiceConfig2W( services[i]->full_access_handle, SERVICE_CONFIG_PRESHUTDOWN_INFO,
 525                             (LPBYTE)&spi, sizeof(spi), &i );
 526                     if (res)
 527                     {
 528                         FIXME("service should be able to delay shutdown\n");
 529                         timeout += spi.dwPreshutdownTimeout;
 530                         ret = service_handle_control( services[i], SERVICE_CONTROL_PRESHUTDOWN );
 531                         wait_handles[n++] = services[i]->thread;
 532                     }
 533                 }
 534                 else if (res && (st.dwControlsAccepted & SERVICE_ACCEPT_SHUTDOWN))
 535                 {
 536                     ret = service_handle_control( services[i], SERVICE_CONTROL_SHUTDOWN );
 537                     wait_handles[n++] = services[i]->thread;
 538                 }
 539             }
 540             LeaveCriticalSection( &service_cs );
 541
 542             TRACE("last user process exited, shutting down (timeout: %d)\n", timeout);
 543             WaitForMultipleObjects( n, wait_handles, TRUE, timeout );
 544             ExitProcess(0);
 545         }
 546         else if (ret == 1)
 547         {
 548             TRACE( "control dispatcher exited, shutting down\n" );
 549             /* FIXME: we should maybe send a shutdown control to running services */
 550             ExitProcess(0);
 551         }
 552         else if (ret == 2)
 553         {
 554             continue;  /* rebuild the list */
 555         }
 556         else if (ret == 3)
 557         {
 558             return TRUE;
 559         }
 560         else if (ret < n)
 561         {
 562             services[wait_services[ret]]->thread = 0;
 563             CloseHandle( wait_handles[ret] );
 564         }
 565         else return FALSE;
 566     }
 567 }
 568
 569 /******************************************************************************
 570  * StartServiceCtrlDispatcherA [ADVAPI32.@]
 571  *
 572  * See StartServiceCtrlDispatcherW.
 573  */
 574 BOOL WINAPI StartServiceCtrlDispatcherA( const SERVICE_TABLE_ENTRYA *servent )
 575 {
 576     service_data *info;
 577     unsigned int i;
 578
 579     TRACE("%p\n", servent);
 580
 581     if (nb_services)
 582     {
 583         SetLastError( ERROR_SERVICE_ALREADY_RUNNING );
 584         return FALSE;
 585     }
 586     while (servent[nb_services].lpServiceName) nb_services++;
 587     if (!nb_services)
 588     {
 589         SetLastError( ERROR_INVALID_PARAMETER );
 590         return FALSE;
 591     }
 592
 593     services = HeapAlloc( GetProcessHeap(), 0, nb_services * sizeof(*services) );
 594
 595     for (i = 0; i < nb_services; i++)
 596     {
 597         DWORD len = MultiByteToWideChar(CP_ACP, 0, servent[i].lpServiceName, -1, NULL, 0);
 598         DWORD sz = FIELD_OFFSET( service_data, name[len] );
 599         info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz );
 600         MultiByteToWideChar(CP_ACP, 0, servent[i].lpServiceName, -1, info->name, len);
 601         info->proc.a = servent[i].lpServiceProc;
 602         info->unicode = FALSE;
 603         services[i] = info;
 604     }
 605
 606     return service_run_main_thread();
 607 }
 608
 609 /******************************************************************************
 610  * StartServiceCtrlDispatcherW [ADVAPI32.@]
 611  *
 612  *  Connects a process containing one or more services to the service control
 613  * manager.
 614  *
 615  * PARAMS
 616  *   servent [I]  A list of the service names and service procedures
 617  *
 618  * RETURNS
 619  *  Success: TRUE.
 620  *  Failure: FALSE.
 621  */
 622 BOOL WINAPI StartServiceCtrlDispatcherW( const SERVICE_TABLE_ENTRYW *servent )
 623 {
 624     service_data *info;
 625     unsigned int i;
 626
 627     TRACE("%p\n", servent);
 628
 629     if (nb_services)
 630     {
 631         SetLastError( ERROR_SERVICE_ALREADY_RUNNING );
 632         return FALSE;
 633     }
 634     while (servent[nb_services].lpServiceName) nb_services++;
 635     if (!nb_services)
 636     {
 637         SetLastError( ERROR_INVALID_PARAMETER );
 638         return FALSE;
 639     }
 640
 641     services = HeapAlloc( GetProcessHeap(), 0, nb_services * sizeof(*services) );
 642
 643     for (i = 0; i < nb_services; i++)
 644     {
 645         DWORD len = strlenW(servent[i].lpServiceName) + 1;
 646         DWORD sz = FIELD_OFFSET( service_data, name[len] );
 647         info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz );
 648         strcpyW(info->name, servent[i].lpServiceName);
 649         info->proc.w = servent[i].lpServiceProc;
 650         info->unicode = TRUE;
 651         services[i] = info;
 652     }
 653
 654     return service_run_main_thread();
 655 }
 656
 657 /******************************************************************************
 658  * LockServiceDatabase  [ADVAPI32.@]
 659  */
 660 SC_LOCK WINAPI LockServiceDatabase (SC_HANDLE hSCManager)
 661 {
 662     SC_RPC_LOCK hLock = NULL;
 663     DWORD err;
 664
 665     TRACE("%p\n",hSCManager);
 666
 667     __TRY
 668     {
 669         err = svcctl_LockServiceDatabase(hSCManager, &hLock);
 670     }
 671     __EXCEPT(rpc_filter)
 672     {
 673         err = map_exception_code(GetExceptionCode());
 674     }
 675     __ENDTRY
 676     if (err != ERROR_SUCCESS)
 677     {
 678         SetLastError(err);
 679         return NULL;
 680     }
 681     return hLock;
 682 }
 683
 684 /******************************************************************************
 685  * UnlockServiceDatabase  [ADVAPI32.@]
 686  */
 687 BOOL WINAPI UnlockServiceDatabase (SC_LOCK ScLock)
 688 {
 689     DWORD err;
 690     SC_RPC_LOCK hRpcLock = ScLock;
 691
 692     TRACE("%p\n",ScLock);
 693
 694     __TRY
 695     {
 696         err = svcctl_UnlockServiceDatabase(&hRpcLock);
 697     }
 698     __EXCEPT(rpc_filter)
 699     {
 700         err = map_exception_code(GetExceptionCode());
 701     }
 702     __ENDTRY
 703     if (err != ERROR_SUCCESS)
 704     {
 705         SetLastError(err);
 706         return FALSE;
 707     }
 708     return TRUE;
 709 }
 710
 711 /******************************************************************************
 712  * SetServiceStatus [ADVAPI32.@]
 713  *
 714  * PARAMS
 715  *   hService []
 716  *   lpStatus []
 717  */
 718 BOOL WINAPI
 719 SetServiceStatus( SERVICE_STATUS_HANDLE hService, LPSERVICE_STATUS lpStatus )
 720 {
 721     DWORD err;
 722
 723     TRACE("%p %x %x %x %x %x %x %x\n", hService,
 724           lpStatus->dwServiceType, lpStatus->dwCurrentState,
 725           lpStatus->dwControlsAccepted, lpStatus->dwWin32ExitCode,
 726           lpStatus->dwServiceSpecificExitCode, lpStatus->dwCheckPoint,
 727           lpStatus->dwWaitHint);
 728
 729     __TRY
 730     {
 731         err = svcctl_SetServiceStatus( hService, lpStatus );
 732     }
 733     __EXCEPT(rpc_filter)
 734     {
 735         err = map_exception_code(GetExceptionCode());
 736     }
 737     __ENDTRY
 738     if (err != ERROR_SUCCESS)
 739     {
 740         SetLastError(err);
 741         return FALSE;
 742     }
 743
 744     if (lpStatus->dwCurrentState == SERVICE_STOPPED) {
 745         SetEvent(stop_event);
 746         CloseServiceHandle((SC_HANDLE)hService);
 747     }
 748
 749     return TRUE;
 750 }
 751
 752
 753 /******************************************************************************
 754  * OpenSCManagerA [ADVAPI32.@]
 755  *
 756  * Establish a connection to the service control manager and open its database.
 757  *
 758  * PARAMS
 759  *   lpMachineName   [I] Pointer to machine name string
 760  *   lpDatabaseName  [I] Pointer to database name string
 761  *   dwDesiredAccess [I] Type of access
 762  *
 763  * RETURNS
 764  *   Success: A Handle to the service control manager database
 765  *   Failure: NULL
 766  */
 767 SC_HANDLE WINAPI OpenSCManagerA( LPCSTR lpMachineName, LPCSTR lpDatabaseName,
 768                                  DWORD dwDesiredAccess )
 769 {
 770     LPWSTR lpMachineNameW, lpDatabaseNameW;
 771     SC_HANDLE ret;
 772
 773     lpMachineNameW = SERV_dup(lpMachineName);
 774     lpDatabaseNameW = SERV_dup(lpDatabaseName);
 775     ret = OpenSCManagerW(lpMachineNameW, lpDatabaseNameW, dwDesiredAccess);
 776     HeapFree(GetProcessHeap(), 0, lpDatabaseNameW);
 777     HeapFree(GetProcessHeap(), 0, lpMachineNameW);
 778     return ret;
 779 }
 780
 781 /******************************************************************************
 782  * OpenSCManagerW [ADVAPI32.@]
 783  *
 784  * See OpenSCManagerA.
 785  */
 786 DWORD SERV_OpenSCManagerW( LPCWSTR lpMachineName, LPCWSTR lpDatabaseName,
 787                            DWORD dwDesiredAccess, SC_HANDLE *handle )
 788 {
 789     DWORD r;
 790
 791     TRACE("(%s,%s,0x%08x)\n", debugstr_w(lpMachineName),
 792           debugstr_w(lpDatabaseName), dwDesiredAccess);
 793
 794     __TRY
 795     {
 796         r = svcctl_OpenSCManagerW(lpMachineName, lpDatabaseName, dwDesiredAccess, (SC_RPC_HANDLE *)handle);
 797     }
 798     __EXCEPT(rpc_filter)
 799     {
 800         r = map_exception_code(GetExceptionCode());
 801     }
 802     __ENDTRY
 803
 804     if (r!=ERROR_SUCCESS)
 805         *handle = 0;
 806
 807     TRACE("returning %p\n", *handle);
 808     return r;
 809 }
 810
 811 SC_HANDLE WINAPI OpenSCManagerW( LPCWSTR lpMachineName, LPCWSTR lpDatabaseName,
 812                                  DWORD dwDesiredAccess )
 813 {
 814     SC_HANDLE handle = 0;
 815     DWORD r;
 816
 817     r = SERV_OpenSCManagerW(lpMachineName, lpDatabaseName, dwDesiredAccess, &handle);
 818     if (r!=ERROR_SUCCESS)
 819         SetLastError(r);
 820     return handle;
 821 }
 822
 823 /******************************************************************************
 824  * ControlService [ADVAPI32.@]
 825  *
 826  * Send a control code to a service.
 827  *
 828  * PARAMS
 829  *   hService        [I] Handle of the service control manager database
 830  *   dwControl       [I] Control code to send (SERVICE_CONTROL_* flags from "winsvc.h")
 831  *   lpServiceStatus [O] Destination for the status of the service, if available
 832  *
 833  * RETURNS
 834  *   Success: TRUE.
 835  *   Failure: FALSE.
 836  *
 837  * BUGS
 838  *   Unlike M$' implementation, control requests are not serialized and may be
 839  *   processed asynchronously.
 840  */
 841 BOOL WINAPI ControlService( SC_HANDLE hService, DWORD dwControl,
 842                             LPSERVICE_STATUS lpServiceStatus )
 843 {
 844     DWORD err;
 845
 846     TRACE("%p %d %p\n", hService, dwControl, lpServiceStatus);
 847
 848     __TRY
 849     {
 850         err = svcctl_ControlService(hService, dwControl, lpServiceStatus);
 851     }
 852     __EXCEPT(rpc_filter)
 853     {
 854         err = map_exception_code(GetExceptionCode());
 855     }
 856     __ENDTRY
 857     if (err != ERROR_SUCCESS)
 858     {
 859         SetLastError(err);
 860         return FALSE;
 861     }
 862
 863     return TRUE;
 864 }
 865
 866 /******************************************************************************
 867  * CloseServiceHandle [ADVAPI32.@]
 868  *
 869  * Close a handle to a service or the service control manager database.
 870  *
 871  * PARAMS
 872  *   hSCObject [I] Handle to service or service control manager database
 873  *
 874  * RETURNS
 875  *  Success: TRUE
 876  *  Failure: FALSE
 877  */
 878 BOOL WINAPI
 879 CloseServiceHandle( SC_HANDLE hSCObject )
 880 {
 881     DWORD err;
 882
 883     TRACE("%p\n", hSCObject);
 884
 885     __TRY
 886     {
 887         err = svcctl_CloseServiceHandle((SC_RPC_HANDLE *)&hSCObject);
 888     }
 889     __EXCEPT(rpc_filter)
 890     {
 891         err = map_exception_code(GetExceptionCode());
 892     }
 893     __ENDTRY
 894
 895     if (err != ERROR_SUCCESS)
 896     {
 897         SetLastError(err);
 898         return FALSE;
 899     }
 900     return TRUE;
 901 }
 902
 903
 904 /******************************************************************************
 905  * OpenServiceA [ADVAPI32.@]
 906  *
 907  * Open a handle to a service.
 908  *
 909  * PARAMS
 910  *   hSCManager      [I] Handle of the service control manager database
 911  *   lpServiceName   [I] Name of the service to open
 912  *   dwDesiredAccess [I] Access required to the service
 913  *
 914  * RETURNS
 915  *    Success: Handle to the service
 916  *    Failure: NULL
 917  */
 918 SC_HANDLE WINAPI OpenServiceA( SC_HANDLE hSCManager, LPCSTR lpServiceName,
 919                                DWORD dwDesiredAccess )
 920 {
 921     LPWSTR lpServiceNameW;
 922     SC_HANDLE ret;
 923
 924     TRACE("%p %s %d\n", hSCManager, debugstr_a(lpServiceName), dwDesiredAccess);
 925
 926     lpServiceNameW = SERV_dup(lpServiceName);
 927     ret = OpenServiceW( hSCManager, lpServiceNameW, dwDesiredAccess);
 928     HeapFree(GetProcessHeap(), 0, lpServiceNameW);
 929     return ret;
 930 }
 931
 932
 933 /******************************************************************************
 934  * OpenServiceW [ADVAPI32.@]
 935  *
 936  * See OpenServiceA.
 937  */
 938 DWORD SERV_OpenServiceW( SC_HANDLE hSCManager, LPCWSTR lpServiceName,
 939                          DWORD dwDesiredAccess, SC_HANDLE *handle )
 940 {
 941     DWORD err;
 942
 943     TRACE("%p %s %d\n", hSCManager, debugstr_w(lpServiceName), dwDesiredAccess);
 944
 945     if (!hSCManager)
 946         return ERROR_INVALID_HANDLE;
 947
 948     __TRY
 949     {
 950         err = svcctl_OpenServiceW(hSCManager, lpServiceName, dwDesiredAccess, (SC_RPC_HANDLE *)handle);
 951     }
 952     __EXCEPT(rpc_filter)
 953     {
 954         err = map_exception_code(GetExceptionCode());
 955     }
 956     __ENDTRY
 957
 958     if (err != ERROR_SUCCESS)
 959         *handle = 0;
 960
 961     TRACE("returning %p\n", *handle);
 962     return err;
 963 }
 964
 965 SC_HANDLE WINAPI OpenServiceW( SC_HANDLE hSCManager, LPCWSTR lpServiceName,
 966                                DWORD dwDesiredAccess)
 967 {
 968     SC_HANDLE handle = 0;
 969     DWORD err;
 970
 971     err = SERV_OpenServiceW(hSCManager, lpServiceName, dwDesiredAccess, &handle);
 972     if (err != ERROR_SUCCESS)
 973         SetLastError(err);
 974     return handle;
 975 }
 976
 977 /******************************************************************************
 978  * CreateServiceW [ADVAPI32.@]
 979  */
 980 SC_HANDLE WINAPI
 981 CreateServiceW( SC_HANDLE hSCManager, LPCWSTR lpServiceName,
 982                   LPCWSTR lpDisplayName, DWORD dwDesiredAccess,
 983                   DWORD dwServiceType, DWORD dwStartType,
 984                   DWORD dwErrorControl, LPCWSTR lpBinaryPathName,
 985                   LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId,
 986                   LPCWSTR lpDependencies, LPCWSTR lpServiceStartName,
 987                   LPCWSTR lpPassword )
 988 {
 989     SC_HANDLE handle = 0;
 990     DWORD err;
 991     SIZE_T passwdlen;
 992
 993     TRACE("%p %s %s\n", hSCManager,
 994           debugstr_w(lpServiceName), debugstr_w(lpDisplayName));
 995
 996     if (!hSCManager)
 997     {
 998         SetLastError( ERROR_INVALID_HANDLE );
 999         return 0;
1000     }
1001
1002     if (lpPassword)
1003         passwdlen = (strlenW(lpPassword) + 1) * sizeof(WCHAR);
1004     else
1005         passwdlen = 0;
1006
1007     __TRY
1008     {
1009         err = svcctl_CreateServiceW(hSCManager, lpServiceName,
1010                 lpDisplayName, dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
1011                 lpBinaryPathName, lpLoadOrderGroup, lpdwTagId, (const BYTE*)lpDependencies,
1012                 multisz_cb(lpDependencies), lpServiceStartName, (const BYTE*)lpPassword, passwdlen,
1013                 (SC_RPC_HANDLE *)&handle);
1014     }
1015     __EXCEPT(rpc_filter)
1016     {
1017         err = map_exception_code(GetExceptionCode());
1018     }
1019     __ENDTRY
1020
1021     if (err != ERROR_SUCCESS)
1022     {
1023         SetLastError(err);
1024         handle = 0;
1025     }
1026     return handle;
1027 }
1028
1029
1030 /******************************************************************************
1031  * CreateServiceA [ADVAPI32.@]
1032  */
1033 SC_HANDLE WINAPI
1034 CreateServiceA( SC_HANDLE hSCManager, LPCSTR lpServiceName,
1035                   LPCSTR lpDisplayName, DWORD dwDesiredAccess,
1036                   DWORD dwServiceType, DWORD dwStartType,
1037                   DWORD dwErrorControl, LPCSTR lpBinaryPathName,
1038                   LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId,
1039                   LPCSTR lpDependencies, LPCSTR lpServiceStartName,
1040                   LPCSTR lpPassword )
1041 {
1042     LPWSTR lpServiceNameW, lpDisplayNameW, lpBinaryPathNameW,
1043         lpLoadOrderGroupW, lpDependenciesW, lpServiceStartNameW, lpPasswordW;
1044     SC_HANDLE r;
1045
1046     TRACE("%p %s %s\n", hSCManager,
1047           debugstr_a(lpServiceName), debugstr_a(lpDisplayName));
1048
1049     lpServiceNameW = SERV_dup( lpServiceName );
1050     lpDisplayNameW = SERV_dup( lpDisplayName );
1051     lpBinaryPathNameW = SERV_dup( lpBinaryPathName );
1052     lpLoadOrderGroupW = SERV_dup( lpLoadOrderGroup );
1053     lpDependenciesW = SERV_dupmulti( lpDependencies );
1054     lpServiceStartNameW = SERV_dup( lpServiceStartName );
1055     lpPasswordW = SERV_dup( lpPassword );
1056
1057     r = CreateServiceW( hSCManager, lpServiceNameW, lpDisplayNameW,
1058             dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
1059             lpBinaryPathNameW, lpLoadOrderGroupW, lpdwTagId,
1060             lpDependenciesW, lpServiceStartNameW, lpPasswordW );
1061
1062     HeapFree( GetProcessHeap(), 0, lpServiceNameW );
1063     HeapFree( GetProcessHeap(), 0, lpDisplayNameW );
1064     HeapFree( GetProcessHeap(), 0, lpBinaryPathNameW );
1065     HeapFree( GetProcessHeap(), 0, lpLoadOrderGroupW );
1066     HeapFree( GetProcessHeap(), 0, lpDependenciesW );
1067     HeapFree( GetProcessHeap(), 0, lpServiceStartNameW );
1068     HeapFree( GetProcessHeap(), 0, lpPasswordW );
1069
1070     return r;
1071 }
1072
1073
1074 /******************************************************************************
1075  * DeleteService [ADVAPI32.@]
1076  *
1077  * Delete a service from the service control manager database.
1078  *
1079  * PARAMS
1080  *    hService [I] Handle of the service to delete
1081  *
1082  * RETURNS
1083  *  Success: TRUE
1084  *  Failure: FALSE
1085  */
1086 BOOL WINAPI DeleteService( SC_HANDLE hService )
1087 {
1088     DWORD err;
1089
1090     TRACE("%p\n", hService);
1091
1092     __TRY
1093     {
1094         err = svcctl_DeleteService(hService);
1095     }
1096     __EXCEPT(rpc_filter)
1097     {
1098         err = map_exception_code(GetExceptionCode());
1099     }
1100     __ENDTRY
1101     if (err != 0)
1102     {
1103         SetLastError(err);
1104         return FALSE;
1105     }
1106
1107     return TRUE;
1108 }
1109
1110
1111 /******************************************************************************
1112  * StartServiceA [ADVAPI32.@]
1113  *
1114  * Start a service
1115  *
1116  * PARAMS
1117  *   hService            [I] Handle of service
1118  *   dwNumServiceArgs    [I] Number of arguments
1119  *   lpServiceArgVectors [I] Address of array of argument strings
1120  *
1121  * NOTES
1122  *  - NT implements this function using an obscure RPC call.
1123  *  - You might need to do a "setenv SystemRoot \\WINNT" in your .cshrc
1124  *    to get things like "%SystemRoot%\\System32\\service.exe" to load.
1125  *  - This will only work for shared address space. How should the service
1126  *    args be transferred when address spaces are separated?
1127  *  - Can only start one service at a time.
1128  *  - Has no concept of privilege.
1129  *
1130  * RETURNS
1131  *   Success: TRUE.
1132  *   Failure: FALSE
1133  */
1134 BOOL WINAPI StartServiceA( SC_HANDLE hService, DWORD dwNumServiceArgs,
1135                            LPCSTR *lpServiceArgVectors )
1136 {
1137     LPWSTR *lpwstr=NULL;
1138     unsigned int i;
1139     BOOL r;
1140
1141     TRACE("(%p,%d,%p)\n",hService,dwNumServiceArgs,lpServiceArgVectors);
1142
1143     if (dwNumServiceArgs)
1144         lpwstr = HeapAlloc( GetProcessHeap(), 0,
1145                                    dwNumServiceArgs*sizeof(LPWSTR) );
1146
1147     for(i=0; i<dwNumServiceArgs; i++)
1148         lpwstr[i]=SERV_dup(lpServiceArgVectors[i]);
1149
1150     r = StartServiceW(hService, dwNumServiceArgs, (LPCWSTR *)lpwstr);
1151
1152     if (dwNumServiceArgs)
1153     {
1154         for(i=0; i<dwNumServiceArgs; i++)
1155             HeapFree(GetProcessHeap(), 0, lpwstr[i]);
1156         HeapFree(GetProcessHeap(), 0, lpwstr);
1157     }
1158
1159     return r;
1160 }
1161
1162
1163 /******************************************************************************
1164  * StartServiceW [ADVAPI32.@]
1165  *
1166  * See StartServiceA.
1167  */
1168 BOOL WINAPI StartServiceW(SC_HANDLE hService, DWORD dwNumServiceArgs,
1169                           LPCWSTR *lpServiceArgVectors)
1170 {
1171     DWORD err;
1172
1173     TRACE("%p %d %p\n", hService, dwNumServiceArgs, lpServiceArgVectors);
1174
1175     __TRY
1176     {
1177         err = svcctl_StartServiceW(hService, dwNumServiceArgs, lpServiceArgVectors);
1178     }
1179     __EXCEPT(rpc_filter)
1180     {
1181         err = map_exception_code(GetExceptionCode());
1182     }
1183     __ENDTRY
1184     if (err != ERROR_SUCCESS)
1185     {
1186         SetLastError(err);
1187         return FALSE;
1188     }
1189
1190     return TRUE;
1191 }
1192
1193 /******************************************************************************
1194  * QueryServiceStatus [ADVAPI32.@]
1195  *
1196  * PARAMS
1197  *   hService        [I] Handle to service to get information about
1198  *   lpservicestatus [O] buffer to receive the status information for the service
1199  *
1200  */
1201 BOOL WINAPI QueryServiceStatus(SC_HANDLE hService,
1202                                LPSERVICE_STATUS lpservicestatus)
1203 {
1204     SERVICE_STATUS_PROCESS SvcStatusData;
1205     BOOL ret;
1206     DWORD dummy;
1207
1208     TRACE("%p %p\n", hService, lpservicestatus);
1209
1210     if (!hService)
1211     {
1212         SetLastError(ERROR_INVALID_HANDLE);
1213         return FALSE;
1214     }
1215     if (!lpservicestatus)
1216     {
1217         SetLastError(ERROR_INVALID_ADDRESS);
1218         return FALSE;
1219     }
1220
1221     ret = QueryServiceStatusEx(hService, SC_STATUS_PROCESS_INFO, (LPBYTE)&SvcStatusData,
1222                                 sizeof(SERVICE_STATUS_PROCESS), &dummy);
1223     if (ret) memcpy(lpservicestatus, &SvcStatusData, sizeof(SERVICE_STATUS)) ;
1224     return ret;
1225 }
1226
1227
1228 /******************************************************************************
1229  * QueryServiceStatusEx [ADVAPI32.@]
1230  *
1231  * Get information about a service.
1232  *
1233  * PARAMS
1234  *   hService       [I] Handle to service to get information about
1235  *   InfoLevel      [I] Level of information to get
1236  *   lpBuffer       [O] Destination for requested information
1237  *   cbBufSize      [I] Size of lpBuffer in bytes
1238  *   pcbBytesNeeded [O] Destination for number of bytes needed, if cbBufSize is too small
1239  *
1240  * RETURNS
1241  *  Success: TRUE
1242  *  FAILURE: FALSE
1243  */
1244 BOOL WINAPI QueryServiceStatusEx(SC_HANDLE hService, SC_STATUS_TYPE InfoLevel,
1245                         LPBYTE lpBuffer, DWORD cbBufSize,
1246                         LPDWORD pcbBytesNeeded)
1247 {
1248     DWORD err;
1249
1250     TRACE("%p %d %p %d %p\n", hService, InfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
1251
1252     if (InfoLevel != SC_STATUS_PROCESS_INFO)
1253     {
1254         err = ERROR_INVALID_LEVEL;
1255     }
1256     else if (cbBufSize < sizeof(SERVICE_STATUS_PROCESS))
1257     {
1258         *pcbBytesNeeded = sizeof(SERVICE_STATUS_PROCESS);
1259         err = ERROR_INSUFFICIENT_BUFFER;
1260     }
1261     else
1262     {
1263         __TRY
1264         {
1265             err = svcctl_QueryServiceStatusEx(hService, InfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
1266         }
1267         __EXCEPT(rpc_filter)
1268         {
1269             err = map_exception_code(GetExceptionCode());
1270         }
1271         __ENDTRY
1272     }
1273     if (err != ERROR_SUCCESS)
1274     {
1275         SetLastError(err);
1276         return FALSE;
1277     }
1278     return TRUE;
1279 }
1280
1281 /******************************************************************************
1282  * QueryServiceConfigA [ADVAPI32.@]
1283  */
1284 BOOL WINAPI QueryServiceConfigA( SC_HANDLE hService, LPQUERY_SERVICE_CONFIGA config,
1285                                  DWORD size, LPDWORD needed )
1286 {
1287     DWORD n;
1288     LPSTR p, buffer;
1289     BOOL ret;
1290     QUERY_SERVICE_CONFIGW *configW;
1291
1292     TRACE("%p %p %d %p\n", hService, config, size, needed);
1293
1294     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, 2 * size )))
1295     {
1296         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1297         return FALSE;
1298     }
1299     configW = (QUERY_SERVICE_CONFIGW *)buffer;
1300     ret = QueryServiceConfigW( hService, configW, 2 * size, needed );
1301     if (!ret) goto done;
1302
1303     config->dwServiceType      = configW->dwServiceType;
1304     config->dwStartType        = configW->dwStartType;
1305     config->dwErrorControl     = configW->dwErrorControl;
1306     config->lpBinaryPathName   = NULL;
1307     config->lpLoadOrderGroup   = NULL;
1308     config->dwTagId            = configW->dwTagId;
1309     config->lpDependencies     = NULL;
1310     config->lpServiceStartName = NULL;
1311     config->lpDisplayName      = NULL;
1312
1313     p = (LPSTR)(config + 1);
1314     n = size - sizeof(*config);
1315     ret = FALSE;
1316
1317 #define MAP_STR(str) \
1318     do { \
1319         if (configW->str) \
1320         { \
1321             DWORD sz = WideCharToMultiByte( CP_ACP, 0, configW->str, -1, p, n, NULL, NULL ); \
1322             if (!sz) goto done; \
1323             config->str = p; \
1324             p += sz; \
1325             n -= sz; \
1326         } \
1327     } while (0)
1328
1329     MAP_STR( lpBinaryPathName );
1330     MAP_STR( lpLoadOrderGroup );
1331     MAP_STR( lpDependencies );
1332     MAP_STR( lpServiceStartName );
1333     MAP_STR( lpDisplayName );
1334 #undef MAP_STR
1335
1336     *needed = p - (LPSTR)config;
1337     ret = TRUE;
1338
1339 done:
1340     HeapFree( GetProcessHeap(), 0, buffer );
1341     return ret;
1342 }
1343
1344 static DWORD move_string_to_buffer(BYTE **buf, LPWSTR *string_ptr)
1345 {
1346     DWORD cb;
1347
1348     if (!*string_ptr)
1349     {
1350         cb = sizeof(WCHAR);
1351         memset(*buf, 0, cb);
1352     }
1353     else
1354     {
1355         cb = (strlenW(*string_ptr) + 1)*sizeof(WCHAR);
1356         memcpy(*buf, *string_ptr, cb);
1357         MIDL_user_free(*string_ptr);
1358     }
1359
1360     *string_ptr = (LPWSTR)*buf;
1361     *buf += cb;
1362
1363     return cb;
1364 }
1365
1366 static DWORD size_string(LPCWSTR string)
1367 {
1368     return (string ? (strlenW(string) + 1)*sizeof(WCHAR) : sizeof(WCHAR));
1369 }
1370
1371 /******************************************************************************
1372  * QueryServiceConfigW [ADVAPI32.@]
1373  */
1374 BOOL WINAPI
1375 QueryServiceConfigW( SC_HANDLE hService,
1376                      LPQUERY_SERVICE_CONFIGW lpServiceConfig,
1377                      DWORD cbBufSize, LPDWORD pcbBytesNeeded)
1378 {
1379     QUERY_SERVICE_CONFIGW config;
1380     DWORD total;
1381     DWORD err;
1382     BYTE *bufpos;
1383
1384     TRACE("%p %p %d %p\n", hService, lpServiceConfig,
1385            cbBufSize, pcbBytesNeeded);
1386
1387     memset(&config, 0, sizeof(config));
1388
1389     __TRY
1390     {
1391         err = svcctl_QueryServiceConfigW(hService, &config);
1392     }
1393     __EXCEPT(rpc_filter)
1394     {
1395         err = map_exception_code(GetExceptionCode());
1396     }
1397     __ENDTRY
1398
1399     if (err != ERROR_SUCCESS)
1400     {
1401         TRACE("services.exe: error %u\n", err);
1402         SetLastError(err);
1403         return FALSE;
1404     }
1405
1406     /* calculate the size required first */
1407     total = sizeof (QUERY_SERVICE_CONFIGW);
1408     total += size_string(config.lpBinaryPathName);
1409     total += size_string(config.lpLoadOrderGroup);
1410     total += size_string(config.lpDependencies);
1411     total += size_string(config.lpServiceStartName);
1412     total += size_string(config.lpDisplayName);
1413
1414     *pcbBytesNeeded = total;
1415
1416     /* if there's not enough memory, return an error */
1417     if( total > cbBufSize )
1418     {
1419         SetLastError( ERROR_INSUFFICIENT_BUFFER );
1420         MIDL_user_free(config.lpBinaryPathName);
1421         MIDL_user_free(config.lpLoadOrderGroup);
1422         MIDL_user_free(config.lpDependencies);
1423         MIDL_user_free(config.lpServiceStartName);
1424         MIDL_user_free(config.lpDisplayName);
1425         return FALSE;
1426     }
1427
1428     *lpServiceConfig = config;
1429     bufpos = ((BYTE *)lpServiceConfig) + sizeof(QUERY_SERVICE_CONFIGW);
1430     move_string_to_buffer(&bufpos, &lpServiceConfig->lpBinaryPathName);
1431     move_string_to_buffer(&bufpos, &lpServiceConfig->lpLoadOrderGroup);
1432     move_string_to_buffer(&bufpos, &lpServiceConfig->lpDependencies);
1433     move_string_to_buffer(&bufpos, &lpServiceConfig->lpServiceStartName);
1434     move_string_to_buffer(&bufpos, &lpServiceConfig->lpDisplayName);
1435
1436     TRACE("Image path           = %s\n", debugstr_w(lpServiceConfig->lpBinaryPathName) );
1437     TRACE("Group                = %s\n", debugstr_w(lpServiceConfig->lpLoadOrderGroup) );
1438     TRACE("Dependencies         = %s\n", debugstr_w(lpServiceConfig->lpDependencies) );
1439     TRACE("Service account name = %s\n", debugstr_w(lpServiceConfig->lpServiceStartName) );
1440     TRACE("Display name         = %s\n", debugstr_w(lpServiceConfig->lpDisplayName) );
1441
1442     return TRUE;
1443 }
1444
1445 /******************************************************************************
1446  * QueryServiceConfig2A [ADVAPI32.@]
1447  *
1448  * Note
1449  *   observed under win2k:
1450  *   The functions QueryServiceConfig2A and QueryServiceConfig2W return the same
1451  *   required buffer size (in byte) at least for dwLevel SERVICE_CONFIG_DESCRIPTION
1452  */
1453 BOOL WINAPI QueryServiceConfig2A(SC_HANDLE hService, DWORD dwLevel, LPBYTE buffer,
1454                                  DWORD size, LPDWORD needed)
1455 {
1456     BOOL ret;
1457     LPBYTE bufferW = NULL;
1458
1459     if(buffer && size)
1460         bufferW = HeapAlloc( GetProcessHeap(), 0, size);
1461
1462     ret = QueryServiceConfig2W(hService, dwLevel, bufferW, size, needed);
1463     if(!ret) goto cleanup;
1464
1465     switch(dwLevel) {
1466         case SERVICE_CONFIG_DESCRIPTION:
1467             if (buffer && bufferW) {
1468                 LPSERVICE_DESCRIPTIONA configA = (LPSERVICE_DESCRIPTIONA) buffer;
1469                 LPSERVICE_DESCRIPTIONW configW = (LPSERVICE_DESCRIPTIONW) bufferW;
1470                 if (configW->lpDescription && (size > sizeof(SERVICE_DESCRIPTIONA))) {
1471                     DWORD sz;
1472                     configA->lpDescription = (LPSTR)(configA + 1);
1473                     sz = WideCharToMultiByte( CP_ACP, 0, configW->lpDescription, -1,
1474                              configA->lpDescription, size - sizeof(SERVICE_DESCRIPTIONA), NULL, NULL );
1475                     if (!sz) {
1476                         FIXME("WideCharToMultiByte failed for configW->lpDescription\n");
1477                         ret = FALSE;
1478                         configA->lpDescription = NULL;
1479                     }
1480                 }
1481                 else configA->lpDescription = NULL;
1482             }
1483             break;
1484         case SERVICE_CONFIG_PRESHUTDOWN_INFO:
1485             if (buffer && bufferW && *needed<=size)
1486                 memcpy(buffer, bufferW, *needed);
1487             break;
1488         default:
1489             FIXME("conversation W->A not implemented for level %d\n", dwLevel);
1490             ret = FALSE;
1491             break;
1492     }
1493
1494 cleanup:
1495     HeapFree( GetProcessHeap(), 0, bufferW);
1496     return ret;
1497 }
1498
1499 /******************************************************************************
1500  * QueryServiceConfig2W [ADVAPI32.@]
1501  *
1502  * See QueryServiceConfig2A.
1503  */
1504 BOOL WINAPI QueryServiceConfig2W(SC_HANDLE hService, DWORD dwLevel, LPBYTE buffer,
1505                                  DWORD size, LPDWORD needed)
1506 {
1507     DWORD err;
1508
1509     if(dwLevel!=SERVICE_CONFIG_DESCRIPTION && dwLevel!=SERVICE_CONFIG_PRESHUTDOWN_INFO) {
1510         FIXME("Level %d not implemented\n", dwLevel);
1511         SetLastError(ERROR_INVALID_LEVEL);
1512         return FALSE;
1513     }
1514
1515     if(!buffer && size) {
1516         SetLastError(ERROR_INVALID_ADDRESS);
1517         return FALSE;
1518     }
1519
1520     TRACE("%p 0x%d %p 0x%d %p\n", hService, dwLevel, buffer, size, needed);
1521
1522     __TRY
1523     {
1524         err = svcctl_QueryServiceConfig2W(hService, dwLevel, buffer, size, needed);
1525     }
1526     __EXCEPT(rpc_filter)
1527     {
1528         err = map_exception_code(GetExceptionCode());
1529     }
1530     __ENDTRY
1531
1532     if (err != ERROR_SUCCESS)
1533     {
1534         SetLastError( err );
1535         return FALSE;
1536     }
1537
1538     switch (dwLevel)
1539     {
1540     case SERVICE_CONFIG_DESCRIPTION:
1541         if (buffer)
1542         {
1543             SERVICE_DESCRIPTIONW *descr = (SERVICE_DESCRIPTIONW *)buffer;
1544             if (descr->lpDescription)  /* make it an absolute pointer */
1545                 descr->lpDescription = (WCHAR *)(buffer + (ULONG_PTR)descr->lpDescription);
1546             break;
1547         }
1548     }
1549
1550     return TRUE;
1551 }
1552
1553 /******************************************************************************
1554  * EnumServicesStatusA [ADVAPI32.@]
1555  */
1556 BOOL WINAPI
1557 EnumServicesStatusA( SC_HANDLE hmngr, DWORD type, DWORD state, LPENUM_SERVICE_STATUSA
1558                      services, DWORD size, LPDWORD needed, LPDWORD returned,
1559                      LPDWORD resume_handle )
1560 {
1561     BOOL ret;
1562     unsigned int i;
1563     ENUM_SERVICE_STATUSW *servicesW = NULL;
1564     DWORD sz, n;
1565     char *p;
1566
1567     TRACE("%p 0x%x 0x%x %p %u %p %p %p\n", hmngr, type, state, services, size, needed,
1568           returned, resume_handle);
1569
1570     sz = max( 2 * size, sizeof(*servicesW) );
1571     if (!(servicesW = HeapAlloc( GetProcessHeap(), 0, sz )))
1572     {
1573         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1574         return FALSE;
1575     }
1576
1577     ret = EnumServicesStatusW( hmngr, type, state, servicesW, sz, needed, returned, resume_handle );
1578     if (!ret) goto done;
1579
1580     p = (char *)services + *returned * sizeof(ENUM_SERVICE_STATUSA);
1581     n = size - (p - (char *)services);
1582     ret = FALSE;
1583     for (i = 0; i < *returned; i++)
1584     {
1585         sz = WideCharToMultiByte( CP_ACP, 0, servicesW[i].lpServiceName, -1, p, n, NULL, NULL );
1586         if (!sz) goto done;
1587         services[i].lpServiceName = p;
1588         p += sz;
1589         n -= sz;
1590         if (servicesW[i].lpDisplayName)
1591         {
1592             sz = WideCharToMultiByte( CP_ACP, 0, servicesW[i].lpDisplayName, -1, p, n, NULL, NULL );
1593             if (!sz) goto done;
1594             services[i].lpDisplayName = p;
1595             p += sz;
1596             n -= sz;
1597         }
1598         else services[i].lpDisplayName = NULL;
1599         services[i].ServiceStatus = servicesW[i].ServiceStatus;
1600     }
1601
1602     ret = TRUE;
1603
1604 done:
1605     HeapFree( GetProcessHeap(), 0, servicesW );
1606     return ret;
1607 }
1608
1609 /******************************************************************************
1610  * EnumServicesStatusW [ADVAPI32.@]
1611  */
1612 BOOL WINAPI
1613 EnumServicesStatusW( SC_HANDLE hmngr, DWORD type, DWORD state, LPENUM_SERVICE_STATUSW
1614                      services, DWORD size, LPDWORD needed, LPDWORD returned,
1615                      LPDWORD resume_handle )
1616 {
1617     DWORD err, i;
1618     ENUM_SERVICE_STATUSW dummy_status;
1619
1620     TRACE("%p 0x%x 0x%x %p %u %p %p %p\n", hmngr, type, state, services, size, needed,
1621           returned, resume_handle);
1622
1623     if (resume_handle)
1624         FIXME("resume handle not supported\n");
1625
1626     if (!hmngr)
1627     {
1628         SetLastError( ERROR_INVALID_HANDLE );
1629         return FALSE;
1630     }
1631
1632     /* make sure we pass a valid pointer */
1633     if (!services || size < sizeof(*services))
1634     {
1635         services = &dummy_status;
1636         size = sizeof(dummy_status);
1637     }
1638
1639     __TRY
1640     {
1641         err = svcctl_EnumServicesStatusW( hmngr, type, state, (BYTE *)services, size, needed, returned );
1642     }
1643     __EXCEPT(rpc_filter)
1644     {
1645         err = map_exception_code( GetExceptionCode() );
1646     }
1647     __ENDTRY
1648
1649     if (err != ERROR_SUCCESS)
1650     {
1651         SetLastError( err );
1652         return FALSE;
1653     }
1654
1655     for (i = 0; i < *returned; i++)
1656     {
1657         /* convert buffer offsets into pointers */
1658         services[i].lpServiceName = (WCHAR *)((char *)services + (DWORD_PTR)services[i].lpServiceName);
1659         if (services[i].lpDisplayName)
1660             services[i].lpDisplayName = (WCHAR *)((char *)services + (DWORD_PTR)services[i].lpDisplayName);
1661     }
1662
1663     return TRUE;
1664 }
1665
1666 /******************************************************************************
1667  * EnumServicesStatusExA [ADVAPI32.@]
1668  */
1669 BOOL WINAPI
1670 EnumServicesStatusExA( SC_HANDLE hmngr, SC_ENUM_TYPE level, DWORD type, DWORD state,
1671                        LPBYTE buffer, DWORD size, LPDWORD needed, LPDWORD returned,
1672                        LPDWORD resume_handle, LPCSTR group )
1673 {
1674     BOOL ret;
1675     unsigned int i;
1676     ENUM_SERVICE_STATUS_PROCESSA *services = (ENUM_SERVICE_STATUS_PROCESSA *)buffer;
1677     ENUM_SERVICE_STATUS_PROCESSW *servicesW = NULL;
1678     WCHAR *groupW = NULL;
1679     DWORD sz, n;
1680     char *p;
1681
1682     TRACE("%p %u 0x%x 0x%x %p %u %p %p %p %s\n", hmngr, level, type, state, buffer,
1683           size, needed, returned, resume_handle, debugstr_a(group));
1684
1685     sz = max( 2 * size, sizeof(*servicesW) );
1686     if (!(servicesW = HeapAlloc( GetProcessHeap(), 0, sz )))
1687     {
1688         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1689         return FALSE;
1690     }
1691     if (group)
1692     {
1693         int len = MultiByteToWideChar( CP_ACP, 0, group, -1, NULL, 0 );
1694         if (!(groupW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
1695         {
1696             SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1697             HeapFree( GetProcessHeap(), 0, servicesW );
1698             return FALSE;
1699         }
1700         MultiByteToWideChar( CP_ACP, 0, group, -1, groupW, len * sizeof(WCHAR) );
1701     }
1702
1703     ret = EnumServicesStatusExW( hmngr, level, type, state, (BYTE *)servicesW, sz,
1704                                  needed, returned, resume_handle, groupW );
1705     if (!ret) goto done;
1706
1707     p = (char *)services + *returned * sizeof(ENUM_SERVICE_STATUS_PROCESSA);
1708     n = size - (p - (char *)services);
1709     ret = FALSE;
1710     for (i = 0; i < *returned; i++)
1711     {
1712         sz = WideCharToMultiByte( CP_ACP, 0, servicesW[i].lpServiceName, -1, p, n, NULL, NULL );
1713         if (!sz) goto done;
1714         services[i].lpServiceName = p;
1715         p += sz;
1716         n -= sz;
1717         if (servicesW[i].lpDisplayName)
1718         {
1719             sz = WideCharToMultiByte( CP_ACP, 0, servicesW[i].lpDisplayName, -1, p, n, NULL, NULL );
1720             if (!sz) goto done;
1721             services[i].lpDisplayName = p;
1722             p += sz;
1723             n -= sz;
1724         }
1725         else services[i].lpDisplayName = NULL;
1726         services[i].ServiceStatusProcess = servicesW[i].ServiceStatusProcess;
1727     }
1728
1729     ret = TRUE;
1730
1731 done:
1732     HeapFree( GetProcessHeap(), 0, servicesW );
1733     HeapFree( GetProcessHeap(), 0, groupW );
1734     return ret;
1735 }
1736
1737 /******************************************************************************
1738  * EnumServicesStatusExW [ADVAPI32.@]
1739  */
1740 BOOL WINAPI
1741 EnumServicesStatusExW( SC_HANDLE hmngr, SC_ENUM_TYPE level, DWORD type, DWORD state,
1742                        LPBYTE buffer, DWORD size, LPDWORD needed, LPDWORD returned,
1743                        LPDWORD resume_handle, LPCWSTR group )
1744 {
1745     DWORD err, i;
1746     ENUM_SERVICE_STATUS_PROCESSW dummy_status;
1747     ENUM_SERVICE_STATUS_PROCESSW *services = (ENUM_SERVICE_STATUS_PROCESSW *)buffer;
1748
1749     TRACE("%p %u 0x%x 0x%x %p %u %p %p %p %s\n", hmngr, level, type, state, buffer,
1750           size, needed, returned, resume_handle, debugstr_w(group));
1751
1752     if (resume_handle)
1753         FIXME("resume handle not supported\n");
1754
1755     if (level != SC_ENUM_PROCESS_INFO)
1756     {
1757         SetLastError( ERROR_INVALID_LEVEL );
1758         return FALSE;
1759     }
1760     if (!hmngr)
1761     {
1762         SetLastError( ERROR_INVALID_HANDLE );
1763         return FALSE;
1764     }
1765
1766     /* make sure we pass a valid buffer pointer */
1767     if (!services || size < sizeof(*services))
1768     {
1769         buffer = (BYTE *)&dummy_status;
1770         size = sizeof(dummy_status);
1771     }
1772
1773     __TRY
1774     {
1775         err = svcctl_EnumServicesStatusExW( hmngr, type, state, buffer, size, needed,
1776                                             returned, group );
1777     }
1778     __EXCEPT(rpc_filter)
1779     {
1780         err = map_exception_code( GetExceptionCode() );
1781     }
1782     __ENDTRY
1783
1784     if (err != ERROR_SUCCESS)
1785     {
1786         SetLastError( err );
1787         return FALSE;
1788     }
1789
1790     for (i = 0; i < *returned; i++)
1791     {
1792         /* convert buffer offsets into pointers */
1793         services[i].lpServiceName = (WCHAR *)((char *)services + (DWORD_PTR)services[i].lpServiceName);
1794         if (services[i].lpDisplayName)
1795             services[i].lpDisplayName = (WCHAR *)((char *)services + (DWORD_PTR)services[i].lpDisplayName);
1796     }
1797
1798     return TRUE;
1799 }
1800
1801 /******************************************************************************
1802  * GetServiceKeyNameA [ADVAPI32.@]
1803  */
1804 BOOL WINAPI GetServiceKeyNameA( SC_HANDLE hSCManager, LPCSTR lpDisplayName,
1805                                 LPSTR lpServiceName, LPDWORD lpcchBuffer )
1806 {
1807     LPWSTR lpDisplayNameW, lpServiceNameW;
1808     DWORD sizeW;
1809     BOOL ret = FALSE;
1810
1811     TRACE("%p %s %p %p\n", hSCManager,
1812           debugstr_a(lpDisplayName), lpServiceName, lpcchBuffer);
1813
1814     lpDisplayNameW = SERV_dup(lpDisplayName);
1815     if (lpServiceName)
1816         lpServiceNameW = HeapAlloc(GetProcessHeap(), 0, *lpcchBuffer * sizeof(WCHAR));
1817     else
1818         lpServiceNameW = NULL;
1819
1820     sizeW = *lpcchBuffer;
1821     if (!GetServiceKeyNameW(hSCManager, lpDisplayNameW, lpServiceNameW, &sizeW))
1822     {
1823         if (lpServiceName && *lpcchBuffer)
1824             lpServiceName[0] = 0;
1825         *lpcchBuffer = sizeW*2;  /* we can only provide an upper estimation of string length */
1826         goto cleanup;
1827     }
1828
1829     if (!WideCharToMultiByte(CP_ACP, 0, lpServiceNameW, (sizeW + 1), lpServiceName,
1830                         *lpcchBuffer, NULL, NULL ))
1831     {
1832         if (*lpcchBuffer && lpServiceName)
1833             lpServiceName[0] = 0;
1834         *lpcchBuffer = WideCharToMultiByte(CP_ACP, 0, lpServiceNameW, -1, NULL, 0, NULL, NULL);
1835         goto cleanup;
1836     }
1837
1838     /* lpcchBuffer not updated - same as in GetServiceDisplayNameA */
1839     ret = TRUE;
1840
1841 cleanup:
1842     HeapFree(GetProcessHeap(), 0, lpServiceNameW);
1843     HeapFree(GetProcessHeap(), 0, lpDisplayNameW);
1844     return ret;
1845 }
1846
1847 /******************************************************************************
1848  * GetServiceKeyNameW [ADVAPI32.@]
1849  */
1850 BOOL WINAPI GetServiceKeyNameW( SC_HANDLE hSCManager, LPCWSTR lpDisplayName,
1851                                 LPWSTR lpServiceName, LPDWORD lpcchBuffer )
1852 {
1853     DWORD err;
1854     WCHAR buffer[2];
1855     DWORD size;
1856
1857     TRACE("%p %s %p %p\n", hSCManager,
1858           debugstr_w(lpDisplayName), lpServiceName, lpcchBuffer);
1859
1860     if (!hSCManager)
1861     {
1862         SetLastError( ERROR_INVALID_HANDLE );
1863         return FALSE;
1864     }
1865
1866     /* provide a buffer if the caller didn't */
1867     if (!lpServiceName || *lpcchBuffer < 2)
1868     {
1869         lpServiceName = buffer;
1870         /* A size of 1 would be enough, but tests show that Windows returns 2,
1871          * probably because of a WCHAR/bytes mismatch in their code.
1872          */
1873         *lpcchBuffer = 2;
1874     }
1875
1876     /* RPC call takes size excluding nul-terminator, whereas *lpcchBuffer
1877      * includes the nul-terminator on input. */
1878     size = *lpcchBuffer - 1;
1879
1880     __TRY
1881     {
1882         err = svcctl_GetServiceKeyNameW(hSCManager, lpDisplayName, lpServiceName,
1883                                         &size);
1884     }
1885     __EXCEPT(rpc_filter)
1886     {
1887         err = map_exception_code(GetExceptionCode());
1888     }
1889     __ENDTRY
1890
1891     /* The value of *lpcchBuffer excludes nul-terminator on output. */
1892     if (err == ERROR_SUCCESS || err == ERROR_INSUFFICIENT_BUFFER)
1893         *lpcchBuffer = size;
1894
1895     if (err)
1896         SetLastError(err);
1897     return err == ERROR_SUCCESS;
1898 }
1899
1900 /******************************************************************************
1901  * QueryServiceLockStatusA [ADVAPI32.@]
1902  */
1903 BOOL WINAPI QueryServiceLockStatusA( SC_HANDLE hSCManager,
1904                                      LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus,
1905                                      DWORD cbBufSize, LPDWORD pcbBytesNeeded)
1906 {
1907     FIXME("%p %p %08x %p\n", hSCManager, lpLockStatus, cbBufSize, pcbBytesNeeded);
1908
1909     return FALSE;
1910 }
1911
1912 /******************************************************************************
1913  * QueryServiceLockStatusW [ADVAPI32.@]
1914  */
1915 BOOL WINAPI QueryServiceLockStatusW( SC_HANDLE hSCManager,
1916                                      LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus,
1917                                      DWORD cbBufSize, LPDWORD pcbBytesNeeded)
1918 {
1919     FIXME("%p %p %08x %p\n", hSCManager, lpLockStatus, cbBufSize, pcbBytesNeeded);
1920
1921     return FALSE;
1922 }
1923
1924 /******************************************************************************
1925  * GetServiceDisplayNameA  [ADVAPI32.@]
1926  */
1927 BOOL WINAPI GetServiceDisplayNameA( SC_HANDLE hSCManager, LPCSTR lpServiceName,
1928   LPSTR lpDisplayName, LPDWORD lpcchBuffer)
1929 {
1930     LPWSTR lpServiceNameW, lpDisplayNameW;
1931     DWORD sizeW;
1932     BOOL ret = FALSE;
1933
1934     TRACE("%p %s %p %p\n", hSCManager,
1935           debugstr_a(lpServiceName), lpDisplayName, lpcchBuffer);
1936
1937     lpServiceNameW = SERV_dup(lpServiceName);
1938     if (lpDisplayName)
1939         lpDisplayNameW = HeapAlloc(GetProcessHeap(), 0, *lpcchBuffer * sizeof(WCHAR));
1940     else
1941         lpDisplayNameW = NULL;
1942
1943     sizeW = *lpcchBuffer;
1944     if (!GetServiceDisplayNameW(hSCManager, lpServiceNameW, lpDisplayNameW, &sizeW))
1945     {
1946         if (lpDisplayName && *lpcchBuffer)
1947             lpDisplayName[0] = 0;
1948         *lpcchBuffer = sizeW*2;  /* we can only provide an upper estimation of string length */
1949         goto cleanup;
1950     }
1951
1952     if (!WideCharToMultiByte(CP_ACP, 0, lpDisplayNameW, (sizeW + 1), lpDisplayName,
1953                         *lpcchBuffer, NULL, NULL ))
1954     {
1955         if (*lpcchBuffer && lpDisplayName)
1956             lpDisplayName[0] = 0;
1957         *lpcchBuffer = WideCharToMultiByte(CP_ACP, 0, lpDisplayNameW, -1, NULL, 0, NULL, NULL);
1958         goto cleanup;
1959     }
1960
1961     /* probably due to a bug GetServiceDisplayNameA doesn't modify lpcchBuffer on success.
1962      * (but if the function succeeded it means that is a good upper estimation of the size) */
1963     ret = TRUE;
1964
1965 cleanup:
1966     HeapFree(GetProcessHeap(), 0, lpDisplayNameW);
1967     HeapFree(GetProcessHeap(), 0, lpServiceNameW);
1968     return ret;
1969 }
1970
1971 /******************************************************************************
1972  * GetServiceDisplayNameW  [ADVAPI32.@]
1973  */
1974 BOOL WINAPI GetServiceDisplayNameW( SC_HANDLE hSCManager, LPCWSTR lpServiceName,
1975   LPWSTR lpDisplayName, LPDWORD lpcchBuffer)
1976 {
1977     DWORD err;
1978     DWORD size;
1979     WCHAR buffer[2];
1980
1981     TRACE("%p %s %p %p\n", hSCManager,
1982           debugstr_w(lpServiceName), lpDisplayName, lpcchBuffer);
1983
1984     if (!hSCManager)
1985     {
1986         SetLastError( ERROR_INVALID_HANDLE );
1987         return FALSE;
1988     }
1989
1990     /* provide a buffer if the caller didn't */
1991     if (!lpDisplayName || *lpcchBuffer < 2)
1992     {
1993         lpDisplayName = buffer;
1994         /* A size of 1 would be enough, but tests show that Windows returns 2,
1995          * probably because of a WCHAR/bytes mismatch in their code.
1996          */
1997         *lpcchBuffer = 2;
1998     }
1999
2000     /* RPC call takes size excluding nul-terminator, whereas *lpcchBuffer
2001      * includes the nul-terminator on input. */
2002     size = *lpcchBuffer - 1;
2003
2004     __TRY
2005     {
2006         err = svcctl_GetServiceDisplayNameW(hSCManager, lpServiceName, lpDisplayName,
2007                                             &size);
2008     }
2009     __EXCEPT(rpc_filter)
2010     {
2011         err = map_exception_code(GetExceptionCode());
2012     }
2013     __ENDTRY
2014
2015     /* The value of *lpcchBuffer excludes nul-terminator on output. */
2016     if (err == ERROR_SUCCESS || err == ERROR_INSUFFICIENT_BUFFER)
2017         *lpcchBuffer = size;
2018
2019     if (err)
2020         SetLastError(err);
2021     return err == ERROR_SUCCESS;
2022 }
2023
2024 /******************************************************************************
2025  * ChangeServiceConfigW  [ADVAPI32.@]
2026  */
2027 BOOL WINAPI ChangeServiceConfigW( SC_HANDLE hService, DWORD dwServiceType,
2028   DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName,
2029   LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies,
2030   LPCWSTR lpServiceStartName, LPCWSTR lpPassword, LPCWSTR lpDisplayName)
2031 {
2032     DWORD cb_pwd;
2033     DWORD err;
2034
2035     TRACE("%p %d %d %d %s %s %p %p %s %s %s\n",
2036           hService, dwServiceType, dwStartType, dwErrorControl,
2037           debugstr_w(lpBinaryPathName), debugstr_w(lpLoadOrderGroup),
2038           lpdwTagId, lpDependencies, debugstr_w(lpServiceStartName),
2039           debugstr_w(lpPassword), debugstr_w(lpDisplayName) );
2040
2041     cb_pwd = lpPassword ? (strlenW(lpPassword) + 1)*sizeof(WCHAR) : 0;
2042
2043     __TRY
2044     {
2045         err = svcctl_ChangeServiceConfigW(hService, dwServiceType,
2046                 dwStartType, dwErrorControl, lpBinaryPathName, lpLoadOrderGroup, lpdwTagId,
2047                 (const BYTE *)lpDependencies, multisz_cb(lpDependencies), lpServiceStartName,
2048                 (const BYTE *)lpPassword, cb_pwd, lpDisplayName);
2049     }
2050     __EXCEPT(rpc_filter)
2051     {
2052         err = map_exception_code(GetExceptionCode());
2053     }
2054     __ENDTRY
2055
2056     if (err != ERROR_SUCCESS)
2057         SetLastError(err);
2058
2059     return err == ERROR_SUCCESS;
2060 }
2061
2062 /******************************************************************************
2063  * ChangeServiceConfigA  [ADVAPI32.@]
2064  */
2065 BOOL WINAPI ChangeServiceConfigA( SC_HANDLE hService, DWORD dwServiceType,
2066   DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpBinaryPathName,
2067   LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCSTR lpDependencies,
2068   LPCSTR lpServiceStartName, LPCSTR lpPassword, LPCSTR lpDisplayName)
2069 {
2070     LPWSTR wBinaryPathName, wLoadOrderGroup, wDependencies;
2071     LPWSTR wServiceStartName, wPassword, wDisplayName;
2072     BOOL r;
2073
2074     TRACE("%p %d %d %d %s %s %p %p %s %s %s\n",
2075           hService, dwServiceType, dwStartType, dwErrorControl,
2076           debugstr_a(lpBinaryPathName), debugstr_a(lpLoadOrderGroup),
2077           lpdwTagId, lpDependencies, debugstr_a(lpServiceStartName),
2078           debugstr_a(lpPassword), debugstr_a(lpDisplayName) );
2079
2080     wBinaryPathName = SERV_dup( lpBinaryPathName );
2081     wLoadOrderGroup = SERV_dup( lpLoadOrderGroup );
2082     wDependencies = SERV_dupmulti( lpDependencies );
2083     wServiceStartName = SERV_dup( lpServiceStartName );
2084     wPassword = SERV_dup( lpPassword );
2085     wDisplayName = SERV_dup( lpDisplayName );
2086
2087     r = ChangeServiceConfigW( hService, dwServiceType,
2088             dwStartType, dwErrorControl, wBinaryPathName,
2089             wLoadOrderGroup, lpdwTagId, wDependencies,
2090             wServiceStartName, wPassword, wDisplayName);
2091
2092     HeapFree( GetProcessHeap(), 0, wBinaryPathName );
2093     HeapFree( GetProcessHeap(), 0, wLoadOrderGroup );
2094     HeapFree( GetProcessHeap(), 0, wDependencies );
2095     HeapFree( GetProcessHeap(), 0, wServiceStartName );
2096     HeapFree( GetProcessHeap(), 0, wPassword );
2097     HeapFree( GetProcessHeap(), 0, wDisplayName );
2098
2099     return r;
2100 }
2101
2102 /******************************************************************************
2103  * ChangeServiceConfig2A  [ADVAPI32.@]
2104  */
2105 BOOL WINAPI ChangeServiceConfig2A( SC_HANDLE hService, DWORD dwInfoLevel,
2106     LPVOID lpInfo)
2107 {
2108     BOOL r = FALSE;
2109
2110     TRACE("%p %d %p\n",hService, dwInfoLevel, lpInfo);
2111
2112     if (dwInfoLevel == SERVICE_CONFIG_DESCRIPTION)
2113     {
2114         LPSERVICE_DESCRIPTIONA sd = lpInfo;
2115         SERVICE_DESCRIPTIONW sdw;
2116
2117         sdw.lpDescription = SERV_dup( sd->lpDescription );
2118
2119         r = ChangeServiceConfig2W( hService, dwInfoLevel, &sdw );
2120
2121         HeapFree( GetProcessHeap(), 0, sdw.lpDescription );
2122     }
2123     else if (dwInfoLevel == SERVICE_CONFIG_FAILURE_ACTIONS)
2124     {
2125         LPSERVICE_FAILURE_ACTIONSA fa = lpInfo;
2126         SERVICE_FAILURE_ACTIONSW faw;
2127
2128         faw.dwResetPeriod = fa->dwResetPeriod;
2129         faw.lpRebootMsg = SERV_dup( fa->lpRebootMsg );
2130         faw.lpCommand = SERV_dup( fa->lpCommand );
2131         faw.cActions = fa->cActions;
2132         faw.lpsaActions = fa->lpsaActions;
2133
2134         r = ChangeServiceConfig2W( hService, dwInfoLevel, &faw );
2135
2136         HeapFree( GetProcessHeap(), 0, faw.lpRebootMsg );
2137         HeapFree( GetProcessHeap(), 0, faw.lpCommand );
2138     }
2139     else if (dwInfoLevel == SERVICE_CONFIG_PRESHUTDOWN_INFO)
2140     {
2141         r = ChangeServiceConfig2W( hService, dwInfoLevel, lpInfo);
2142     }
2143     else
2144         SetLastError( ERROR_INVALID_PARAMETER );
2145
2146     return r;
2147 }
2148
2149 /******************************************************************************
2150  * ChangeServiceConfig2W  [ADVAPI32.@]
2151  */
2152 BOOL WINAPI ChangeServiceConfig2W( SC_HANDLE hService, DWORD dwInfoLevel,
2153     LPVOID lpInfo)
2154 {
2155     DWORD err;
2156
2157     __TRY
2158     {
2159         err = svcctl_ChangeServiceConfig2W( hService, dwInfoLevel, lpInfo );
2160     }
2161     __EXCEPT(rpc_filter)
2162     {
2163         err = map_exception_code(GetExceptionCode());
2164     }
2165     __ENDTRY
2166
2167     if (err != ERROR_SUCCESS)
2168         SetLastError(err);
2169
2170     return err == ERROR_SUCCESS;
2171 }
2172
2173 NTSTATUS SERV_QueryServiceObjectSecurity(SC_HANDLE hService,
2174        SECURITY_INFORMATION dwSecurityInformation,
2175        PSECURITY_DESCRIPTOR lpSecurityDescriptor,
2176        DWORD cbBufSize, LPDWORD pcbBytesNeeded)
2177 {
2178     SECURITY_DESCRIPTOR descriptor;
2179     NTSTATUS status;
2180     DWORD size;
2181     ACL acl;
2182
2183     FIXME("%p %d %p %u %p - semi-stub\n", hService, dwSecurityInformation,
2184           lpSecurityDescriptor, cbBufSize, pcbBytesNeeded);
2185
2186     if (dwSecurityInformation != DACL_SECURITY_INFORMATION)
2187         FIXME("information %d not supported\n", dwSecurityInformation);
2188
2189     InitializeSecurityDescriptor(&descriptor, SECURITY_DESCRIPTOR_REVISION);
2190
2191     InitializeAcl(&acl, sizeof(ACL), ACL_REVISION);
2192     SetSecurityDescriptorDacl(&descriptor, TRUE, &acl, TRUE);
2193
2194     size = cbBufSize;
2195     status = RtlMakeSelfRelativeSD(&descriptor, lpSecurityDescriptor, &size);
2196     *pcbBytesNeeded = size;
2197     return status;
2198 }
2199
2200 /******************************************************************************
2201  * QueryServiceObjectSecurity [ADVAPI32.@]
2202  */
2203 BOOL WINAPI QueryServiceObjectSecurity(SC_HANDLE hService,
2204        SECURITY_INFORMATION dwSecurityInformation,
2205        PSECURITY_DESCRIPTOR lpSecurityDescriptor,
2206        DWORD cbBufSize, LPDWORD pcbBytesNeeded)
2207 {
2208     NTSTATUS status = SERV_QueryServiceObjectSecurity(hService, dwSecurityInformation, lpSecurityDescriptor,
2209                                                       cbBufSize, pcbBytesNeeded);
2210     if (status != STATUS_SUCCESS)
2211     {
2212         SetLastError(RtlNtStatusToDosError(status));
2213         return FALSE;
2214     }
2215     return TRUE;
2216 }
2217
2218 /******************************************************************************
2219  * SetServiceObjectSecurity [ADVAPI32.@]
2220  *
2221  * NOTES
2222  *  - SetSecurityInfo should be updated to call this function once it's implemented.
2223  */
2224 BOOL WINAPI SetServiceObjectSecurity(SC_HANDLE hService,
2225        SECURITY_INFORMATION dwSecurityInformation,
2226        PSECURITY_DESCRIPTOR lpSecurityDescriptor)
2227 {
2228     FIXME("%p %d %p\n", hService, dwSecurityInformation, lpSecurityDescriptor);
2229     return TRUE;
2230 }
2231
2232 /******************************************************************************
2233  * SetServiceBits [ADVAPI32.@]
2234  */
2235 BOOL WINAPI SetServiceBits( SERVICE_STATUS_HANDLE hServiceStatus,
2236         DWORD dwServiceBits,
2237         BOOL bSetBitsOn,
2238         BOOL bUpdateImmediately)
2239 {
2240     FIXME("%p %08x %x %x\n", hServiceStatus, dwServiceBits,
2241           bSetBitsOn, bUpdateImmediately);
2242     return TRUE;
2243 }
2244
2245 /* thunk for calling the RegisterServiceCtrlHandler handler function */
2246 static DWORD WINAPI ctrl_handler_thunk( DWORD control, DWORD type, void *data, void *context )
2247 {
2248     LPHANDLER_FUNCTION func = context;
2249
2250     func( control );
2251     return ERROR_SUCCESS;
2252 }
2253
2254 /******************************************************************************
2255  * RegisterServiceCtrlHandlerA [ADVAPI32.@]
2256  */
2257 SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerA( LPCSTR name, LPHANDLER_FUNCTION handler )
2258 {
2259     return RegisterServiceCtrlHandlerExA( name, ctrl_handler_thunk, handler );
2260 }
2261
2262 /******************************************************************************
2263  * RegisterServiceCtrlHandlerW [ADVAPI32.@]
2264  */
2265 SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerW( LPCWSTR name, LPHANDLER_FUNCTION handler )
2266 {
2267     return RegisterServiceCtrlHandlerExW( name, ctrl_handler_thunk, handler );
2268 }
2269
2270 /******************************************************************************
2271  * RegisterServiceCtrlHandlerExA [ADVAPI32.@]
2272  */
2273 SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerExA( LPCSTR name, LPHANDLER_FUNCTION_EX handler, LPVOID context )
2274 {
2275     LPWSTR nameW;
2276     SERVICE_STATUS_HANDLE ret;
2277
2278     nameW = SERV_dup(name);
2279     ret = RegisterServiceCtrlHandlerExW( nameW, handler, context );
2280     HeapFree( GetProcessHeap(), 0, nameW );
2281     return ret;
2282 }
2283
2284 /******************************************************************************
2285  * RegisterServiceCtrlHandlerExW [ADVAPI32.@]
2286  */
2287 SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerExW( LPCWSTR lpServiceName,
2288         LPHANDLER_FUNCTION_EX lpHandlerProc, LPVOID lpContext )
2289 {
2290     service_data *service;
2291     SC_HANDLE hService = 0;
2292     BOOL found = FALSE;
2293
2294     TRACE("%s %p %p\n", debugstr_w(lpServiceName), lpHandlerProc, lpContext);
2295
2296     EnterCriticalSection( &service_cs );
2297     if ((service = find_service_by_name( lpServiceName )))
2298     {
2299         service->handler = lpHandlerProc;
2300         service->context = lpContext;
2301         hService = service->handle;
2302         found = TRUE;
2303     }
2304     LeaveCriticalSection( &service_cs );
2305
2306     if (!found) SetLastError(ERROR_SERVICE_DOES_NOT_EXIST);
2307
2308     return (SERVICE_STATUS_HANDLE)hService;
2309 }
2310
2311 /******************************************************************************
2312  * EnumDependentServicesA [ADVAPI32.@]
2313  */
2314 BOOL WINAPI EnumDependentServicesA( SC_HANDLE hService, DWORD dwServiceState,
2315                                     LPENUM_SERVICE_STATUSA lpServices, DWORD cbBufSize,
2316         LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned )
2317 {
2318     FIXME("%p 0x%08x %p 0x%08x %p %p - stub\n", hService, dwServiceState,
2319           lpServices, cbBufSize, pcbBytesNeeded, lpServicesReturned);
2320
2321     *lpServicesReturned = 0;
2322     return TRUE;
2323 }
2324
2325 /******************************************************************************
2326  * EnumDependentServicesW [ADVAPI32.@]
2327  */
2328 BOOL WINAPI EnumDependentServicesW( SC_HANDLE hService, DWORD dwServiceState,
2329                                     LPENUM_SERVICE_STATUSW lpServices, DWORD cbBufSize,
2330                                     LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned )
2331 {
2332     FIXME("%p 0x%08x %p 0x%08x %p %p - stub\n", hService, dwServiceState,
2333           lpServices, cbBufSize, pcbBytesNeeded, lpServicesReturned);
2334
2335     *lpServicesReturned = 0;
2336     return TRUE;
2337 }