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