?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push b72af2511d67bded8ece08d825ff0eb4a60c20a6
[wine/hacks.git] / dlls / advapi32 / service.c
bloba698f116b1e1005ce0c78df9e1a826f6a01bcc6d
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 <stdarg.h>
24 #include <string.h>
25 #include <time.h>
26 #include <assert.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winsvc.h"
31 #include "winerror.h"
32 #include "winreg.h"
33 #include "wine/unicode.h"
34 #include "wine/debug.h"
35 #include "winternl.h"
36 #include "lmcons.h"
37 #include "lmserver.h"
38 #include "wine/list.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
41
42 static const WCHAR szServiceManagerKey[] = { 'S','y','s','t','e','m','\\',
43 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
44 'S','e','r','v','i','c','e','s',0 };
45 static const WCHAR szSCMLock[] = {'A','D','V','A','P','I','_','S','C','M',
46 'L','O','C','K',0};
47
48 static const GENERIC_MAPPING scm_generic = {
49 (STANDARD_RIGHTS_READ | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_QUERY_LOCK_STATUS),
50 (STANDARD_RIGHTS_WRITE | SC_MANAGER_CREATE_SERVICE | SC_MANAGER_MODIFY_BOOT_CONFIG),
51 (STANDARD_RIGHTS_EXECUTE | SC_MANAGER_CONNECT | SC_MANAGER_LOCK),
52 SC_MANAGER_ALL_ACCESS
53 };
54
55 static const GENERIC_MAPPING svc_generic = {
56 (STANDARD_RIGHTS_READ | SERVICE_QUERY_CONFIG | SERVICE_QUERY_STATUS | SERVICE_INTERROGATE | SERVICE_ENUMERATE_DEPENDENTS),
57 (STANDARD_RIGHTS_WRITE | SERVICE_CHANGE_CONFIG),
58 (STANDARD_RIGHTS_EXECUTE | SERVICE_START | SERVICE_STOP | SERVICE_PAUSE_CONTINUE | SERVICE_USER_DEFINED_CONTROL),
59 SERVICE_ALL_ACCESS
60 };
61
62 typedef struct service_start_info_t
63 {
64 DWORD cmd;
65 DWORD size;
66 WCHAR str[1];
67 } service_start_info;
68
69 #define WINESERV_STARTINFO 1
70 #define WINESERV_GETSTATUS 2
71 #define WINESERV_SENDCONTROL 3
72
73 typedef struct service_data_t
74 {
75 struct list entry;
76 union {
77 LPHANDLER_FUNCTION handler;
78 LPHANDLER_FUNCTION_EX handler_ex;
79 } handler;
80 LPVOID context;
81 SERVICE_STATUS_PROCESS status;
82 HANDLE thread;
83 BOOL unicode : 1;
84 BOOL extended : 1; /* uses handler_ex instead of handler? */
85 union {
86 LPSERVICE_MAIN_FUNCTIONA a;
87 LPSERVICE_MAIN_FUNCTIONW w;
88 } proc;
89 LPWSTR args;
90 WCHAR name[1];
91 } service_data;
92
93 static CRITICAL_SECTION service_cs;
94 static CRITICAL_SECTION_DEBUG service_cs_debug =
95 {
96 0, 0, &service_cs,
97 { &service_cs_debug.ProcessLocksList,
98 &service_cs_debug.ProcessLocksList },
99 0, 0, { (DWORD_PTR)(__FILE__ ": service_cs") }
100 };
101 static CRITICAL_SECTION service_cs = { &service_cs_debug, -1, 0, 0, 0, 0 };
102
103 static struct list service_list = LIST_INIT(service_list);
104
105 extern HANDLE __wine_make_process_system(void);
106
107 /******************************************************************************
108 * SC_HANDLEs
109 */
110
111 #define MAX_SERVICE_NAME 256
112
113 typedef enum { SC_HTYPE_MANAGER, SC_HTYPE_SERVICE } SC_HANDLE_TYPE;
114
115 struct sc_handle;
116 typedef VOID (*sc_handle_destructor)(struct sc_handle *);
117
118 struct sc_handle
119 {
120 SC_HANDLE_TYPE htype;
121 DWORD ref_count;
122 sc_handle_destructor destroy;
123 };
124
125 struct sc_manager /* service control manager handle */
126 {
127 struct sc_handle hdr;
128 HKEY hkey; /* handle to services database in the registry */
129 DWORD dwAccess;
130 };
131
132 struct sc_service /* service handle */
133 {
134 struct sc_handle hdr;
135 HKEY hkey; /* handle to service entry in the registry (under hkey) */
136 DWORD dwAccess;
137 struct sc_manager *scm; /* pointer to SCM handle */
138 WCHAR name[1];
139 };
140
141 static void *sc_handle_alloc(SC_HANDLE_TYPE htype, DWORD size,
142 sc_handle_destructor destroy)
143 {
144 struct sc_handle *hdr;
145
146 hdr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size );
147 if (hdr)
148 {
149 hdr->htype = htype;
150 hdr->ref_count = 1;
151 hdr->destroy = destroy;
152 }
153 TRACE("sc_handle type=%d -> %p\n", htype, hdr);
154 return hdr;
155 }
156
157 static void *sc_handle_get_handle_data(SC_HANDLE handle, DWORD htype)
158 {
159 struct sc_handle *hdr = (struct sc_handle *) handle;
160
161 if (!hdr)
162 return NULL;
163 if (hdr->htype != htype)
164 return NULL;
165 return hdr;
166 }
167
168 static void sc_handle_free(struct sc_handle* hdr)
169 {
170 if (!hdr)
171 return;
172 if (--hdr->ref_count)
173 return;
174 hdr->destroy(hdr);
175 HeapFree(GetProcessHeap(), 0, hdr);
176 }
177
178 static void sc_handle_destroy_manager(struct sc_handle *handle)
179 {
180 struct sc_manager *mgr = (struct sc_manager*) handle;
181
182 TRACE("destroying SC Manager %p\n", mgr);
183 if (mgr->hkey)
184 RegCloseKey(mgr->hkey);
185 }
186
187 static void sc_handle_destroy_service(struct sc_handle *handle)
188 {
189 struct sc_service *svc = (struct sc_service*) handle;
190
191 TRACE("destroying service %p\n", svc);
192 if (svc->hkey)
193 RegCloseKey(svc->hkey);
194 svc->hkey = NULL;
195 sc_handle_free(&svc->scm->hdr);
196 svc->scm = NULL;
197 }
198
199 /******************************************************************************
200 * String management functions (same behaviour as strdup)
201 * NOTE: the caller of those functions is responsible for calling HeapFree
202 * in order to release the memory allocated by those functions.
203 */
204 static inline LPWSTR SERV_dup( LPCSTR str )
205 {
206 UINT len;
207 LPWSTR wstr;
208
209 if( !str )
210 return NULL;
211 len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
212 wstr = HeapAlloc( GetProcessHeap(), 0, len*sizeof (WCHAR) );
213 MultiByteToWideChar( CP_ACP, 0, str, -1, wstr, len );
214 return wstr;
215 }
216
217 static inline LPWSTR SERV_dupmulti(LPCSTR str)
218 {
219 UINT len = 0, n = 0;
220 LPWSTR wstr;
221
222 if( !str )
223 return NULL;
224 do {
225 len += MultiByteToWideChar( CP_ACP, 0, &str[n], -1, NULL, 0 );
226 n += (strlen( &str[n] ) + 1);
227 } while (str[n]);
228 len++;
229 n++;
230
231 wstr = HeapAlloc( GetProcessHeap(), 0, len*sizeof (WCHAR) );
232 MultiByteToWideChar( CP_ACP, 0, str, n, wstr, len );
233 return wstr;
234 }
235
236 /******************************************************************************
237 * registry access functions and data
238 */
239 static const WCHAR szDisplayName[] = {
240 'D','i','s','p','l','a','y','N','a','m','e', 0 };
241 static const WCHAR szType[] = {'T','y','p','e',0};
242 static const WCHAR szStart[] = {'S','t','a','r','t',0};
243 static const WCHAR szError[] = {
244 'E','r','r','o','r','C','o','n','t','r','o','l', 0};
245 static const WCHAR szImagePath[] = {'I','m','a','g','e','P','a','t','h',0};
246 static const WCHAR szGroup[] = {'G','r','o','u','p',0};
247 static const WCHAR szDependencies[] = {
248 'D','e','p','e','n','d','e','n','c','i','e','s',0};
249 static const WCHAR szDependOnService[] = {
250 'D','e','p','e','n','d','O','n','S','e','r','v','i','c','e',0};
251 static const WCHAR szObjectName[] = {
252 'O','b','j','e','c','t','N','a','m','e',0};
253 static const WCHAR szTag[] = {
254 'T','a','g',0};
255
256 struct reg_value {
257 DWORD type;
258 DWORD size;
259 LPCWSTR name;
260 LPCVOID data;
261 };
262
263 static inline void service_set_value( struct reg_value *val,
264 DWORD type, LPCWSTR name, LPCVOID data, DWORD size )
265 {
266 val->name = name;
267 val->type = type;
268 val->data = data;
269 val->size = size;
270 }
271
272 static inline void service_set_dword( struct reg_value *val,
273 LPCWSTR name, const DWORD *data )
274 {
275 service_set_value( val, REG_DWORD, name, data, sizeof (DWORD));
276 }
277
278 static inline void service_set_string( struct reg_value *val,
279 LPCWSTR name, LPCWSTR string )
280 {
281 DWORD len = (lstrlenW(string)+1) * sizeof (WCHAR);
282 service_set_value( val, REG_SZ, name, string, len );
283 }
284
285 static inline void service_set_multi_string( struct reg_value *val,
286 LPCWSTR name, LPCWSTR string )
287 {
288 DWORD len = 0;
289
290 /* determine the length of a double null terminated multi string */
291 do {
292 len += (lstrlenW( &string[ len ] )+1);
293 } while ( string[ len++ ] );
294
295 len *= sizeof (WCHAR);
296 service_set_value( val, REG_MULTI_SZ, name, string, len );
297 }
298
299 static inline LONG service_write_values( HKEY hKey,
300 const struct reg_value *val, int n )
301 {
302 LONG r = ERROR_SUCCESS;
303 int i;
304
305 for( i=0; i<n; i++ )
306 {
307 r = RegSetValueExW(hKey, val[i].name, 0, val[i].type,
308 (const BYTE*)val[i].data, val[i].size );
309 if( r != ERROR_SUCCESS )
310 break;
311 }
312 return r;
313 }
314
315 /******************************************************************************
316 * Service IPC functions
317 */
318 static LPWSTR service_get_pipe_name(LPCWSTR service)
319 {
320 static const WCHAR prefix[] = { '\\','\\','.','\\','p','i','p','e','\\',
321 '_','_','w','i','n','e','s','e','r','v','i','c','e','_',0};
322 LPWSTR name;
323 DWORD len;
324
325 len = sizeof prefix + strlenW(service)*sizeof(WCHAR);
326 name = HeapAlloc(GetProcessHeap(), 0, len);
327 strcpyW(name, prefix);
328 strcatW(name, service);
329 return name;
330 }
331
332 static HANDLE service_open_pipe(LPCWSTR service)
333 {
334 LPWSTR szPipe = service_get_pipe_name( service );
335 HANDLE handle = INVALID_HANDLE_VALUE;
336
337 do {
338 handle = CreateFileW(szPipe, GENERIC_READ|GENERIC_WRITE,
339 0, NULL, OPEN_ALWAYS, 0, NULL);
340 if (handle != INVALID_HANDLE_VALUE)
341 break;
342 if (GetLastError() != ERROR_PIPE_BUSY)
343 break;
344 } while (WaitNamedPipeW(szPipe, NMPWAIT_WAIT_FOREVER));
345 HeapFree(GetProcessHeap(), 0, szPipe);
346
347 return handle;
348 }
349
350 /******************************************************************************
351 * service_get_event_handle
352 */
353 static HANDLE service_get_event_handle(LPCWSTR service)
354 {
355 static const WCHAR prefix[] = {
356 '_','_','w','i','n','e','s','e','r','v','i','c','e','_',0};
357 LPWSTR name;
358 DWORD len;
359 HANDLE handle;
360
361 len = sizeof prefix + strlenW(service)*sizeof(WCHAR);
362 name = HeapAlloc(GetProcessHeap(), 0, len);
363 strcpyW(name, prefix);
364 strcatW(name, service);
365 handle = CreateEventW(NULL, TRUE, FALSE, name);
366 HeapFree(GetProcessHeap(), 0, name);
367 return handle;
368 }
369
370 /******************************************************************************
371 * service_thread
372 *
373 * Call into the main service routine provided by StartServiceCtrlDispatcher.
374 */
375 static DWORD WINAPI service_thread(LPVOID arg)
376 {
377 service_data *info = arg;
378 LPWSTR str = info->args;
379 DWORD argc = 0, len = 0;
380
381 TRACE("%p\n", arg);
382
383 while (str[len])
384 {
385 len += strlenW(&str[len]) + 1;
386 argc++;
387 }
388
389 if (!argc)
390 {
391 if (info->unicode)
392 info->proc.w(0, NULL);
393 else
394 info->proc.a(0, NULL);
395 return 0;
396 }
397
398 if (info->unicode)
399 {
400 LPWSTR *argv, p;
401
402 argv = HeapAlloc(GetProcessHeap(), 0, (argc+1)*sizeof(LPWSTR));
403 for (argc=0, p=str; *p; p += strlenW(p) + 1)
404 argv[argc++] = p;
405 argv[argc] = NULL;
406
407 info->proc.w(argc, argv);
408 HeapFree(GetProcessHeap(), 0, argv);
409 }
410 else
411 {
412 LPSTR strA, *argv, p;
413 DWORD lenA;
414
415 lenA = WideCharToMultiByte(CP_ACP,0, str, len, NULL, 0, NULL, NULL);
416 strA = HeapAlloc(GetProcessHeap(), 0, lenA);
417 WideCharToMultiByte(CP_ACP,0, str, len, strA, lenA, NULL, NULL);
418
419 argv = HeapAlloc(GetProcessHeap(), 0, (argc+1)*sizeof(LPSTR));
420 for (argc=0, p=strA; *p; p += strlen(p) + 1)
421 argv[argc++] = p;
422 argv[argc] = NULL;
423
424 info->proc.a(argc, argv);
425 HeapFree(GetProcessHeap(), 0, argv);
426 HeapFree(GetProcessHeap(), 0, strA);
427 }
428 return 0;
429 }
430
431 /******************************************************************************
432 * service_handle_start
433 */
434 static BOOL service_handle_start(HANDLE pipe, service_data *service, DWORD count)
435 {
436 DWORD read = 0, result = 0;
437 LPWSTR args;
438 BOOL r;
439
440 TRACE("%p %p %d\n", pipe, service, count);
441
442 args = HeapAlloc(GetProcessHeap(), 0, count*sizeof(WCHAR));
443 r = ReadFile(pipe, args, count*sizeof(WCHAR), &read, NULL);
444 if (!r || count!=read/sizeof(WCHAR) || args[count-1])
445 {
446 ERR("pipe read failed r = %d count = %d read = %d args[n-1]=%s\n",
447 r, count, read, debugstr_wn(args, count));
448 goto end;
449 }
450
451 if (service->thread)
452 {
453 WARN("service is not stopped\n");
454 result = ERROR_SERVICE_ALREADY_RUNNING;
455 goto end;
456 }
457
458 HeapFree(GetProcessHeap(), 0, service->args);
459 service->args = args;
460 args = NULL;
461 service->thread = CreateThread( NULL, 0, service_thread,
462 service, 0, NULL );
463
464 end:
465 HeapFree(GetProcessHeap(), 0, args);
466 WriteFile( pipe, &result, sizeof result, &read, NULL );
467
468 return TRUE;
469 }
470
471 /******************************************************************************
472 * service_send_start_message
473 */
474 static BOOL service_send_start_message(HANDLE pipe, LPCWSTR *argv, DWORD argc)
475 {
476 DWORD i, len, count, result;
477 service_start_info *ssi;
478 LPWSTR p;
479 BOOL r;
480
481 TRACE("%p %p %d\n", pipe, argv, argc);
482
483 /* calculate how much space do we need to send the startup info */
484 len = 1;
485 for (i=0; i<argc; i++)
486 len += strlenW(argv[i])+1;
487
488 ssi = HeapAlloc(GetProcessHeap(),0,sizeof *ssi + (len-1)*sizeof(WCHAR));
489 ssi->cmd = WINESERV_STARTINFO;
490 ssi->size = len;
491
492 /* copy service args into a single buffer*/
493 p = &ssi->str[0];
494 for (i=0; i<argc; i++)
495 {
496 strcpyW(p, argv[i]);
497 p += strlenW(p) + 1;
498 }
499 *p=0;
500
501 r = WriteFile(pipe, ssi, sizeof *ssi + len*sizeof(WCHAR), &count, NULL);
502 if (r)
503 {
504 r = ReadFile(pipe, &result, sizeof result, &count, NULL);
505 if (r && result)
506 {
507 SetLastError(result);
508 r = FALSE;
509 }
510 }
511
512 HeapFree(GetProcessHeap(),0,ssi);
513
514 return r;
515 }
516
517 /******************************************************************************
518 * service_handle_get_status
519 */
520 static BOOL service_handle_get_status(HANDLE pipe, const service_data *service)
521 {
522 DWORD count = 0;
523 TRACE("\n");
524 return WriteFile(pipe, &service->status,
525 sizeof service->status, &count, NULL);
526 }
527
528 /******************************************************************************
529 * service_get_status
530 */
531 static BOOL service_get_status(HANDLE pipe, LPSERVICE_STATUS_PROCESS status)
532 {
533 DWORD cmd[2], count = 0;
534 BOOL r;
535
536 cmd[0] = WINESERV_GETSTATUS;
537 cmd[1] = 0;
538 r = WriteFile( pipe, cmd, sizeof cmd, &count, NULL );
539 if (!r || count != sizeof cmd)
540 {
541 ERR("service protocol error - failed to write pipe!\n");
542 return r;
543 }
544 r = ReadFile( pipe, status, sizeof *status, &count, NULL );
545 if (!r || count != sizeof *status)
546 ERR("service protocol error - failed to read pipe "
547 "r = %d count = %d!\n", r, count);
548 return r;
549 }
550
551 /******************************************************************************
552 * service_send_control
553 */
554 static BOOL service_send_control(HANDLE pipe, DWORD dwControl, DWORD *result)
555 {
556 DWORD cmd[2], count = 0;
557 BOOL r;
558
559 cmd[0] = WINESERV_SENDCONTROL;
560 cmd[1] = dwControl;
561 r = WriteFile(pipe, cmd, sizeof cmd, &count, NULL);
562 if (!r || count != sizeof cmd)
563 {
564 ERR("service protocol error - failed to write pipe!\n");
565 return r;
566 }
567 r = ReadFile(pipe, result, sizeof *result, &count, NULL);
568 if (!r || count != sizeof *result)
569 ERR("service protocol error - failed to read pipe "
570 "r = %d count = %d!\n", r, count);
571 return r;
572 }
573
574 /******************************************************************************
575 * service_accepts_control
576 */
577 static BOOL service_accepts_control(const service_data *service, DWORD dwControl)
578 {
579 DWORD a = service->status.dwControlsAccepted;
580
581 switch (dwControl)
582 {
583 case SERVICE_CONTROL_INTERROGATE:
584 return TRUE;
585 case SERVICE_CONTROL_STOP:
586 if (a&SERVICE_ACCEPT_STOP)
587 return TRUE;
588 break;
589 case SERVICE_CONTROL_SHUTDOWN:
590 if (a&SERVICE_ACCEPT_SHUTDOWN)
591 return TRUE;
592 break;
593 case SERVICE_CONTROL_PAUSE:
594 case SERVICE_CONTROL_CONTINUE:
595 if (a&SERVICE_ACCEPT_PAUSE_CONTINUE)
596 return TRUE;
597 break;
598 case SERVICE_CONTROL_PARAMCHANGE:
599 if (a&SERVICE_ACCEPT_PARAMCHANGE)
600 return TRUE;
601 break;
602 case SERVICE_CONTROL_NETBINDADD:
603 case SERVICE_CONTROL_NETBINDREMOVE:
604 case SERVICE_CONTROL_NETBINDENABLE:
605 case SERVICE_CONTROL_NETBINDDISABLE:
606 if (a&SERVICE_ACCEPT_NETBINDCHANGE)
607 return TRUE;
608 }
609 if (!service->extended)
610 return FALSE;
611 switch (dwControl)
612 {
613 case SERVICE_CONTROL_HARDWAREPROFILECHANGE:
614 if (a&SERVICE_ACCEPT_HARDWAREPROFILECHANGE)
615 return TRUE;
616 break;
617 case SERVICE_CONTROL_POWEREVENT:
618 if (a&SERVICE_ACCEPT_POWEREVENT)
619 return TRUE;
620 break;
621 case SERVICE_CONTROL_SESSIONCHANGE:
622 if (a&SERVICE_ACCEPT_SESSIONCHANGE)
623 return TRUE;
624 break;
625 }
626 return FALSE;
627 }
628
629 /******************************************************************************
630 * service_handle_control
631 */
632 static BOOL service_handle_control(HANDLE pipe, service_data *service,
633 DWORD dwControl)
634 {
635 DWORD count, ret = ERROR_INVALID_SERVICE_CONTROL;
636
637 TRACE("received control %d\n", dwControl);
638
639 if (service_accepts_control(service, dwControl))
640 {
641 if (service->extended && service->handler.handler_ex)
642 {
643 service->handler.handler_ex(dwControl, 0, NULL, service->context);
644 ret = ERROR_SUCCESS;
645 }
646 else if (service->handler.handler)
647 {
648 service->handler.handler(dwControl);
649 ret = ERROR_SUCCESS;
650 }
651 }
652 return WriteFile(pipe, &ret, sizeof ret, &count, NULL);
653 }
654
655 /******************************************************************************
656 * service_reap_thread
657 */
658 static DWORD service_reap_thread(service_data *service)
659 {
660 DWORD exitcode = 0;
661
662 if (!service->thread)
663 return 0;
664 GetExitCodeThread(service->thread, &exitcode);
665 if (exitcode!=STILL_ACTIVE)
666 {
667 CloseHandle(service->thread);
668 service->thread = 0;
669 }
670 return exitcode;
671 }
672
673 /******************************************************************************
674 * service_control_dispatcher
675 */
676 static DWORD WINAPI service_control_dispatcher(LPVOID arg)
677 {
678 service_data *service = arg;
679 LPWSTR name;
680 HANDLE pipe, event;
681
682 TRACE("%p %s\n", service, debugstr_w(service->name));
683
684 /* create a pipe to talk to the rest of the world with */
685 name = service_get_pipe_name(service->name);
686 pipe = CreateNamedPipeW(name, PIPE_ACCESS_DUPLEX,
687 PIPE_TYPE_BYTE|PIPE_WAIT, 1, 256, 256, 10000, NULL );
688 HeapFree(GetProcessHeap(), 0, name);
689
690 /* let the process who started us know we've tried to create a pipe */
691 event = service_get_event_handle(service->name);
692 SetEvent(event);
693 CloseHandle(event);
694
695 if (pipe==INVALID_HANDLE_VALUE)
696 {
697 ERR("failed to create pipe for %s, error = %d\n",
698 debugstr_w(service->name), GetLastError());
699 return 0;
700 }
701
702 /* dispatcher loop */
703 while (1)
704 {
705 BOOL r;
706 DWORD count, req[2] = {0,0};
707
708 r = ConnectNamedPipe(pipe, NULL);
709 if (!r && GetLastError() != ERROR_PIPE_CONNECTED)
710 {
711 ERR("pipe connect failed\n");
712 break;
713 }
714
715 r = ReadFile( pipe, &req, sizeof req, &count, NULL );
716 if (!r || count!=sizeof req)
717 {
718 ERR("pipe read failed\n");
719 break;
720 }
721
722 service_reap_thread(service);
723
724 /* handle the request */
725 switch (req[0])
726 {
727 case WINESERV_STARTINFO:
728 service_handle_start(pipe, service, req[1]);
729 break;
730 case WINESERV_GETSTATUS:
731 service_handle_get_status(pipe, service);
732 break;
733 case WINESERV_SENDCONTROL:
734 service_handle_control(pipe, service, req[1]);
735 break;
736 default:
737 ERR("received invalid command %d length %d\n", req[0], req[1]);
738 }
739
740 FlushFileBuffers(pipe);
741 DisconnectNamedPipe(pipe);
742 }
743
744 CloseHandle(pipe);
745 return 1;
746 }
747
748 /******************************************************************************
749 * service_run_threads
750 */
751 static BOOL service_run_threads(void)
752 {
753 service_data *service;
754 DWORD count, n = 0;
755 HANDLE *handles;
756
757 EnterCriticalSection( &service_cs );
758
759 count = list_count( &service_list );
760
761 TRACE("Starting %d pipe listener threads. Services running as process %d\n", count, GetCurrentProcessId());
762
763 handles = HeapAlloc(GetProcessHeap(), 0, sizeof(HANDLE) * (count + 1));
764
765 handles[n++] = __wine_make_process_system();
766
767 LIST_FOR_EACH_ENTRY( service, &service_list, service_data, entry )
768 {
769 service->status.dwProcessId = GetCurrentProcessId();
770 handles[n++] = CreateThread( NULL, 0, service_control_dispatcher,
771 service, 0, NULL );
772 }
773 assert(n == count + 1);
774
775 LeaveCriticalSection( &service_cs );
776
777 /* wait for all the threads to pack up and exit */
778 while (n > 1)
779 {
780 DWORD ret = WaitForMultipleObjects( min(n,MAXIMUM_WAIT_OBJECTS), handles, FALSE, INFINITE );
781 if (!ret) /* system process event */
782 {
783 TRACE( "last user process exited, shutting down\n" );
784 /* FIXME: we should maybe send a shutdown control to running services */
785 ExitProcess(0);
786 }
787 if (ret < MAXIMUM_WAIT_OBJECTS)
788 {
789 CloseHandle( handles[ret] );
790 memmove( &handles[ret], &handles[ret+1], (n - ret - 1) * sizeof(HANDLE) );
791 n--;
792 }
793 else break;
794 }
795
796 while (n) CloseHandle( handles[--n] );
797 HeapFree(GetProcessHeap(), 0, handles);
798
799 return TRUE;
800 }
801
802 /******************************************************************************
803 * StartServiceCtrlDispatcherA [ADVAPI32.@]
804 *
805 * See StartServiceCtrlDispatcherW.
806 */
807 BOOL WINAPI StartServiceCtrlDispatcherA( const SERVICE_TABLE_ENTRYA *servent )
808 {
809 service_data *info;
810 DWORD sz, len;
811 BOOL ret = TRUE;
812
813 TRACE("%p\n", servent);
814
815 EnterCriticalSection( &service_cs );
816 while (servent->lpServiceName)
817 {
818 LPSTR name = servent->lpServiceName;
819
820 len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
821 sz = len*sizeof(WCHAR) + sizeof *info;
822 info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz );
823 MultiByteToWideChar(CP_ACP, 0, name, -1, info->name, len);
824 info->proc.a = servent->lpServiceProc;
825 info->unicode = FALSE;
826 list_add_head( &service_list, &info->entry );
827 servent++;
828 }
829 LeaveCriticalSection( &service_cs );
830
831 service_run_threads();
832
833 return ret;
834 }
835
836 /******************************************************************************
837 * StartServiceCtrlDispatcherW [ADVAPI32.@]
838 *
839 * Connects a process containing one or more services to the service control
840 * manager.
841 *
842 * PARAMS
843 * servent [I] A list of the service names and service procedures
844 *
845 * RETURNS
846 * Success: TRUE.
847 * Failure: FALSE.
848 */
849 BOOL WINAPI StartServiceCtrlDispatcherW( const SERVICE_TABLE_ENTRYW *servent )
850 {
851 service_data *info;
852 DWORD sz, len;
853 BOOL ret = TRUE;
854
855 TRACE("%p\n", servent);
856
857 EnterCriticalSection( &service_cs );
858 while (servent->lpServiceName)
859 {
860 LPWSTR name = servent->lpServiceName;
861
862 len = strlenW(name);
863 sz = len*sizeof(WCHAR) + sizeof *info;
864 info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz );
865 strcpyW(info->name, name);
866 info->proc.w = servent->lpServiceProc;
867 info->unicode = TRUE;
868 list_add_head( &service_list, &info->entry );
869 servent++;
870 }
871 LeaveCriticalSection( &service_cs );
872
873 service_run_threads();
874
875 return ret;
876 }
877
878 /******************************************************************************
879 * LockServiceDatabase [ADVAPI32.@]
880 */
881 SC_LOCK WINAPI LockServiceDatabase (SC_HANDLE hSCManager)
882 {
883 HANDLE ret;
884
885 TRACE("%p\n",hSCManager);
886
887 ret = CreateSemaphoreW( NULL, 1, 1, szSCMLock );
888 if( ret && GetLastError() == ERROR_ALREADY_EXISTS )
889 {
890 CloseHandle( ret );
891 ret = NULL;
892 SetLastError( ERROR_SERVICE_DATABASE_LOCKED );
893 }
894
895 TRACE("returning %p\n", ret);
896
897 return ret;
898 }
899
900 /******************************************************************************
901 * UnlockServiceDatabase [ADVAPI32.@]
902 */
903 BOOL WINAPI UnlockServiceDatabase (SC_LOCK ScLock)
904 {
905 TRACE("%p\n",ScLock);
906
907 return CloseHandle( ScLock );
908 }
909
910 /******************************************************************************
911 * RegisterServiceCtrlHandlerA [ADVAPI32.@]
912 */
913 SERVICE_STATUS_HANDLE WINAPI
914 RegisterServiceCtrlHandlerA( LPCSTR lpServiceName, LPHANDLER_FUNCTION lpfHandler )
915 {
916 LPWSTR lpServiceNameW;
917 SERVICE_STATUS_HANDLE ret;
918
919 lpServiceNameW = SERV_dup(lpServiceName);
920 ret = RegisterServiceCtrlHandlerW( lpServiceNameW, lpfHandler );
921 HeapFree(GetProcessHeap(), 0, lpServiceNameW);
922 return ret;
923 }
924
925 /******************************************************************************
926 * RegisterServiceCtrlHandlerW [ADVAPI32.@]
927 *
928 * PARAMS
929 * lpServiceName []
930 * lpfHandler []
931 */
932 SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerW( LPCWSTR lpServiceName,
933 LPHANDLER_FUNCTION lpfHandler )
934 {
935 service_data *service;
936 SERVICE_STATUS_HANDLE handle = 0;
937
938 EnterCriticalSection( &service_cs );
939 LIST_FOR_EACH_ENTRY( service, &service_list, service_data, entry )
940 {
941 if(!strcmpW(lpServiceName, service->name))
942 {
943 service->handler.handler = lpfHandler;
944 handle = (SERVICE_STATUS_HANDLE)service;
945 break;
946 }
947 }
948 LeaveCriticalSection( &service_cs );
949 return handle;
950 }
951
952 /******************************************************************************
953 * SetServiceStatus [ADVAPI32.@]
954 *
955 * PARAMS
956 * hService []
957 * lpStatus []
958 */
959 BOOL WINAPI
960 SetServiceStatus( SERVICE_STATUS_HANDLE hService, LPSERVICE_STATUS lpStatus )
961 {
962 service_data *service;
963 BOOL r = FALSE;
964
965 TRACE("%p %x %x %x %x %x %x %x\n", hService,
966 lpStatus->dwServiceType, lpStatus->dwCurrentState,
967 lpStatus->dwControlsAccepted, lpStatus->dwWin32ExitCode,
968 lpStatus->dwServiceSpecificExitCode, lpStatus->dwCheckPoint,
969 lpStatus->dwWaitHint);
970
971 EnterCriticalSection( &service_cs );
972 LIST_FOR_EACH_ENTRY( service, &service_list, service_data, entry )
973 {
974 if(service == (service_data*)hService)
975 {
976 memcpy( &service->status, lpStatus, sizeof(SERVICE_STATUS) );
977 TRACE("Set service status to %d\n",service->status.dwCurrentState);
978 r = TRUE;
979 break;
980 }
981 }
982 LeaveCriticalSection( &service_cs );
983
984 return r;
985 }
986
987
988 /******************************************************************************
989 * OpenSCManagerA [ADVAPI32.@]
990 *
991 * Establish a connection to the service control manager and open its database.
992 *
993 * PARAMS
994 * lpMachineName [I] Pointer to machine name string
995 * lpDatabaseName [I] Pointer to database name string
996 * dwDesiredAccess [I] Type of access
997 *
998 * RETURNS
999 * Success: A Handle to the service control manager database
1000 * Failure: NULL
1001 */
1002 SC_HANDLE WINAPI OpenSCManagerA( LPCSTR lpMachineName, LPCSTR lpDatabaseName,
1003 DWORD dwDesiredAccess )
1004 {
1005 LPWSTR lpMachineNameW, lpDatabaseNameW;
1006 SC_HANDLE ret;
1007
1008 lpMachineNameW = SERV_dup(lpMachineName);
1009 lpDatabaseNameW = SERV_dup(lpDatabaseName);
1010 ret = OpenSCManagerW(lpMachineNameW, lpDatabaseNameW, dwDesiredAccess);
1011 HeapFree(GetProcessHeap(), 0, lpDatabaseNameW);
1012 HeapFree(GetProcessHeap(), 0, lpMachineNameW);
1013 return ret;
1014 }
1015
1016 /******************************************************************************
1017 * OpenSCManagerW [ADVAPI32.@]
1018 *
1019 * See OpenSCManagerA.
1020 */
1021 SC_HANDLE WINAPI OpenSCManagerW( LPCWSTR lpMachineName, LPCWSTR lpDatabaseName,
1022 DWORD dwDesiredAccess )
1023 {
1024 struct sc_manager *manager;
1025 HKEY hReg;
1026 LONG r;
1027 DWORD new_mask = dwDesiredAccess;
1028
1029 TRACE("(%s,%s,0x%08x)\n", debugstr_w(lpMachineName),
1030 debugstr_w(lpDatabaseName), dwDesiredAccess);
1031
1032 if( lpDatabaseName && lpDatabaseName[0] )
1033 {
1034 if( strcmpiW( lpDatabaseName, SERVICES_ACTIVE_DATABASEW ) == 0 )
1035 {
1036 /* noop, all right */
1037 }
1038 else if( strcmpiW( lpDatabaseName, SERVICES_FAILED_DATABASEW ) == 0 )
1039 {
1040 SetLastError( ERROR_DATABASE_DOES_NOT_EXIST );
1041 return NULL;
1042 }
1043 else
1044 {
1045 SetLastError( ERROR_INVALID_NAME );
1046 return NULL;
1047 }
1048 }
1049
1050 manager = sc_handle_alloc( SC_HTYPE_MANAGER, sizeof (struct sc_manager),
1051 sc_handle_destroy_manager );
1052 if (!manager)
1053 return NULL;
1054
1055 r = RegConnectRegistryW(lpMachineName,HKEY_LOCAL_MACHINE,&hReg);
1056 if (r!=ERROR_SUCCESS)
1057 goto error;
1058
1059 r = RegCreateKeyW(hReg, szServiceManagerKey, &manager->hkey);
1060 RegCloseKey( hReg );
1061 if (r!=ERROR_SUCCESS)
1062 goto error;
1063
1064 RtlMapGenericMask(&new_mask, &scm_generic);
1065 manager->dwAccess = new_mask;
1066 TRACE("returning %p (access : 0x%08x)\n", manager, manager->dwAccess);
1067
1068 return (SC_HANDLE) &manager->hdr;
1069
1070 error:
1071 sc_handle_free( &manager->hdr );
1072 SetLastError( r);
1073 return NULL;
1074 }
1075
1076 /******************************************************************************
1077 * ControlService [ADVAPI32.@]
1078 *
1079 * Send a control code to a service.
1080 *
1081 * PARAMS
1082 * hService [I] Handle of the service control manager database
1083 * dwControl [I] Control code to send (SERVICE_CONTROL_* flags from "winsvc.h")
1084 * lpServiceStatus [O] Destination for the status of the service, if available
1085 *
1086 * RETURNS
1087 * Success: TRUE.
1088 * Failure: FALSE.
1089 *
1090 * BUGS
1091 * Unlike M$' implementation, control requests are not serialized and may be
1092 * processed asynchronously.
1093 */
1094 BOOL WINAPI ControlService( SC_HANDLE hService, DWORD dwControl,
1095 LPSERVICE_STATUS lpServiceStatus )
1096 {
1097 struct sc_service *hsvc;
1098 BOOL ret = FALSE;
1099 HANDLE handle;
1100
1101 TRACE("%p %d %p\n", hService, dwControl, lpServiceStatus);
1102
1103 hsvc = sc_handle_get_handle_data(hService, SC_HTYPE_SERVICE);
1104 if (!hsvc)
1105 {
1106 SetLastError( ERROR_INVALID_HANDLE );
1107 return FALSE;
1108 }
1109
1110 ret = QueryServiceStatus(hService, lpServiceStatus);
1111 if (!ret)
1112 {
1113 ERR("failed to query service status\n");
1114 SetLastError(ERROR_SERVICE_NOT_ACTIVE);
1115 return FALSE;
1116 }
1117
1118 switch (lpServiceStatus->dwCurrentState)
1119 {
1120 case SERVICE_STOPPED:
1121 SetLastError(ERROR_SERVICE_NOT_ACTIVE);
1122 return FALSE;
1123 case SERVICE_START_PENDING:
1124 if (dwControl==SERVICE_CONTROL_STOP)
1125 break;
1126 /* fall thru */
1127 case SERVICE_STOP_PENDING:
1128 SetLastError(ERROR_SERVICE_CANNOT_ACCEPT_CTRL);
1129 return FALSE;
1130 }
1131
1132 handle = service_open_pipe(hsvc->name);
1133 if (handle!=INVALID_HANDLE_VALUE)
1134 {
1135 DWORD result = ERROR_SUCCESS;
1136 ret = service_send_control(handle, dwControl, &result);
1137 CloseHandle(handle);
1138 if (result!=ERROR_SUCCESS)
1139 {
1140 SetLastError(result);
1141 ret = FALSE;
1142 }
1143 }
1144
1145 return ret;
1146 }
1147
1148 /******************************************************************************
1149 * CloseServiceHandle [ADVAPI32.@]
1150 *
1151 * Close a handle to a service or the service control manager database.
1152 *
1153 * PARAMS
1154 * hSCObject [I] Handle to service or service control manager database
1155 *
1156 * RETURNS
1157 * Success: TRUE
1158 * Failure: FALSE
1159 */
1160 BOOL WINAPI
1161 CloseServiceHandle( SC_HANDLE hSCObject )
1162 {
1163 TRACE("%p\n", hSCObject);
1164
1165 sc_handle_free( (struct sc_handle*) hSCObject );
1166
1167 return TRUE;
1168 }
1169
1170
1171 /******************************************************************************
1172 * OpenServiceA [ADVAPI32.@]
1173 *
1174 * Open a handle to a service.
1175 *
1176 * PARAMS
1177 * hSCManager [I] Handle of the service control manager database
1178 * lpServiceName [I] Name of the service to open
1179 * dwDesiredAccess [I] Access required to the service
1180 *
1181 * RETURNS
1182 * Success: Handle to the service
1183 * Failure: NULL
1184 */
1185 SC_HANDLE WINAPI OpenServiceA( SC_HANDLE hSCManager, LPCSTR lpServiceName,
1186 DWORD dwDesiredAccess )
1187 {
1188 LPWSTR lpServiceNameW;
1189 SC_HANDLE ret;
1190
1191 TRACE("%p %s %d\n", hSCManager, debugstr_a(lpServiceName), dwDesiredAccess);
1192
1193 lpServiceNameW = SERV_dup(lpServiceName);
1194 ret = OpenServiceW( hSCManager, lpServiceNameW, dwDesiredAccess);
1195 HeapFree(GetProcessHeap(), 0, lpServiceNameW);
1196 return ret;
1197 }
1198
1199
1200 /******************************************************************************
1201 * OpenServiceW [ADVAPI32.@]
1202 *
1203 * See OpenServiceA.
1204 */
1205 SC_HANDLE WINAPI OpenServiceW( SC_HANDLE hSCManager, LPCWSTR lpServiceName,
1206 DWORD dwDesiredAccess)
1207 {
1208 struct sc_manager *hscm;
1209 struct sc_service *hsvc;
1210 HKEY hKey;
1211 long r;
1212 DWORD len;
1213 DWORD new_mask = dwDesiredAccess;
1214
1215 TRACE("%p %s %d\n", hSCManager, debugstr_w(lpServiceName), dwDesiredAccess);
1216
1217 hscm = sc_handle_get_handle_data( hSCManager, SC_HTYPE_MANAGER );
1218 if (!hscm)
1219 {
1220 SetLastError( ERROR_INVALID_HANDLE );
1221 return FALSE;
1222 }
1223
1224 if (!lpServiceName)
1225 {
1226 SetLastError(ERROR_INVALID_ADDRESS);
1227 return NULL;
1228 }
1229
1230 r = RegOpenKeyExW( hscm->hkey, lpServiceName, 0, KEY_ALL_ACCESS, &hKey );
1231 if (r!=ERROR_SUCCESS)
1232 {
1233 SetLastError( ERROR_SERVICE_DOES_NOT_EXIST );
1234 return NULL;
1235 }
1236
1237 len = strlenW(lpServiceName)+1;
1238 hsvc = sc_handle_alloc( SC_HTYPE_SERVICE,
1239 sizeof (struct sc_service) + len*sizeof(WCHAR),
1240 sc_handle_destroy_service );
1241 if (!hsvc)
1242 {
1243 RegCloseKey(hKey);
1244 return NULL;
1245 }
1246 strcpyW( hsvc->name, lpServiceName );
1247 hsvc->hkey = hKey;
1248
1249 RtlMapGenericMask(&new_mask, &svc_generic);
1250 hsvc->dwAccess = new_mask;
1251
1252 /* add reference to SCM handle */
1253 hscm->hdr.ref_count++;
1254 hsvc->scm = hscm;
1255
1256 TRACE("returning %p\n",hsvc);
1257
1258 return (SC_HANDLE) &hsvc->hdr;
1259 }
1260
1261 /******************************************************************************
1262 * CreateServiceW [ADVAPI32.@]
1263 */
1264 SC_HANDLE WINAPI
1265 CreateServiceW( SC_HANDLE hSCManager, LPCWSTR lpServiceName,
1266 LPCWSTR lpDisplayName, DWORD dwDesiredAccess,
1267 DWORD dwServiceType, DWORD dwStartType,
1268 DWORD dwErrorControl, LPCWSTR lpBinaryPathName,
1269 LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId,
1270 LPCWSTR lpDependencies, LPCWSTR lpServiceStartName,
1271 LPCWSTR lpPassword )
1272 {
1273 struct sc_manager *hscm;
1274 struct sc_service *hsvc = NULL;
1275 HKEY hKey;
1276 LONG r;
1277 DWORD dp, len;
1278 struct reg_value val[10];
1279 int n = 0;
1280 DWORD new_mask = dwDesiredAccess;
1281 DWORD index = 0;
1282 WCHAR buffer[MAX_PATH];
1283 BOOL displayname_exists = FALSE;
1284
1285 TRACE("%p %s %s\n", hSCManager,
1286 debugstr_w(lpServiceName), debugstr_w(lpDisplayName));
1287
1288 hscm = sc_handle_get_handle_data( hSCManager, SC_HTYPE_MANAGER );
1289 if (!hscm)
1290 {
1291 SetLastError( ERROR_INVALID_HANDLE );
1292 return NULL;
1293 }
1294
1295 if (!lpServiceName || !lpBinaryPathName)
1296 {
1297 SetLastError(ERROR_INVALID_ADDRESS);
1298 return NULL;
1299 }
1300
1301 if (!(hscm->dwAccess & SC_MANAGER_CREATE_SERVICE))
1302 {
1303 SetLastError(ERROR_ACCESS_DENIED);
1304 return NULL;
1305 }
1306
1307 if (!lpServiceName[0])
1308 {
1309 SetLastError(ERROR_INVALID_NAME);
1310 return NULL;
1311 }
1312
1313 if (!lpBinaryPathName[0])
1314 {
1315 SetLastError(ERROR_INVALID_PARAMETER);
1316 return NULL;
1317 }
1318
1319 /* ServiceType can only be one value (except for SERVICE_INTERACTIVE_PROCESS which can be used
1320 * together with SERVICE_WIN32_OWN_PROCESS or SERVICE_WIN32_SHARE_PROCESS when the service
1321 * runs under the LocalSystem account)
1322 */
1323 switch (dwServiceType)
1324 {
1325 case SERVICE_KERNEL_DRIVER:
1326 case SERVICE_FILE_SYSTEM_DRIVER:
1327 case SERVICE_WIN32_OWN_PROCESS:
1328 case SERVICE_WIN32_SHARE_PROCESS:
1329 /* No problem */
1330 break;
1331 case SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS:
1332 case SERVICE_WIN32_SHARE_PROCESS | SERVICE_INTERACTIVE_PROCESS:
1333 /* FIXME : Do we need a more thorough check? */
1334 if (lpServiceStartName)
1335 {
1336 SetLastError(ERROR_INVALID_PARAMETER);
1337 return NULL;
1338 }
1339 break;
1340 default:
1341 SetLastError(ERROR_INVALID_PARAMETER);
1342 return NULL;
1343 }
1344
1345 /* StartType can only be a single value (if several values are mixed the result is probably not what was intended) */
1346 if (dwStartType > SERVICE_DISABLED)
1347 {
1348 SetLastError(ERROR_INVALID_PARAMETER);
1349 return NULL;
1350 }
1351
1352 /* SERVICE_BOOT_START and SERVICE_SYSTEM_START or only allowed for driver services */
1353 if (((dwStartType == SERVICE_BOOT_START) || (dwStartType == SERVICE_SYSTEM_START)) &&
1354 ((dwServiceType & SERVICE_WIN32_OWN_PROCESS) || (dwServiceType & SERVICE_WIN32_SHARE_PROCESS)))
1355 {
1356 SetLastError(ERROR_INVALID_PARAMETER);
1357 return NULL;
1358 }
1359
1360 /* Loop through the registry to check if the service already exists and to
1361 * check if we can use the given displayname.
1362 * FIXME: Should we use EnumServicesStatusEx?
1363 */
1364 len = sizeof(buffer);
1365 while (RegEnumKeyExW(hscm->hkey, index, buffer, &len, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
1366 {
1367 HKEY service_key;
1368
1369 /* The service already exists, so bail out */
1370 if(!lstrcmpiW(lpServiceName, buffer))
1371 {
1372 SetLastError(ERROR_SERVICE_EXISTS);
1373 return NULL;
1374 }
1375
1376 /* The given displayname matches the found servicename. We don't bail out
1377 * as servicename is checked before a duplicate displayname
1378 */
1379 if(!lstrcmpiW(lpDisplayName, buffer))
1380 displayname_exists = TRUE;
1381
1382 if (RegOpenKeyExW(hscm->hkey, buffer, 0, KEY_READ, &service_key) == ERROR_SUCCESS)
1383 {
1384 WCHAR name[MAX_PATH];
1385 DWORD size = sizeof(name);
1386
1387 if (RegQueryValueExW(service_key, szDisplayName, NULL, NULL, (LPBYTE)name, &size) == ERROR_SUCCESS)
1388 {
1389 /* The given displayname matches the found displayname */
1390 if (!lstrcmpiW(lpDisplayName, name))
1391 displayname_exists = TRUE;
1392 }
1393 RegCloseKey(service_key);
1394 }
1395 index++;
1396 len = sizeof(buffer);
1397 }
1398
1399 if (lpDisplayName && displayname_exists)
1400 {
1401 SetLastError(ERROR_DUPLICATE_SERVICE_NAME);
1402 return NULL;
1403 }
1404
1405 r = RegCreateKeyExW(hscm->hkey, lpServiceName, 0, NULL,
1406 REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &dp);
1407 if (r!=ERROR_SUCCESS)
1408 {
1409 /* FIXME: Should we set an error? */
1410 return NULL;
1411 }
1412
1413 if( lpDisplayName )
1414 service_set_string( &val[n++], szDisplayName, lpDisplayName );
1415
1416 service_set_dword( &val[n++], szType, &dwServiceType );
1417 service_set_dword( &val[n++], szStart, &dwStartType );
1418 service_set_dword( &val[n++], szError, &dwErrorControl );
1419
1420 service_set_string( &val[n++], szImagePath, lpBinaryPathName );
1421
1422 if( lpLoadOrderGroup )
1423 service_set_string( &val[n++], szGroup, lpLoadOrderGroup );
1424
1425 /* FIXME: lpDependencies is used to create both DependOnService and DependOnGroup
1426 * There is no such key as what szDependencies refers to */
1427 if( lpDependencies )
1428 service_set_multi_string( &val[n++], szDependencies, lpDependencies );
1429
1430 if( lpPassword )
1431 FIXME("Don't know how to add a Password for a service.\n");
1432
1433 if( lpServiceStartName )
1434 service_set_string( &val[n++], szObjectName, lpServiceStartName );
1435
1436 r = service_write_values( hKey, val, n );
1437 if( r != ERROR_SUCCESS )
1438 goto error;
1439
1440 len = strlenW(lpServiceName)+1;
1441 len = sizeof (struct sc_service) + len*sizeof(WCHAR);
1442 hsvc = sc_handle_alloc( SC_HTYPE_SERVICE, len, sc_handle_destroy_service );
1443 if( !hsvc )
1444 goto error;
1445 lstrcpyW( hsvc->name, lpServiceName );
1446 hsvc->hkey = hKey;
1447
1448 RtlMapGenericMask(&new_mask, &svc_generic);
1449 hsvc->dwAccess = new_mask;
1450
1451 hsvc->scm = hscm;
1452 hscm->hdr.ref_count++;
1453
1454 return (SC_HANDLE) &hsvc->hdr;
1455
1456 error:
1457 RegCloseKey( hKey );
1458 return NULL;
1459 }
1460
1461
1462 /******************************************************************************
1463 * CreateServiceA [ADVAPI32.@]
1464 */
1465 SC_HANDLE WINAPI
1466 CreateServiceA( SC_HANDLE hSCManager, LPCSTR lpServiceName,
1467 LPCSTR lpDisplayName, DWORD dwDesiredAccess,
1468 DWORD dwServiceType, DWORD dwStartType,
1469 DWORD dwErrorControl, LPCSTR lpBinaryPathName,
1470 LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId,
1471 LPCSTR lpDependencies, LPCSTR lpServiceStartName,
1472 LPCSTR lpPassword )
1473 {
1474 LPWSTR lpServiceNameW, lpDisplayNameW, lpBinaryPathNameW,
1475 lpLoadOrderGroupW, lpDependenciesW, lpServiceStartNameW, lpPasswordW;
1476 SC_HANDLE r;
1477
1478 TRACE("%p %s %s\n", hSCManager,
1479 debugstr_a(lpServiceName), debugstr_a(lpDisplayName));
1480
1481 lpServiceNameW = SERV_dup( lpServiceName );
1482 lpDisplayNameW = SERV_dup( lpDisplayName );
1483 lpBinaryPathNameW = SERV_dup( lpBinaryPathName );
1484 lpLoadOrderGroupW = SERV_dup( lpLoadOrderGroup );
1485 lpDependenciesW = SERV_dupmulti( lpDependencies );
1486 lpServiceStartNameW = SERV_dup( lpServiceStartName );
1487 lpPasswordW = SERV_dup( lpPassword );
1488
1489 r = CreateServiceW( hSCManager, lpServiceNameW, lpDisplayNameW,
1490 dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
1491 lpBinaryPathNameW, lpLoadOrderGroupW, lpdwTagId,
1492 lpDependenciesW, lpServiceStartNameW, lpPasswordW );
1493
1494 HeapFree( GetProcessHeap(), 0, lpServiceNameW );
1495 HeapFree( GetProcessHeap(), 0, lpDisplayNameW );
1496 HeapFree( GetProcessHeap(), 0, lpBinaryPathNameW );
1497 HeapFree( GetProcessHeap(), 0, lpLoadOrderGroupW );
1498 HeapFree( GetProcessHeap(), 0, lpDependenciesW );
1499 HeapFree( GetProcessHeap(), 0, lpServiceStartNameW );
1500 HeapFree( GetProcessHeap(), 0, lpPasswordW );
1501
1502 return r;
1503 }
1504
1505
1506 /******************************************************************************
1507 * DeleteService [ADVAPI32.@]
1508 *
1509 * Delete a service from the service control manager database.
1510 *
1511 * PARAMS
1512 * hService [I] Handle of the service to delete
1513 *
1514 * RETURNS
1515 * Success: TRUE
1516 * Failure: FALSE
1517 */
1518 BOOL WINAPI DeleteService( SC_HANDLE hService )
1519 {
1520 struct sc_service *hsvc;
1521
1522 hsvc = sc_handle_get_handle_data(hService, SC_HTYPE_SERVICE);
1523 if (!hsvc)
1524 {
1525 SetLastError( ERROR_INVALID_HANDLE );
1526 return FALSE;
1527 }
1528
1529 if (!(hsvc->dwAccess & DELETE))
1530 {
1531 SetLastError(ERROR_ACCESS_DENIED);
1532 return FALSE;
1533 }
1534
1535 /* Close the key to the service */
1536 RegCloseKey(hsvc->hkey);
1537
1538 /* Delete the service under the Service Control Manager key */
1539 RegDeleteTreeW(hsvc->scm->hkey, hsvc->name);
1540
1541 hsvc->hkey = NULL;
1542
1543 return TRUE;
1544 }
1545
1546
1547 /******************************************************************************
1548 * StartServiceA [ADVAPI32.@]
1549 *
1550 * Start a service
1551 *
1552 * PARAMS
1553 * hService [I] Handle of service
1554 * dwNumServiceArgs [I] Number of arguments
1555 * lpServiceArgVectors [I] Address of array of argument strings
1556 *
1557 * NOTES
1558 * - NT implements this function using an obscure RPC call.
1559 * - You might need to do a "setenv SystemRoot \\WINNT" in your .cshrc
1560 * to get things like "%SystemRoot%\\System32\\service.exe" to load.
1561 * - This will only work for shared address space. How should the service
1562 * args be transferred when address spaces are separated?
1563 * - Can only start one service at a time.
1564 * - Has no concept of privilege.
1565 *
1566 * RETURNS
1567 * Success: TRUE.
1568 * Failure: FALSE
1569 */
1570 BOOL WINAPI StartServiceA( SC_HANDLE hService, DWORD dwNumServiceArgs,
1571 LPCSTR *lpServiceArgVectors )
1572 {
1573 LPWSTR *lpwstr=NULL;
1574 unsigned int i;
1575 BOOL r;
1576
1577 TRACE("(%p,%d,%p)\n",hService,dwNumServiceArgs,lpServiceArgVectors);
1578
1579 if (dwNumServiceArgs)
1580 lpwstr = HeapAlloc( GetProcessHeap(), 0,
1581 dwNumServiceArgs*sizeof(LPWSTR) );
1582
1583 for(i=0; i<dwNumServiceArgs; i++)
1584 lpwstr[i]=SERV_dup(lpServiceArgVectors[i]);
1585
1586 r = StartServiceW(hService, dwNumServiceArgs, (LPCWSTR *)lpwstr);
1587
1588 if (dwNumServiceArgs)
1589 {
1590 for(i=0; i<dwNumServiceArgs; i++)
1591 HeapFree(GetProcessHeap(), 0, lpwstr[i]);
1592 HeapFree(GetProcessHeap(), 0, lpwstr);
1593 }
1594
1595 return r;
1596 }
1597
1598 /******************************************************************************
1599 * service_start_process [INTERNAL]
1600 */
1601 static DWORD service_start_process(struct sc_service *hsvc, LPDWORD ppid)
1602 {
1603 static const WCHAR _ImagePathW[] = {'I','m','a','g','e','P','a','t','h',0};
1604 PROCESS_INFORMATION pi;
1605 STARTUPINFOW si;
1606 LPWSTR path = NULL, str;
1607 DWORD type, size, ret, svc_type;
1608 HANDLE handles[2];
1609 BOOL r;
1610
1611 size = sizeof(svc_type);
1612 if (RegQueryValueExW(hsvc->hkey, szType, NULL, &type, (LPBYTE)&svc_type, &size) || type != REG_DWORD)
1613 svc_type = 0;
1614
1615 if (svc_type == SERVICE_KERNEL_DRIVER)
1616 {
1617 static const WCHAR winedeviceW[] = {'\\','w','i','n','e','d','e','v','i','c','e','.','e','x','e',' ',0};
1618 DWORD len = GetSystemDirectoryW( NULL, 0 ) + sizeof(winedeviceW)/sizeof(WCHAR) + strlenW(hsvc->name);
1619
1620 if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return FALSE;
1621 GetSystemDirectoryW( path, len );
1622 lstrcatW( path, winedeviceW );
1623 lstrcatW( path, hsvc->name );
1624 }
1625 else
1626 {
1627 /* read the executable path from the registry */
1628 size = 0;
1629 ret = RegQueryValueExW(hsvc->hkey, _ImagePathW, NULL, &type, NULL, &size);
1630 if (ret!=ERROR_SUCCESS)
1631 return FALSE;
1632 str = HeapAlloc(GetProcessHeap(),0,size);
1633 ret = RegQueryValueExW(hsvc->hkey, _ImagePathW, NULL, &type, (LPBYTE)str, &size);
1634 if (ret==ERROR_SUCCESS)
1635 {
1636 size = ExpandEnvironmentStringsW(str,NULL,0);
1637 path = HeapAlloc(GetProcessHeap(),0,size*sizeof(WCHAR));
1638 ExpandEnvironmentStringsW(str,path,size);
1639 }
1640 HeapFree(GetProcessHeap(),0,str);
1641 if (!path)
1642 return FALSE;
1643 }
1644
1645 /* wait for the process to start and set an event or terminate */
1646 handles[0] = service_get_event_handle( hsvc->name );
1647 ZeroMemory(&si, sizeof(STARTUPINFOW));
1648 si.cb = sizeof(STARTUPINFOW);
1649 r = CreateProcessW(NULL, path, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
1650 if (r)
1651 {
1652 if (ppid) *ppid = pi.dwProcessId;
1653
1654 handles[1] = pi.hProcess;
1655 ret = WaitForMultipleObjectsEx(2, handles, FALSE, 30000, FALSE);
1656 if(ret != WAIT_OBJECT_0)
1657 {
1658 SetLastError(ERROR_IO_PENDING);
1659 r = FALSE;
1660 }
1661
1662 CloseHandle( pi.hThread );
1663 CloseHandle( pi.hProcess );
1664 }
1665 CloseHandle( handles[0] );
1666 HeapFree(GetProcessHeap(),0,path);
1667 return r;
1668 }
1669
1670 static BOOL service_wait_for_startup(SC_HANDLE hService)
1671 {
1672 DWORD i;
1673 SERVICE_STATUS status;
1674 BOOL r = FALSE;
1675
1676 TRACE("%p\n", hService);
1677
1678 for (i=0; i<30; i++)
1679 {
1680 status.dwCurrentState = 0;
1681 r = QueryServiceStatus(hService, &status);
1682 if (!r)
1683 break;
1684 if (status.dwCurrentState == SERVICE_RUNNING)
1685 {
1686 TRACE("Service started successfully\n");
1687 break;
1688 }
1689 r = FALSE;
1690 Sleep(1000);
1691 }
1692 return r;
1693 }
1694
1695 /******************************************************************************
1696 * StartServiceW [ADVAPI32.@]
1697 *
1698 * See StartServiceA.
1699 */
1700 BOOL WINAPI StartServiceW(SC_HANDLE hService, DWORD dwNumServiceArgs,
1701 LPCWSTR *lpServiceArgVectors)
1702 {
1703 struct sc_service *hsvc;
1704 BOOL r = FALSE;
1705 SC_LOCK hLock;
1706 HANDLE handle = INVALID_HANDLE_VALUE;
1707
1708 TRACE("%p %d %p\n", hService, dwNumServiceArgs, lpServiceArgVectors);
1709
1710 hsvc = sc_handle_get_handle_data(hService, SC_HTYPE_SERVICE);
1711 if (!hsvc)
1712 {
1713 SetLastError(ERROR_INVALID_HANDLE);
1714 return r;
1715 }
1716
1717 hLock = LockServiceDatabase((SC_HANDLE)hsvc->scm);
1718 if (!hLock)
1719 return r;
1720
1721 handle = service_open_pipe(hsvc->name);
1722 if (handle==INVALID_HANDLE_VALUE)
1723 {
1724 /* start the service process */
1725 if (service_start_process(hsvc, NULL))
1726 handle = service_open_pipe(hsvc->name);
1727 }
1728
1729 if (handle != INVALID_HANDLE_VALUE)
1730 {
1731 r = service_send_start_message(handle, lpServiceArgVectors, dwNumServiceArgs);
1732 CloseHandle(handle);
1733 }
1734
1735 UnlockServiceDatabase( hLock );
1736
1737 TRACE("returning %d\n", r);
1738
1739 if (r)
1740 service_wait_for_startup(hService);
1741
1742 return r;
1743 }
1744
1745 /******************************************************************************
1746 * QueryServiceStatus [ADVAPI32.@]
1747 *
1748 * PARAMS
1749 * hService [I] Handle to service to get information about
1750 * lpservicestatus [O] buffer to receive the status information for the service
1751 *
1752 */
1753 BOOL WINAPI QueryServiceStatus(SC_HANDLE hService,
1754 LPSERVICE_STATUS lpservicestatus)
1755 {
1756 SERVICE_STATUS_PROCESS SvcStatusData;
1757 BOOL ret;
1758
1759 TRACE("%p %p\n", hService, lpservicestatus);
1760
1761 ret = QueryServiceStatusEx(hService, SC_STATUS_PROCESS_INFO, (LPBYTE)&SvcStatusData,
1762 sizeof(SERVICE_STATUS_PROCESS), NULL);
1763 if (ret) memcpy(lpservicestatus, &SvcStatusData, sizeof(SERVICE_STATUS)) ;
1764 return ret;
1765 }
1766
1767
1768 /******************************************************************************
1769 * QueryServiceStatusEx [ADVAPI32.@]
1770 *
1771 * Get information about a service.
1772 *
1773 * PARAMS
1774 * hService [I] Handle to service to get information about
1775 * InfoLevel [I] Level of information to get
1776 * lpBuffer [O] Destination for requested information
1777 * cbBufSize [I] Size of lpBuffer in bytes
1778 * pcbBytesNeeded [O] Destination for number of bytes needed, if cbBufSize is too small
1779 *
1780 * RETURNS
1781 * Success: TRUE
1782 * FAILURE: FALSE
1783 */
1784 BOOL WINAPI QueryServiceStatusEx(SC_HANDLE hService, SC_STATUS_TYPE InfoLevel,
1785 LPBYTE lpBuffer, DWORD cbBufSize,
1786 LPDWORD pcbBytesNeeded)
1787 {
1788 struct sc_service *hsvc;
1789 DWORD size, type, val;
1790 HANDLE pipe;
1791 LONG r;
1792 LPSERVICE_STATUS_PROCESS pSvcStatusData;
1793
1794 TRACE("%p %d %p %d %p\n", hService, InfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
1795
1796 if (InfoLevel != SC_STATUS_PROCESS_INFO)
1797 {
1798 SetLastError( ERROR_INVALID_LEVEL);
1799 return FALSE;
1800 }
1801
1802 pSvcStatusData = (LPSERVICE_STATUS_PROCESS) lpBuffer;
1803 if (pSvcStatusData == NULL)
1804 {
1805 SetLastError( ERROR_INVALID_PARAMETER);
1806 return FALSE;
1807 }
1808
1809 if (cbBufSize < sizeof(SERVICE_STATUS_PROCESS))
1810 {
1811 if( pcbBytesNeeded != NULL)
1812 *pcbBytesNeeded = sizeof(SERVICE_STATUS_PROCESS);
1813
1814 SetLastError( ERROR_INSUFFICIENT_BUFFER);
1815 return FALSE;
1816 }
1817
1818 hsvc = sc_handle_get_handle_data(hService, SC_HTYPE_SERVICE);
1819 if (!hsvc)
1820 {
1821 SetLastError( ERROR_INVALID_HANDLE );
1822 return FALSE;
1823 }
1824
1825 pipe = service_open_pipe(hsvc->name);
1826 if (pipe != INVALID_HANDLE_VALUE)
1827 {
1828 r = service_get_status(pipe, pSvcStatusData);
1829 CloseHandle(pipe);
1830 if (r)
1831 return TRUE;
1832 }
1833
1834 TRACE("Failed to read service status\n");
1835
1836 /* read the service type from the registry */
1837 size = sizeof(val);
1838 r = RegQueryValueExA(hsvc->hkey, "Type", NULL, &type, (LPBYTE)&val, &size);
1839 if (r != ERROR_SUCCESS || type != REG_DWORD)
1840 val = 0;
1841
1842 pSvcStatusData->dwServiceType = val;
1843 pSvcStatusData->dwCurrentState = SERVICE_STOPPED; /* stopped */
1844 pSvcStatusData->dwControlsAccepted = 0;
1845 pSvcStatusData->dwWin32ExitCode = ERROR_SERVICE_NEVER_STARTED;
1846 pSvcStatusData->dwServiceSpecificExitCode = 0;
1847 pSvcStatusData->dwCheckPoint = 0;
1848 pSvcStatusData->dwWaitHint = 0;
1849
1850 return TRUE;
1851 }
1852
1853 /******************************************************************************
1854 * QueryServiceConfigA [ADVAPI32.@]
1855 */
1856 BOOL WINAPI QueryServiceConfigA( SC_HANDLE hService, LPQUERY_SERVICE_CONFIGA config,
1857 DWORD size, LPDWORD needed )
1858 {
1859 DWORD n;
1860 LPSTR p, buffer;
1861 BOOL ret;
1862 QUERY_SERVICE_CONFIGW *configW;
1863
1864 TRACE("%p %p %d %p\n", hService, config, size, needed);
1865
1866 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, 2 * size )))
1867 {
1868 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1869 return FALSE;
1870 }
1871 configW = (QUERY_SERVICE_CONFIGW *)buffer;
1872 ret = QueryServiceConfigW( hService, configW, 2 * size, needed );
1873 if (!ret) goto done;
1874
1875 config->dwServiceType = configW->dwServiceType;
1876 config->dwStartType = configW->dwStartType;
1877 config->dwErrorControl = configW->dwErrorControl;
1878 config->lpBinaryPathName = NULL;
1879 config->lpLoadOrderGroup = NULL;
1880 config->dwTagId = configW->dwTagId;
1881 config->lpDependencies = NULL;
1882 config->lpServiceStartName = NULL;
1883 config->lpDisplayName = NULL;
1884
1885 p = (LPSTR)(config + 1);
1886 n = size - sizeof(*config);
1887 ret = FALSE;
1888
1889 #define MAP_STR(str) \
1890 do { \
1891 if (configW->str) \
1892 { \
1893 DWORD sz = WideCharToMultiByte( CP_ACP, 0, configW->str, -1, p, n, NULL, NULL ); \
1894 if (!sz) goto done; \
1895 config->str = p; \
1896 p += sz; \
1897 n -= sz; \
1898 } \
1899 } while (0)
1900
1901 MAP_STR( lpBinaryPathName );
1902 MAP_STR( lpLoadOrderGroup );
1903 MAP_STR( lpDependencies );
1904 MAP_STR( lpServiceStartName );
1905 MAP_STR( lpDisplayName );
1906 #undef MAP_STR
1907
1908 *needed = p - (LPSTR)config;
1909 ret = TRUE;
1910
1911 done:
1912 HeapFree( GetProcessHeap(), 0, buffer );
1913 return ret;
1914 }
1915
1916 /******************************************************************************
1917 * QueryServiceConfigW [ADVAPI32.@]
1918 */
1919 BOOL WINAPI
1920 QueryServiceConfigW( SC_HANDLE hService,
1921 LPQUERY_SERVICE_CONFIGW lpServiceConfig,
1922 DWORD cbBufSize, LPDWORD pcbBytesNeeded)
1923 {
1924 WCHAR str_buffer[ MAX_PATH ];
1925 LONG r;
1926 DWORD type, val, sz, total, n;
1927 LPBYTE p;
1928 HKEY hKey;
1929 struct sc_service *hsvc;
1930
1931 TRACE("%p %p %d %p\n", hService, lpServiceConfig,
1932 cbBufSize, pcbBytesNeeded);
1933
1934 hsvc = sc_handle_get_handle_data(hService, SC_HTYPE_SERVICE);
1935 if (!hsvc)
1936 {
1937 SetLastError( ERROR_INVALID_HANDLE );
1938 return FALSE;
1939 }
1940 hKey = hsvc->hkey;
1941
1942 /* TODO: Check which members are mandatory and what the registry types
1943 * should be. This should of course also be tested when a service is
1944 * created.
1945 */
1946
1947 /* calculate the size required first */
1948 total = sizeof (QUERY_SERVICE_CONFIGW);
1949
1950 sz = sizeof(str_buffer);
1951 r = RegQueryValueExW( hKey, szImagePath, 0, &type, (LPBYTE) str_buffer, &sz );
1952 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ || type == REG_EXPAND_SZ ) )
1953 {
1954 sz = ExpandEnvironmentStringsW(str_buffer,NULL,0);
1955 if( 0 == sz ) return FALSE;
1956
1957 total += sizeof(WCHAR) * sz;
1958 }
1959 else
1960 {
1961 /* FIXME: set last error */
1962 return FALSE;
1963 }
1964
1965 sz = 0;
1966 r = RegQueryValueExW( hKey, szGroup, 0, &type, NULL, &sz );
1967 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
1968 total += sz;
1969 else
1970 total += sizeof(WCHAR);
1971
1972 sz = 0;
1973 r = RegQueryValueExW( hKey, szDependencies, 0, &type, NULL, &sz );
1974 if( ( r == ERROR_SUCCESS ) && ( type == REG_MULTI_SZ ) )
1975 total += sz;
1976 else
1977 total += sizeof(WCHAR);
1978
1979 sz = 0;
1980 r = RegQueryValueExW( hKey, szObjectName, 0, &type, NULL, &sz );
1981 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
1982 total += sz;
1983 else
1984 total += sizeof(WCHAR);
1985
1986 sz = 0;
1987 r = RegQueryValueExW( hKey, szDisplayName, 0, &type, NULL, &sz );
1988 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
1989 total += sz;
1990 else
1991 total += sizeof(WCHAR);
1992
1993 *pcbBytesNeeded = total;
1994
1995 /* if there's not enough memory, return an error */
1996 if( total > cbBufSize )
1997 {
1998 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1999 return FALSE;
2000 }
2001
2002 ZeroMemory( lpServiceConfig, total );
2003
2004 sz = sizeof val;
2005 r = RegQueryValueExW( hKey, szType, 0, &type, (LPBYTE)&val, &sz );
2006 if( ( r == ERROR_SUCCESS ) && ( type == REG_DWORD ) )
2007 lpServiceConfig->dwServiceType = val;
2008
2009 sz = sizeof val;
2010 r = RegQueryValueExW( hKey, szStart, 0, &type, (LPBYTE)&val, &sz );
2011 if( ( r == ERROR_SUCCESS ) && ( type == REG_DWORD ) )
2012 lpServiceConfig->dwStartType = val;
2013
2014 sz = sizeof val;
2015 r = RegQueryValueExW( hKey, szError, 0, &type, (LPBYTE)&val, &sz );
2016 if( ( r == ERROR_SUCCESS ) && ( type == REG_DWORD ) )
2017 lpServiceConfig->dwErrorControl = val;
2018
2019 sz = sizeof val;
2020 r = RegQueryValueExW( hKey, szTag, 0, &type, (LPBYTE)&val, &sz );
2021 if( ( r == ERROR_SUCCESS ) && ( type == REG_DWORD ) )
2022 lpServiceConfig->dwTagId = val;
2023
2024 /* now do the strings */
2025 p = (LPBYTE) &lpServiceConfig[1];
2026 n = total - sizeof (QUERY_SERVICE_CONFIGW);
2027
2028 sz = sizeof(str_buffer);
2029 r = RegQueryValueExW( hKey, szImagePath, 0, &type, (LPBYTE) str_buffer, &sz );
2030 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ || type == REG_EXPAND_SZ ) )
2031 {
2032 sz = ExpandEnvironmentStringsW(str_buffer, (LPWSTR) p, n);
2033 sz *= sizeof(WCHAR);
2034 if( 0 == sz || sz > n ) return FALSE;
2035
2036 lpServiceConfig->lpBinaryPathName = (LPWSTR) p;
2037 p += sz;
2038 n -= sz;
2039 }
2040 else
2041 {
2042 /* FIXME: set last error */
2043 return FALSE;
2044 }
2045
2046 sz = n;
2047 r = RegQueryValueExW( hKey, szGroup, 0, &type, p, &sz );
2048 lpServiceConfig->lpLoadOrderGroup = (LPWSTR) p;
2049 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
2050 {
2051 p += sz;
2052 n -= sz;
2053 }
2054 else
2055 {
2056 *(WCHAR *) p = 0;
2057 p += sizeof(WCHAR);
2058 n -= sizeof(WCHAR);
2059 }
2060
2061 sz = n;
2062 r = RegQueryValueExW( hKey, szDependencies, 0, &type, p, &sz );
2063 lpServiceConfig->lpDependencies = (LPWSTR) p;
2064 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
2065 {
2066 p += sz;
2067 n -= sz;
2068 }
2069 else
2070 {
2071 *(WCHAR *) p = 0;
2072 p += sizeof(WCHAR);
2073 n -= sizeof(WCHAR);
2074 }
2075
2076 sz = n;
2077 r = RegQueryValueExW( hKey, szObjectName, 0, &type, p, &sz );
2078 lpServiceConfig->lpServiceStartName = (LPWSTR) p;
2079 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
2080 {
2081 p += sz;
2082 n -= sz;
2083 }
2084 else
2085 {
2086 *(WCHAR *) p = 0;
2087 p += sizeof(WCHAR);
2088 n -= sizeof(WCHAR);
2089 }
2090
2091 sz = n;
2092 r = RegQueryValueExW( hKey, szDisplayName, 0, &type, p, &sz );
2093 lpServiceConfig->lpDisplayName = (LPWSTR) p;
2094 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
2095 {
2096 p += sz;
2097 n -= sz;
2098 }
2099 else
2100 {
2101 *(WCHAR *) p = 0;
2102 p += sizeof(WCHAR);
2103 n -= sizeof(WCHAR);
2104 }
2105
2106 if( n < 0 )
2107 ERR("Buffer overflow!\n");
2108
2109 TRACE("Image path = %s\n", debugstr_w(lpServiceConfig->lpBinaryPathName) );
2110 TRACE("Group = %s\n", debugstr_w(lpServiceConfig->lpLoadOrderGroup) );
2111 TRACE("Dependencies = %s\n", debugstr_w(lpServiceConfig->lpDependencies) );
2112 TRACE("Service account name = %s\n", debugstr_w(lpServiceConfig->lpServiceStartName) );
2113 TRACE("Display name = %s\n", debugstr_w(lpServiceConfig->lpDisplayName) );
2114
2115 return TRUE;
2116 }
2117
2118 /******************************************************************************
2119 * EnumServicesStatusA [ADVAPI32.@]
2120 */
2121 BOOL WINAPI
2122 EnumServicesStatusA( SC_HANDLE hSCManager, DWORD dwServiceType,
2123 DWORD dwServiceState, LPENUM_SERVICE_STATUSA lpServices,
2124 DWORD cbBufSize, LPDWORD pcbBytesNeeded,
2125 LPDWORD lpServicesReturned, LPDWORD lpResumeHandle )
2126 {
2127 FIXME("%p type=%x state=%x %p %x %p %p %p\n", hSCManager,
2128 dwServiceType, dwServiceState, lpServices, cbBufSize,
2129 pcbBytesNeeded, lpServicesReturned, lpResumeHandle);
2130 SetLastError (ERROR_ACCESS_DENIED);
2131 return FALSE;
2132 }
2133
2134 /******************************************************************************
2135 * EnumServicesStatusW [ADVAPI32.@]
2136 */
2137 BOOL WINAPI
2138 EnumServicesStatusW( SC_HANDLE hSCManager, DWORD dwServiceType,
2139 DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices,
2140 DWORD cbBufSize, LPDWORD pcbBytesNeeded,
2141 LPDWORD lpServicesReturned, LPDWORD lpResumeHandle )
2142 {
2143 FIXME("%p type=%x state=%x %p %x %p %p %p\n", hSCManager,
2144 dwServiceType, dwServiceState, lpServices, cbBufSize,
2145 pcbBytesNeeded, lpServicesReturned, lpResumeHandle);
2146 SetLastError (ERROR_ACCESS_DENIED);
2147 return FALSE;
2148 }
2149
2150 /******************************************************************************
2151 * EnumServicesStatusExA [ADVAPI32.@]
2152 */
2153 BOOL WINAPI
2154 EnumServicesStatusExA(SC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType,
2155 DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded,
2156 LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCSTR pszGroupName)
2157 {
2158 FIXME("%p level=%d type=%x state=%x %p %x %p %p %p %s\n", hSCManager, InfoLevel,
2159 dwServiceType, dwServiceState, lpServices, cbBufSize,
2160 pcbBytesNeeded, lpServicesReturned, lpResumeHandle, debugstr_a(pszGroupName));
2161 SetLastError (ERROR_ACCESS_DENIED);
2162 return FALSE;
2163 }
2164
2165 /******************************************************************************
2166 * EnumServicesStatusExW [ADVAPI32.@]
2167 */
2168 BOOL WINAPI
2169 EnumServicesStatusExW(SC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType,
2170 DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded,
2171 LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCWSTR pszGroupName)
2172 {
2173 FIXME("%p level=%d type=%x state=%x %p %x %p %p %p %s\n", hSCManager, InfoLevel,
2174 dwServiceType, dwServiceState, lpServices, cbBufSize,
2175 pcbBytesNeeded, lpServicesReturned, lpResumeHandle, debugstr_w(pszGroupName));
2176 SetLastError (ERROR_ACCESS_DENIED);
2177 return FALSE;
2178 }
2179
2180 /******************************************************************************
2181 * GetServiceKeyNameA [ADVAPI32.@]
2182 */
2183 BOOL WINAPI GetServiceKeyNameA( SC_HANDLE hSCManager, LPCSTR lpDisplayName,
2184 LPSTR lpServiceName, LPDWORD lpcchBuffer )
2185 {
2186 FIXME("%p %s %p %p\n", hSCManager, debugstr_a(lpDisplayName), lpServiceName, lpcchBuffer);
2187 return FALSE;
2188 }
2189
2190 /******************************************************************************
2191 * GetServiceKeyNameW [ADVAPI32.@]
2192 */
2193 BOOL WINAPI GetServiceKeyNameW( SC_HANDLE hSCManager, LPCWSTR lpDisplayName,
2194 LPWSTR lpServiceName, LPDWORD lpcchBuffer )
2195 {
2196 FIXME("%p %s %p %p\n", hSCManager, debugstr_w(lpDisplayName), lpServiceName, lpcchBuffer);
2197 return FALSE;
2198 }
2199
2200 /******************************************************************************
2201 * QueryServiceLockStatusA [ADVAPI32.@]
2202 */
2203 BOOL WINAPI QueryServiceLockStatusA( SC_HANDLE hSCManager,
2204 LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus,
2205 DWORD cbBufSize, LPDWORD pcbBytesNeeded)
2206 {
2207 FIXME("%p %p %08x %p\n", hSCManager, lpLockStatus, cbBufSize, pcbBytesNeeded);
2208
2209 return FALSE;
2210 }
2211
2212 /******************************************************************************
2213 * QueryServiceLockStatusW [ADVAPI32.@]
2214 */
2215 BOOL WINAPI QueryServiceLockStatusW( SC_HANDLE hSCManager,
2216 LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus,
2217 DWORD cbBufSize, LPDWORD pcbBytesNeeded)
2218 {
2219 FIXME("%p %p %08x %p\n", hSCManager, lpLockStatus, cbBufSize, pcbBytesNeeded);
2220
2221 return FALSE;
2222 }
2223
2224 /******************************************************************************
2225 * GetServiceDisplayNameA [ADVAPI32.@]
2226 */
2227 BOOL WINAPI GetServiceDisplayNameA( SC_HANDLE hSCManager, LPCSTR lpServiceName,
2228 LPSTR lpDisplayName, LPDWORD lpcchBuffer)
2229 {
2230 LPWSTR lpServiceNameW, lpDisplayNameW = NULL;
2231 DWORD size, sizeW, GLE;
2232 BOOL ret;
2233
2234 TRACE("%p %s %p %p\n", hSCManager,
2235 debugstr_a(lpServiceName), lpDisplayName, lpcchBuffer);
2236
2237 lpServiceNameW = SERV_dup(lpServiceName);
2238 lpDisplayNameW = HeapAlloc(GetProcessHeap(), 0, *lpcchBuffer * sizeof(WCHAR));
2239
2240 size = sizeW = *lpcchBuffer;
2241 ret = GetServiceDisplayNameW(hSCManager, lpServiceNameW,
2242 lpDisplayName ? lpDisplayNameW : NULL,
2243 &sizeW);
2244 /* Last error will be set by GetServiceDisplayNameW and must be preserved */
2245 GLE = GetLastError();
2246
2247 if (!lpDisplayName && *lpcchBuffer && !ret && (GLE == ERROR_INSUFFICIENT_BUFFER))
2248 {
2249 /* Request for buffersize.
2250 *
2251 * Only set the size for ERROR_INSUFFICIENT_BUFFER
2252 */
2253 size = sizeW * 2;
2254 }
2255 else if (lpDisplayName && *lpcchBuffer && !ret)
2256 {
2257 /* Request for displayname.
2258 *
2259 * size only has to be set if this fails
2260 */
2261 size = sizeW * 2;
2262 }
2263
2264 WideCharToMultiByte(CP_ACP, 0, lpDisplayNameW, (sizeW + 1), lpDisplayName,
2265 *lpcchBuffer, NULL, NULL );
2266
2267 *lpcchBuffer = size;
2268
2269 HeapFree(GetProcessHeap(), 0, lpDisplayNameW);
2270 HeapFree(GetProcessHeap(), 0, lpServiceNameW);
2271
2272 SetLastError(GLE);
2273 return ret;
2274 }
2275
2276 /******************************************************************************
2277 * GetServiceDisplayNameW [ADVAPI32.@]
2278 */
2279 BOOL WINAPI GetServiceDisplayNameW( SC_HANDLE hSCManager, LPCWSTR lpServiceName,
2280 LPWSTR lpDisplayName, LPDWORD lpcchBuffer)
2281 {
2282 struct sc_manager *hscm;
2283 DWORD type, size;
2284 LONG ret;
2285
2286 TRACE("%p %s %p %p\n", hSCManager,
2287 debugstr_w(lpServiceName), lpDisplayName, lpcchBuffer);
2288
2289 hscm = sc_handle_get_handle_data(hSCManager, SC_HTYPE_MANAGER);
2290 if (!hscm)
2291 {
2292 SetLastError(ERROR_INVALID_HANDLE);
2293 return FALSE;
2294 }
2295
2296 if (!lpServiceName)
2297 {
2298 SetLastError(ERROR_INVALID_ADDRESS);
2299 return FALSE;
2300 }
2301
2302 size = *lpcchBuffer * sizeof(WCHAR);
2303 ret = RegGetValueW(hscm->hkey, lpServiceName, szDisplayName, RRF_RT_REG_SZ, &type, lpDisplayName, &size);
2304 if (!ret && !lpDisplayName && size)
2305 ret = ERROR_MORE_DATA;
2306
2307 if (ret)
2308 {
2309 if (lpDisplayName && *lpcchBuffer) *lpDisplayName = 0;
2310
2311 if (ret == ERROR_MORE_DATA)
2312 {
2313 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2314 *lpcchBuffer = (size / sizeof(WCHAR)) - 1;
2315 }
2316 else if (ret == ERROR_FILE_NOT_FOUND)
2317 {
2318 HKEY hkey;
2319
2320 if (!RegOpenKeyW(hscm->hkey, lpServiceName, &hkey))
2321 {
2322 INT len = lstrlenW(lpServiceName);
2323 BOOL r = FALSE;
2324
2325 if ((*lpcchBuffer <= len) || (!lpDisplayName && *lpcchBuffer))
2326 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2327 else if (lpDisplayName && *lpcchBuffer)
2328 {
2329 /* No displayname, but the service exists and the buffer
2330 * is big enough. We should return the servicename.
2331 */
2332 lstrcpyW(lpDisplayName, lpServiceName);
2333 r = TRUE;
2334 }
2335
2336 *lpcchBuffer = len;
2337 RegCloseKey(hkey);
2338 return r;
2339 }
2340 else
2341 SetLastError(ERROR_SERVICE_DOES_NOT_EXIST);
2342 }
2343 else
2344 SetLastError(ret);
2345 return FALSE;
2346 }
2347
2348 /* Always return the correct needed size on success */
2349 *lpcchBuffer = (size / sizeof(WCHAR)) - 1;
2350
2351 return TRUE;
2352 }
2353
2354 /******************************************************************************
2355 * ChangeServiceConfigW [ADVAPI32.@]
2356 */
2357 BOOL WINAPI ChangeServiceConfigW( SC_HANDLE hService, DWORD dwServiceType,
2358 DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName,
2359 LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies,
2360 LPCWSTR lpServiceStartName, LPCWSTR lpPassword, LPCWSTR lpDisplayName)
2361 {
2362 struct reg_value val[10];
2363 struct sc_service *hsvc;
2364 DWORD r = ERROR_SUCCESS;
2365 HKEY hKey;
2366 int n = 0;
2367
2368 TRACE("%p %d %d %d %s %s %p %p %s %s %s\n",
2369 hService, dwServiceType, dwStartType, dwErrorControl,
2370 debugstr_w(lpBinaryPathName), debugstr_w(lpLoadOrderGroup),
2371 lpdwTagId, lpDependencies, debugstr_w(lpServiceStartName),
2372 debugstr_w(lpPassword), debugstr_w(lpDisplayName) );
2373
2374 hsvc = sc_handle_get_handle_data(hService, SC_HTYPE_SERVICE);
2375 if (!hsvc)
2376 {
2377 SetLastError( ERROR_INVALID_HANDLE );
2378 return FALSE;
2379 }
2380 hKey = hsvc->hkey;
2381
2382 if( dwServiceType != SERVICE_NO_CHANGE )
2383 service_set_dword( &val[n++], szType, &dwServiceType );
2384
2385 if( dwStartType != SERVICE_NO_CHANGE )
2386 service_set_dword( &val[n++], szStart, &dwStartType );
2387
2388 if( dwErrorControl != SERVICE_NO_CHANGE )
2389 service_set_dword( &val[n++], szError, &dwErrorControl );
2390
2391 if( lpBinaryPathName )
2392 service_set_string( &val[n++], szImagePath, lpBinaryPathName );
2393
2394 if( lpLoadOrderGroup )
2395 service_set_string( &val[n++], szGroup, lpLoadOrderGroup );
2396
2397 /* FIXME: lpDependencies is used to create/change both DependOnService and DependOnGroup
2398 * There is no such key as what szDependencies refers to */
2399 if( lpDependencies )
2400 service_set_multi_string( &val[n++], szDependencies, lpDependencies );
2401
2402 if( lpPassword )
2403 FIXME("ignoring password\n");
2404
2405 if( lpServiceStartName )
2406 service_set_string( &val[n++], szObjectName, lpServiceStartName );
2407
2408 r = service_write_values( hsvc->hkey, val, n );
2409
2410 return (r == ERROR_SUCCESS) ? TRUE : FALSE ;
2411 }
2412
2413 /******************************************************************************
2414 * ChangeServiceConfigA [ADVAPI32.@]
2415 */
2416 BOOL WINAPI ChangeServiceConfigA( SC_HANDLE hService, DWORD dwServiceType,
2417 DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpBinaryPathName,
2418 LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCSTR lpDependencies,
2419 LPCSTR lpServiceStartName, LPCSTR lpPassword, LPCSTR lpDisplayName)
2420 {
2421 LPWSTR wBinaryPathName, wLoadOrderGroup, wDependencies;
2422 LPWSTR wServiceStartName, wPassword, wDisplayName;
2423 BOOL r;
2424
2425 TRACE("%p %d %d %d %s %s %p %p %s %s %s\n",
2426 hService, dwServiceType, dwStartType, dwErrorControl,
2427 debugstr_a(lpBinaryPathName), debugstr_a(lpLoadOrderGroup),
2428 lpdwTagId, lpDependencies, debugstr_a(lpServiceStartName),
2429 debugstr_a(lpPassword), debugstr_a(lpDisplayName) );
2430
2431 wBinaryPathName = SERV_dup( lpBinaryPathName );
2432 wLoadOrderGroup = SERV_dup( lpLoadOrderGroup );
2433 wDependencies = SERV_dupmulti( lpDependencies );
2434 wServiceStartName = SERV_dup( lpServiceStartName );
2435 wPassword = SERV_dup( lpPassword );
2436 wDisplayName = SERV_dup( lpDisplayName );
2437
2438 r = ChangeServiceConfigW( hService, dwServiceType,
2439 dwStartType, dwErrorControl, wBinaryPathName,
2440 wLoadOrderGroup, lpdwTagId, wDependencies,
2441 wServiceStartName, wPassword, wDisplayName);
2442
2443 HeapFree( GetProcessHeap(), 0, wBinaryPathName );
2444 HeapFree( GetProcessHeap(), 0, wLoadOrderGroup );
2445 HeapFree( GetProcessHeap(), 0, wDependencies );
2446 HeapFree( GetProcessHeap(), 0, wServiceStartName );
2447 HeapFree( GetProcessHeap(), 0, wPassword );
2448 HeapFree( GetProcessHeap(), 0, wDisplayName );
2449
2450 return r;
2451 }
2452
2453 /******************************************************************************
2454 * ChangeServiceConfig2A [ADVAPI32.@]
2455 */
2456 BOOL WINAPI ChangeServiceConfig2A( SC_HANDLE hService, DWORD dwInfoLevel,
2457 LPVOID lpInfo)
2458 {
2459 BOOL r = FALSE;
2460
2461 TRACE("%p %d %p\n",hService, dwInfoLevel, lpInfo);
2462
2463 if (dwInfoLevel == SERVICE_CONFIG_DESCRIPTION)
2464 {
2465 LPSERVICE_DESCRIPTIONA sd = (LPSERVICE_DESCRIPTIONA) lpInfo;
2466 SERVICE_DESCRIPTIONW sdw;
2467
2468 sdw.lpDescription = SERV_dup( sd->lpDescription );
2469
2470 r = ChangeServiceConfig2W( hService, dwInfoLevel, &sdw );
2471
2472 HeapFree( GetProcessHeap(), 0, sdw.lpDescription );
2473 }
2474 else if (dwInfoLevel == SERVICE_CONFIG_FAILURE_ACTIONS)
2475 {
2476 LPSERVICE_FAILURE_ACTIONSA fa = (LPSERVICE_FAILURE_ACTIONSA) lpInfo;
2477 SERVICE_FAILURE_ACTIONSW faw;
2478
2479 faw.dwResetPeriod = fa->dwResetPeriod;
2480 faw.lpRebootMsg = SERV_dup( fa->lpRebootMsg );
2481 faw.lpCommand = SERV_dup( fa->lpCommand );
2482 faw.cActions = fa->cActions;
2483 faw.lpsaActions = fa->lpsaActions;
2484
2485 r = ChangeServiceConfig2W( hService, dwInfoLevel, &faw );
2486
2487 HeapFree( GetProcessHeap(), 0, faw.lpRebootMsg );
2488 HeapFree( GetProcessHeap(), 0, faw.lpCommand );
2489 }
2490 else
2491 SetLastError( ERROR_INVALID_PARAMETER );
2492
2493 return r;
2494 }
2495
2496 /******************************************************************************
2497 * ChangeServiceConfig2W [ADVAPI32.@]
2498 */
2499 BOOL WINAPI ChangeServiceConfig2W( SC_HANDLE hService, DWORD dwInfoLevel,
2500 LPVOID lpInfo)
2501 {
2502 HKEY hKey;
2503 struct sc_service *hsvc;
2504
2505 hsvc = sc_handle_get_handle_data(hService, SC_HTYPE_SERVICE);
2506 if (!hsvc)
2507 {
2508 SetLastError( ERROR_INVALID_HANDLE );
2509 return FALSE;
2510 }
2511 hKey = hsvc->hkey;
2512
2513 if (dwInfoLevel == SERVICE_CONFIG_DESCRIPTION)
2514 {
2515 static const WCHAR szDescription[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
2516 LPSERVICE_DESCRIPTIONW sd = (LPSERVICE_DESCRIPTIONW)lpInfo;
2517 if (sd->lpDescription)
2518 {
2519 TRACE("Setting Description to %s\n",debugstr_w(sd->lpDescription));
2520 if (sd->lpDescription[0] == 0)
2521 RegDeleteValueW(hKey,szDescription);
2522 else
2523 RegSetValueExW(hKey, szDescription, 0, REG_SZ,
2524 (LPVOID)sd->lpDescription,
2525 sizeof(WCHAR)*(strlenW(sd->lpDescription)+1));
2526 }
2527 }
2528 else
2529 FIXME("STUB: %p %d %p\n",hService, dwInfoLevel, lpInfo);
2530 return TRUE;
2531 }
2532
2533 /******************************************************************************
2534 * QueryServiceObjectSecurity [ADVAPI32.@]
2535 */
2536 BOOL WINAPI QueryServiceObjectSecurity(SC_HANDLE hService,
2537 SECURITY_INFORMATION dwSecurityInformation,
2538 PSECURITY_DESCRIPTOR lpSecurityDescriptor,
2539 DWORD cbBufSize, LPDWORD pcbBytesNeeded)
2540 {
2541 PACL pACL = NULL;
2542
2543 FIXME("%p %d %p %u %p\n", hService, dwSecurityInformation,
2544 lpSecurityDescriptor, cbBufSize, pcbBytesNeeded);
2545
2546 InitializeSecurityDescriptor(lpSecurityDescriptor, SECURITY_DESCRIPTOR_REVISION);
2547
2548 pACL = HeapAlloc( GetProcessHeap(), 0, sizeof(ACL) );
2549 InitializeAcl(pACL, sizeof(ACL), ACL_REVISION);
2550 SetSecurityDescriptorDacl(lpSecurityDescriptor, TRUE, pACL, TRUE);
2551 return TRUE;
2552 }
2553
2554 /******************************************************************************
2555 * SetServiceObjectSecurity [ADVAPI32.@]
2556 */
2557 BOOL WINAPI SetServiceObjectSecurity(SC_HANDLE hService,
2558 SECURITY_INFORMATION dwSecurityInformation,
2559 PSECURITY_DESCRIPTOR lpSecurityDescriptor)
2560 {
2561 FIXME("%p %d %p\n", hService, dwSecurityInformation, lpSecurityDescriptor);
2562 return TRUE;
2563 }
2564
2565 /******************************************************************************
2566 * SetServiceBits [ADVAPI32.@]
2567 */
2568 BOOL WINAPI SetServiceBits( SERVICE_STATUS_HANDLE hServiceStatus,
2569 DWORD dwServiceBits,
2570 BOOL bSetBitsOn,
2571 BOOL bUpdateImmediately)
2572 {
2573 FIXME("%p %08x %x %x\n", hServiceStatus, dwServiceBits,
2574 bSetBitsOn, bUpdateImmediately);
2575 return TRUE;
2576 }
2577
2578 SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerExA( LPCSTR lpServiceName,
2579 LPHANDLER_FUNCTION_EX lpHandlerProc, LPVOID lpContext )
2580 {
2581 FIXME("%s %p %p\n", debugstr_a(lpServiceName), lpHandlerProc, lpContext);
2582 return 0;
2583 }
2584
2585 SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerExW( LPCWSTR lpServiceName,
2586 LPHANDLER_FUNCTION_EX lpHandlerProc, LPVOID lpContext )
2587 {
2588 service_data *service;
2589 SERVICE_STATUS_HANDLE handle = 0;
2590
2591 TRACE("%s %p %p\n", debugstr_w(lpServiceName), lpHandlerProc, lpContext);
2592
2593 EnterCriticalSection( &service_cs );
2594 LIST_FOR_EACH_ENTRY( service, &service_list, service_data, entry )
2595 {
2596 if(!strcmpW(lpServiceName, service->name))
2597 {
2598 service->handler.handler_ex = lpHandlerProc;
2599 service->context = lpContext;
2600 service->extended = TRUE;
2601 handle = (SERVICE_STATUS_HANDLE)service;
2602 break;
2603 }
2604 }
2605 LeaveCriticalSection( &service_cs );
2606
2607 return handle;
2608 }
useful hacks and other patches not (yet) suitable for mainline