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