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