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