?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
In OpenSCManagerW() allow lpDatabaseName to be an empty string.
[wine.git] / dlls / advapi32 / service.c
blob404d51ebd91e67c50590ca1e20b44b67eb9c0ee4
1 /*
2 * Win32 advapi functions
3 *
4 * Copyright 1995 Sven Verdoolaege
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include <stdarg.h>
22 #include <string.h>
23 #include <time.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winsvc.h"
28 #include "winerror.h"
29 #include "winreg.h"
30 #include "wine/unicode.h"
31 #include "wine/debug.h"
32 #include "winternl.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
35
36 static const WCHAR szServiceManagerKey[] = { 'S','y','s','t','e','m','\\',
37 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
38 'S','e','r','v','i','c','e','s','\\',0 };
39 static const WCHAR szSCMLock[] = {'A','D','V','A','P','I','_','S','C','M',
40 'L','O','C','K',0};
41 static const WCHAR szServiceShmemNameFmtW[] = {'A','D','V','A','P','I','_',
42 'S','E','B','_','%','s',0};
43 static const WCHAR szServiceDispEventNameFmtW[] = {'A','D','V','A','P','I','_',
44 'D','I','S','P','_','%','s',0};
45 static const WCHAR szServiceMutexNameFmtW[] = {'A','D','V','A','P','I','_',
46 'M','U','X','_','%','s',0};
47 static const WCHAR szServiceAckEventNameFmtW[] = {'A','D','V','A','P','I','_',
48 'A','C','K','_','%','s',0};
49 static const WCHAR szWaitServiceStartW[] = {'A','D','V','A','P','I','_','W',
50 'a','i','t','S','e','r','v','i',
51 'c','e','S','t','a','r','t',0};
52
53 struct SEB /* service environment block */
54 { /* resides in service's shared memory object */
55 DWORD control_code; /* service control code */
56 DWORD dispatcher_error; /* set by dispatcher if it fails to invoke control handler */
57 SERVICE_STATUS status;
58 DWORD argc;
59 /* variable part of SEB contains service arguments */
60 };
61
62 static HANDLE dispatcher_event; /* this is used by service thread to wakeup
63 * service control dispatcher when thread terminates */
64
65 static struct service_thread_data *service; /* FIXME: this should be a list */
66
67 /******************************************************************************
68 * SC_HANDLEs
69 */
70
71 #define MAX_SERVICE_NAME 256
72
73 typedef enum { SC_HTYPE_MANAGER, SC_HTYPE_SERVICE } SC_HANDLE_TYPE;
74
75 struct sc_handle;
76
77 struct sc_manager /* SCM handle */
78 {
79 HKEY hkey_scm_db; /* handle to services database in the registry */
80 LONG ref_count; /* handle must remain alive until any related service */
81 /* handle exists because DeleteService requires it */
82 };
83
84 struct sc_service /* service handle */
85 {
86 HKEY hkey; /* handle to service entry in the registry (under hkey_scm_db) */
87 struct sc_handle *sc_manager; /* pointer to SCM handle */
88 WCHAR name[ MAX_SERVICE_NAME ];
89 };
90
91 struct sc_handle
92 {
93 SC_HANDLE_TYPE htype;
94 union
95 {
96 struct sc_manager manager;
97 struct sc_service service;
98 } u;
99 };
100
101 static struct sc_handle* alloc_sc_handle( SC_HANDLE_TYPE htype )
102 {
103 struct sc_handle *retval;
104
105 retval = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct sc_handle) );
106 if( retval != NULL )
107 {
108 retval->htype = htype;
109 }
110 TRACE("SC_HANDLE type=%d -> %p\n",htype,retval);
111 return retval;
112 }
113
114 static void free_sc_handle( struct sc_handle* handle )
115 {
116 if( NULL == handle )
117 return;
118
119 switch( handle->htype )
120 {
121 case SC_HTYPE_MANAGER:
122 {
123 if( InterlockedDecrement( &handle->u.manager.ref_count ) )
124 /* there are references to this handle */
125 return;
126
127 if( handle->u.manager.hkey_scm_db )
128 RegCloseKey( handle->u.manager.hkey_scm_db );
129 break;
130 }
131
132 case SC_HTYPE_SERVICE:
133 {
134 struct sc_handle *h = handle->u.service.sc_manager;
135
136 if( h )
137 {
138 /* release SCM handle */
139 if( 0 == InterlockedDecrement( &h->u.manager.ref_count ) )
140 {
141 /* it's time to destroy SCM handle */
142 if( h->u.manager.hkey_scm_db )
143 RegCloseKey( h->u.manager.hkey_scm_db );
144
145 TRACE("SC_HANDLE (SCM) %p type=%d\n",h,h->htype);
146
147 HeapFree( GetProcessHeap(), 0, h );
148 }
149 }
150 if( handle->u.service.hkey )
151 RegCloseKey( handle->u.service.hkey );
152 break;
153 }
154 }
155
156 TRACE("SC_HANDLE %p type=%d\n",handle,handle->htype);
157
158 HeapFree( GetProcessHeap(), 0, handle );
159 }
160
161 static void init_service_handle( struct sc_handle* handle,
162 struct sc_handle* sc_manager,
163 HKEY hKey, LPCWSTR lpServiceName )
164 {
165 /* init sc_service structure */
166 handle->u.service.hkey = hKey;
167 lstrcpynW( handle->u.service.name, lpServiceName, MAX_SERVICE_NAME );
168
169 /* add reference to SCM handle */
170 InterlockedIncrement( &sc_manager->u.manager.ref_count );
171 handle->u.service.sc_manager = sc_manager;
172 }
173
174 static inline LPWSTR SERV_dup( LPCSTR str )
175 {
176 UINT len;
177 LPWSTR wstr;
178
179 if( !str )
180 return NULL;
181 len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
182 wstr = HeapAlloc( GetProcessHeap(), 0, len*sizeof (WCHAR) );
183 MultiByteToWideChar( CP_ACP, 0, str, -1, wstr, len );
184 return wstr;
185 }
186
187 static inline LPWSTR SERV_dupmulti( LPCSTR str )
188 {
189 UINT len = 0, n = 0;
190 LPWSTR wstr;
191
192 if( !str )
193 return NULL;
194 do {
195 len += MultiByteToWideChar( CP_ACP, 0, &str[n], -1, NULL, 0 );
196 n += (strlen( &str[n] ) + 1);
197 } while (str[n]);
198 len++;
199 n++;
200
201 wstr = HeapAlloc( GetProcessHeap(), 0, len*sizeof (WCHAR) );
202 MultiByteToWideChar( CP_ACP, 0, str, n, wstr, len );
203 return wstr;
204 }
205
206 static inline VOID SERV_free( LPWSTR wstr )
207 {
208 HeapFree( GetProcessHeap(), 0, wstr );
209 }
210
211 /******************************************************************************
212 * EnumServicesStatusA [ADVAPI32.@]
213 */
214 BOOL WINAPI
215 EnumServicesStatusA( SC_HANDLE hSCManager, DWORD dwServiceType,
216 DWORD dwServiceState, LPENUM_SERVICE_STATUSA lpServices,
217 DWORD cbBufSize, LPDWORD pcbBytesNeeded,
218 LPDWORD lpServicesReturned, LPDWORD lpResumeHandle )
219 { FIXME("%p type=%lx state=%lx %p %lx %p %p %p\n", hSCManager,
220 dwServiceType, dwServiceState, lpServices, cbBufSize,
221 pcbBytesNeeded, lpServicesReturned, lpResumeHandle);
222 SetLastError (ERROR_ACCESS_DENIED);
223 return FALSE;
224 }
225
226 /******************************************************************************
227 * EnumServicesStatusW [ADVAPI32.@]
228 */
229 BOOL WINAPI
230 EnumServicesStatusW( SC_HANDLE hSCManager, DWORD dwServiceType,
231 DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices,
232 DWORD cbBufSize, LPDWORD pcbBytesNeeded,
233 LPDWORD lpServicesReturned, LPDWORD lpResumeHandle )
234 { FIXME("%p type=%lx state=%lx %p %lx %p %p %p\n", hSCManager,
235 dwServiceType, dwServiceState, lpServices, cbBufSize,
236 pcbBytesNeeded, lpServicesReturned, lpResumeHandle);
237 SetLastError (ERROR_ACCESS_DENIED);
238 return FALSE;
239 }
240
241 /******************************************************************************
242 * read_scm_lock_data
243 *
244 * helper function for service control dispatcher
245 *
246 * SCM database is locked by StartService;
247 * open global SCM lock object and read service name
248 */
249 static BOOL read_scm_lock_data( LPWSTR buffer )
250 {
251 HANDLE hLock;
252 LPWSTR argptr;
253
254 hLock = OpenFileMappingW( FILE_MAP_ALL_ACCESS, FALSE, szSCMLock );
255 if( NULL == hLock )
256 {
257 SetLastError( ERROR_FAILED_SERVICE_CONTROLLER_CONNECT );
258 return FALSE;
259 }
260 argptr = MapViewOfFile( hLock, FILE_MAP_ALL_ACCESS,
261 0, 0, MAX_SERVICE_NAME * sizeof(WCHAR) );
262 if( NULL == argptr )
263 {
264 CloseHandle( hLock );
265 return FALSE;
266 }
267 strcpyW( buffer, argptr );
268 UnmapViewOfFile( argptr );
269 CloseHandle( hLock );
270 return TRUE;
271 }
272
273 /******************************************************************************
274 * open_seb_shmem
275 *
276 * helper function for service control dispatcher
277 */
278 static struct SEB* open_seb_shmem( LPWSTR service_name, HANDLE* hServiceShmem )
279 {
280 WCHAR object_name[ MAX_PATH ];
281 HANDLE hmem;
282 struct SEB *ret;
283
284 snprintfW( object_name, MAX_PATH, szServiceShmemNameFmtW, service_name );
285 hmem = OpenFileMappingW( FILE_MAP_ALL_ACCESS, FALSE, object_name );
286 if( NULL == hmem )
287 return NULL;
288
289 ret = MapViewOfFile( hmem, FILE_MAP_ALL_ACCESS, 0, 0, 0 );
290 if( NULL == ret )
291 CloseHandle( hmem );
292 else
293 *hServiceShmem = hmem;
294 return ret;
295 }
296
297 /******************************************************************************
298 * build_arg_vectors
299 *
300 * helper function for start_new_service
301 *
302 * Allocate and initialize array of LPWSTRs to arguments in variable part
303 * of service environment block.
304 * First entry in the array is reserved for service name and not initialized.
305 */
306 static LPWSTR* build_arg_vectors( struct SEB* seb )
307 {
308 LPWSTR *ret;
309 LPWSTR argptr;
310 DWORD i;
311
312 ret = HeapAlloc( GetProcessHeap(), 0, (1 + seb->argc) * sizeof(LPWSTR) );
313 if( NULL == ret )
314 return NULL;
315
316 argptr = (LPWSTR) &seb[1];
317 for( i = 0; i < seb->argc; i++ )
318 {
319 ret[ 1 + i ] = argptr;
320 argptr += 1 + strlenW( argptr );
321 }
322 return ret;
323 }
324
325 /******************************************************************************
326 * service thread
327 */
328 struct service_thread_data
329 {
330 WCHAR service_name[ MAX_SERVICE_NAME ];
331 CHAR service_nameA[ MAX_SERVICE_NAME ];
332 LPSERVICE_MAIN_FUNCTIONW service_main;
333 DWORD argc;
334 LPWSTR *argv;
335 HANDLE hServiceShmem;
336 struct SEB *seb;
337 HANDLE thread_handle;
338 HANDLE mutex; /* provides serialization of control request */
339 HANDLE ack_event; /* control handler completion acknowledgement */
340 LPHANDLER_FUNCTION ctrl_handler;
341 };
342
343 static DWORD WINAPI service_thread( LPVOID arg )
344 {
345 struct service_thread_data *data = arg;
346
347 data->service_main( data->argc, data->argv );
348 SetEvent( dispatcher_event );
349 return 0;
350 }
351
352 /******************************************************************************
353 * dispose_service_thread_data
354 *
355 * helper function for service control dispatcher
356 */
357 static void dispose_service_thread_data( struct service_thread_data* thread_data )
358 {
359 if( thread_data->mutex ) CloseHandle( thread_data->mutex );
360 if( thread_data->ack_event ) CloseHandle( thread_data->ack_event );
361 if( thread_data->argv ) HeapFree( GetProcessHeap(), 0, thread_data->argv );
362 if( thread_data->seb ) UnmapViewOfFile( thread_data->seb );
363 if( thread_data->hServiceShmem ) CloseHandle( thread_data->hServiceShmem );
364 HeapFree( GetProcessHeap(), 0, thread_data );
365 }
366
367 /******************************************************************************
368 * start_new_service
369 *
370 * helper function for service control dispatcher
371 */
372 static struct service_thread_data*
373 start_new_service( LPSERVICE_MAIN_FUNCTIONW service_main, BOOL ascii )
374 {
375 struct service_thread_data *thread_data;
376 unsigned int i;
377 WCHAR object_name[ MAX_PATH ];
378
379 thread_data = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct service_thread_data) );
380 if( NULL == thread_data )
381 return NULL;
382
383 if( ! read_scm_lock_data( thread_data->service_name ) )
384 {
385 /* FIXME: Instead of exiting we allow
386 service to be executed as ordinary program.
387 This behaviour was specially introduced in the patch
388 submitted against revision 1.45 and so preserved here.
389 */
390 FIXME("should fail with ERROR_FAILED_SERVICE_CONTROLLER_CONNECT\n");
391 service_main( 0, NULL );
392 HeapFree( GetProcessHeap(), 0, thread_data );
393 return NULL;
394 }
395
396 thread_data->seb = open_seb_shmem( thread_data->service_name, &thread_data->hServiceShmem );
397 if( NULL == thread_data->seb )
398 goto error;
399
400 thread_data->argv = build_arg_vectors( thread_data->seb );
401 if( NULL == thread_data->argv )
402 goto error;
403
404 thread_data->argv[0] = thread_data->service_name;
405 thread_data->argc = thread_data->seb->argc + 1;
406
407 if( ascii )
408 {
409 /* Convert the Unicode arg vectors back to ASCII;
410 * but we'll need unicode service name (argv[0]) for object names */
411 WideCharToMultiByte( CP_ACP, 0, thread_data->argv[0], -1,
412 thread_data->service_nameA, MAX_SERVICE_NAME, NULL, NULL );
413 thread_data->argv[0] = (LPWSTR) thread_data->service_nameA;
414
415 for(i=1; i<thread_data->argc; i++)
416 {
417 LPWSTR src = thread_data->argv[i];
418 int len = WideCharToMultiByte( CP_ACP, 0, src, -1, NULL, 0, NULL, NULL );
419 LPSTR dest = HeapAlloc( GetProcessHeap(), 0, len );
420 if( NULL == dest )
421 goto error;
422 WideCharToMultiByte( CP_ACP, 0, src, -1, dest, len, NULL, NULL );
423 /* copy converted string back */
424 memcpy( src, dest, len );
425 HeapFree( GetProcessHeap(), 0, dest );
426 }
427 }
428
429 /* init status according to docs for StartService */
430 thread_data->seb->status.dwCurrentState = SERVICE_START_PENDING;
431 thread_data->seb->status.dwControlsAccepted = 0;
432 thread_data->seb->status.dwCheckPoint = 0;
433 thread_data->seb->status.dwWaitHint = 2000;
434
435 /* create service mutex; mutex is initially owned */
436 snprintfW( object_name, MAX_PATH, szServiceMutexNameFmtW, thread_data->service_name );
437 thread_data->mutex = CreateMutexW( NULL, TRUE, object_name );
438 if( NULL == thread_data->mutex )
439 goto error;
440
441 if( ERROR_ALREADY_EXISTS == GetLastError() )
442 {
443 SetLastError( ERROR_SERVICE_ALREADY_RUNNING );
444 goto error;
445 }
446
447 /* create service event */
448 snprintfW( object_name, MAX_PATH, szServiceAckEventNameFmtW, thread_data->service_name );
449 thread_data->ack_event = CreateEventW( NULL, FALSE, FALSE, object_name );
450 if( NULL == thread_data->ack_event )
451 goto error;
452
453 if( ERROR_ALREADY_EXISTS == GetLastError() )
454 {
455 SetLastError( ERROR_SERVICE_ALREADY_RUNNING );
456 goto error;
457 }
458
459 /* create service thread in suspended state
460 * to avoid race while caller handles return value */
461 thread_data->service_main = service_main;
462 thread_data->thread_handle = CreateThread( NULL, 0, service_thread,
463 thread_data, CREATE_SUSPENDED, NULL );
464 if( thread_data->thread_handle )
465 return thread_data;
466
467 error:
468 dispose_service_thread_data( thread_data );
469 return FALSE;
470 }
471
472 /******************************************************************************
473 * service_ctrl_dispatcher
474 */
475 static BOOL service_ctrl_dispatcher( LPSERVICE_TABLE_ENTRYW servent, BOOL ascii )
476 {
477 WCHAR object_name[ MAX_PATH ];
478 HANDLE wait;
479
480 /* FIXME: if shared service, find entry by service name */
481
482 /* FIXME: move this into dispatcher loop */
483 service = start_new_service( servent->lpServiceProc, ascii );
484 if( NULL == service )
485 return FALSE;
486
487 ResumeThread( service->thread_handle );
488
489 /* create dispatcher event object */
490 /* FIXME: object_name should be based on executable image path because
491 * this object is common for all services in the process */
492 /* But what if own and shared services have the same executable? */
493 snprintfW( object_name, MAX_PATH, szServiceDispEventNameFmtW, service->service_name );
494 dispatcher_event = CreateEventW( NULL, FALSE, FALSE, object_name );
495 if( NULL == dispatcher_event )
496 {
497 dispose_service_thread_data( service );
498 return FALSE;
499 }
500
501 if( ERROR_ALREADY_EXISTS == GetLastError() )
502 {
503 SetLastError( ERROR_SERVICE_ALREADY_RUNNING );
504 CloseHandle( dispatcher_event );
505 return FALSE;
506 }
507
508 /* ready to accept control requests */
509 ReleaseMutex( service->mutex );
510
511 /* signal for StartService */
512 wait = OpenSemaphoreW( SEMAPHORE_MODIFY_STATE, FALSE, szWaitServiceStartW );
513 if( wait )
514 {
515 ReleaseSemaphore( wait, 1, NULL );
516 CloseHandle( wait );
517 }
518
519 /* dispatcher loop */
520 for(;;)
521 {
522 DWORD ret;
523
524 WaitForSingleObject( dispatcher_event, INFINITE );
525
526 /* at first, look for terminated service thread
527 * FIXME: threads, if shared service */
528 if( !GetExitCodeThread( service->thread_handle, &ret ) )
529 ERR("Couldn't get thread exit code\n");
530 else if( ret != STILL_ACTIVE )
531 {
532 CloseHandle( service->thread_handle );
533 dispose_service_thread_data( service );
534 break;
535 }
536
537 /* look for control requests */
538 if( service->seb->control_code )
539 {
540 if( NULL == service->ctrl_handler )
541 service->seb->dispatcher_error = ERROR_SERVICE_CANNOT_ACCEPT_CTRL;
542 else
543 {
544 service->ctrl_handler( service->seb->control_code );
545 service->seb->dispatcher_error = 0;
546 }
547 service->seb->control_code = 0;
548 SetEvent( service->ack_event );
549 }
550
551 /* FIXME: if shared service, check SCM lock object;
552 * if exists, a new service should be started */
553 }
554
555 CloseHandle( dispatcher_event );
556 return TRUE;
557 }
558
559 /******************************************************************************
560 * StartServiceCtrlDispatcherA [ADVAPI32.@]
561 */
562 BOOL WINAPI
563 StartServiceCtrlDispatcherA( LPSERVICE_TABLE_ENTRYA servent )
564 {
565 int count, i;
566 LPSERVICE_TABLE_ENTRYW ServiceTableW;
567 BOOL ret;
568
569 TRACE("(%p)\n", servent);
570
571 /* convert service table to unicode */
572 for( count = 0; servent[ count ].lpServiceName; )
573 count++;
574 ServiceTableW = HeapAlloc( GetProcessHeap(), 0, (count + 1) * sizeof(SERVICE_TABLE_ENTRYW) );
575 if( NULL == ServiceTableW )
576 return FALSE;
577
578 for( i = 0; i < count; i++ )
579 {
580 ServiceTableW[ i ].lpServiceName = SERV_dup( servent[ i ].lpServiceName );
581 ServiceTableW[ i ].lpServiceProc = (LPSERVICE_MAIN_FUNCTIONW) servent[ i ].lpServiceProc;
582 }
583 ServiceTableW[ count ].lpServiceName = NULL;
584 ServiceTableW[ count ].lpServiceProc = NULL;
585
586 /* start dispatcher */
587 ret = service_ctrl_dispatcher( ServiceTableW, TRUE );
588
589 /* free service table */
590 for( i = 0; i < count; i++ )
591 SERV_free( ServiceTableW[ i ].lpServiceName );
592 HeapFree( GetProcessHeap(), 0, ServiceTableW );
593 return ret;
594 }
595
596 /******************************************************************************
597 * StartServiceCtrlDispatcherW [ADVAPI32.@]
598 *
599 * PARAMS
600 * servent []
601 */
602 BOOL WINAPI
603 StartServiceCtrlDispatcherW( LPSERVICE_TABLE_ENTRYW servent )
604 {
605 TRACE("(%p)\n", servent);
606 return service_ctrl_dispatcher( servent, FALSE );
607 }
608
609 /******************************************************************************
610 * LockServiceDatabase [ADVAPI32.@]
611 */
612 LPVOID WINAPI LockServiceDatabase (SC_HANDLE hSCManager)
613 {
614 HANDLE ret;
615
616 TRACE("%p\n",hSCManager);
617
618 ret = CreateFileMappingW( INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
619 0, MAX_SERVICE_NAME * sizeof(WCHAR), szSCMLock );
620 if( ret && GetLastError() == ERROR_ALREADY_EXISTS )
621 {
622 CloseHandle( ret );
623 ret = NULL;
624 SetLastError( ERROR_SERVICE_DATABASE_LOCKED );
625 }
626
627 TRACE("returning %p\n", ret);
628
629 return ret;
630 }
631
632 /******************************************************************************
633 * UnlockServiceDatabase [ADVAPI32.@]
634 */
635 BOOL WINAPI UnlockServiceDatabase (LPVOID ScLock)
636 {
637 TRACE("%p\n",ScLock);
638
639 return CloseHandle( (HANDLE) ScLock );
640 }
641
642 /******************************************************************************
643 * RegisterServiceCtrlHandlerA [ADVAPI32.@]
644 */
645 SERVICE_STATUS_HANDLE WINAPI
646 RegisterServiceCtrlHandlerA( LPCSTR lpServiceName,
647 LPHANDLER_FUNCTION lpfHandler )
648 {
649 UNICODE_STRING lpServiceNameW;
650 SERVICE_STATUS_HANDLE ret;
651
652 RtlCreateUnicodeStringFromAsciiz (&lpServiceNameW,lpServiceName);
653 ret = RegisterServiceCtrlHandlerW( lpServiceNameW.Buffer, lpfHandler );
654 RtlFreeUnicodeString(&lpServiceNameW);
655 return ret;
656 }
657
658 /******************************************************************************
659 * RegisterServiceCtrlHandlerW [ADVAPI32.@]
660 *
661 * PARAMS
662 * lpServiceName []
663 * lpfHandler []
664 */
665 SERVICE_STATUS_HANDLE WINAPI
666 RegisterServiceCtrlHandlerW( LPCWSTR lpServiceName,
667 LPHANDLER_FUNCTION lpfHandler )
668 {
669 /* FIXME: find service thread data by service name */
670
671 service->ctrl_handler = lpfHandler;
672 return 0xcacacafe;
673 }
674
675 /******************************************************************************
676 * SetServiceStatus [ADVAPI32.@]
677 *
678 * PARAMS
679 * hService []
680 * lpStatus []
681 */
682 BOOL WINAPI
683 SetServiceStatus( SERVICE_STATUS_HANDLE hService, LPSERVICE_STATUS lpStatus )
684 {
685 DWORD r;
686
687 TRACE("\tType:%lx\n",lpStatus->dwServiceType);
688 TRACE("\tState:%lx\n",lpStatus->dwCurrentState);
689 TRACE("\tControlAccepted:%lx\n",lpStatus->dwControlsAccepted);
690 TRACE("\tExitCode:%lx\n",lpStatus->dwWin32ExitCode);
691 TRACE("\tServiceExitCode:%lx\n",lpStatus->dwServiceSpecificExitCode);
692 TRACE("\tCheckPoint:%lx\n",lpStatus->dwCheckPoint);
693 TRACE("\tWaitHint:%lx\n",lpStatus->dwWaitHint);
694
695 /* FIXME: find service thread data by status handle */
696
697 /* acquire mutex; note that mutex may already be owned
698 * when service handles control request
699 */
700 r = WaitForSingleObject( service->mutex, 0 );
701 memcpy( &service->seb->status, lpStatus, sizeof(SERVICE_STATUS) );
702 if( WAIT_OBJECT_0 == r || WAIT_ABANDONED == r )
703 ReleaseMutex( service->mutex );
704 return TRUE;
705 }
706
707 /******************************************************************************
708 * OpenSCManagerA [ADVAPI32.@]
709 *
710 * Establish a connection to the service control manager and open its database.
711 *
712 * PARAMS
713 * lpMachineName [I] Pointer to machine name string
714 * lpDatabaseName [I] Pointer to database name string
715 * dwDesiredAccess [I] Type of access
716 *
717 * RETURNS
718 * Success: A Handle to the service control manager database
719 * Failure: NULL
720 */
721 SC_HANDLE WINAPI OpenSCManagerA( LPCSTR lpMachineName, LPCSTR lpDatabaseName,
722 DWORD dwDesiredAccess )
723 {
724 UNICODE_STRING lpMachineNameW;
725 UNICODE_STRING lpDatabaseNameW;
726 SC_HANDLE ret;
727
728 RtlCreateUnicodeStringFromAsciiz (&lpMachineNameW,lpMachineName);
729 RtlCreateUnicodeStringFromAsciiz (&lpDatabaseNameW,lpDatabaseName);
730 ret = OpenSCManagerW(lpMachineNameW.Buffer,lpDatabaseNameW.Buffer, dwDesiredAccess);
731 RtlFreeUnicodeString(&lpDatabaseNameW);
732 RtlFreeUnicodeString(&lpMachineNameW);
733 return ret;
734 }
735
736 /******************************************************************************
737 * OpenSCManagerW [ADVAPI32.@]
738 *
739 * See OpenSCManagerA.
740 */
741 SC_HANDLE WINAPI OpenSCManagerW( LPCWSTR lpMachineName, LPCWSTR lpDatabaseName,
742 DWORD dwDesiredAccess )
743 {
744 struct sc_handle *retval;
745 HKEY hReg;
746 LONG r;
747
748 TRACE("(%s,%s,0x%08lx)\n", debugstr_w(lpMachineName),
749 debugstr_w(lpDatabaseName), dwDesiredAccess);
750
751 if( lpDatabaseName && lpDatabaseName[0] )
752 {
753 if( strcmpiW( lpDatabaseName, SERVICES_ACTIVE_DATABASEW ) == 0 )
754 {
755 /* noop, all right */
756 }
757 else if( strcmpiW( lpDatabaseName, SERVICES_FAILED_DATABASEW ) == 0 )
758 {
759 SetLastError( ERROR_DATABASE_DOES_NOT_EXIST );
760 return NULL;
761 }
762 else
763 {
764 SetLastError( ERROR_INVALID_NAME );
765 return NULL;
766 }
767 }
768
769 retval = alloc_sc_handle( SC_HTYPE_MANAGER );
770 if( NULL == retval ) return NULL;
771
772 retval->u.manager.ref_count = 1;
773
774 r = RegConnectRegistryW(lpMachineName,HKEY_LOCAL_MACHINE,&hReg);
775 if (r!=ERROR_SUCCESS)
776 goto error;
777
778 r = RegOpenKeyExW(hReg, szServiceManagerKey,
779 0, KEY_ALL_ACCESS, &retval->u.manager.hkey_scm_db);
780 RegCloseKey( hReg );
781 if (r!=ERROR_SUCCESS)
782 goto error;
783
784 TRACE("returning %p\n", retval);
785
786 return (SC_HANDLE) retval;
787
788 error:
789 free_sc_handle( retval );
790 return NULL;
791 }
792
793 /******************************************************************************
794 * ControlService [ADVAPI32.@]
795 *
796 * Send a control code to a service.
797 *
798 * PARAMS
799 * hService [I] Handle of the service control manager database
800 * dwControl [I] Control code to send (SERVICE_CONTROL_* flags from "winsvc.h")
801 * lpServiceStatus [O] Destination for the status of the service, if available
802 *
803 * RETURNS
804 * Success: TRUE.
805 * Failure: FALSE.
806 *
807 * BUGS
808 * Unlike M$' implementation, control requests are not serialized and may be
809 * processed asynchronously.
810 */
811 BOOL WINAPI ControlService( SC_HANDLE hService, DWORD dwControl,
812 LPSERVICE_STATUS lpServiceStatus )
813 {
814 struct sc_handle *hsvc = hService;
815 WCHAR object_name[ MAX_PATH ];
816 HANDLE mutex = NULL, shmem = NULL;
817 HANDLE disp_event = NULL, ack_event = NULL;
818 struct SEB *seb = NULL;
819 DWORD r;
820 BOOL ret = FALSE, mutex_owned = FALSE;
821
822 /* open and hold mutex */
823 snprintfW( object_name, MAX_PATH, szServiceMutexNameFmtW, hsvc->u.service.name );
824 mutex = OpenMutexW( MUTEX_ALL_ACCESS, FALSE, object_name );
825 if( NULL == mutex )
826 {
827 SetLastError( ERROR_SERVICE_NOT_ACTIVE );
828 return FALSE;
829 }
830
831 r = WaitForSingleObject( mutex, 30000 );
832 if( WAIT_FAILED == r )
833 goto done;
834
835 if( WAIT_TIMEOUT == r )
836 {
837 SetLastError( ERROR_SERVICE_REQUEST_TIMEOUT );
838 goto done;
839 }
840 mutex_owned = TRUE;
841
842 /* open event objects */
843 snprintfW( object_name, MAX_PATH, szServiceDispEventNameFmtW, hsvc->u.service.name );
844 disp_event = OpenEventW( EVENT_ALL_ACCESS, FALSE, object_name );
845 if( NULL == disp_event )
846 goto done;
847
848 snprintfW( object_name, MAX_PATH, szServiceAckEventNameFmtW, hsvc->u.service.name );
849 ack_event = OpenEventW( EVENT_ALL_ACCESS, FALSE, object_name );
850 if( NULL == ack_event )
851 goto done;
852
853 /* get service environment block */
854 seb = open_seb_shmem( hsvc->u.service.name, &shmem );
855 if( NULL == seb )
856 goto done;
857
858 /* send request */
859 /* FIXME: check dwControl against controls accepted */
860 seb->control_code = dwControl;
861 SetEvent( disp_event );
862
863 /* wait for acknowledgement */
864 r = WaitForSingleObject( ack_event, 30000 );
865 if( WAIT_FAILED == r )
866 goto done;
867
868 if( WAIT_TIMEOUT == r )
869 {
870 SetLastError( ERROR_SERVICE_REQUEST_TIMEOUT );
871 goto done;
872 }
873
874 if( seb->dispatcher_error )
875 {
876 SetLastError( seb->dispatcher_error );
877 goto done;
878 }
879
880 /* get status */
881 if( lpServiceStatus )
882 memcpy( lpServiceStatus, &seb->status, sizeof(SERVICE_STATUS) );
883 ret = TRUE;
884
885 done:
886 if( seb ) UnmapViewOfFile( seb );
887 if( shmem ) CloseHandle( shmem );
888 if( ack_event ) CloseHandle( ack_event );
889 if( disp_event ) CloseHandle( disp_event );
890 if( mutex_owned ) ReleaseMutex( mutex );
891 if( mutex ) CloseHandle( mutex );
892 return ret;
893 }
894
895 /******************************************************************************
896 * CloseServiceHandle [ADVAPI32.@]
897 *
898 * Close a handle to a service or the service control manager database.
899 *
900 * PARAMS
901 * hSCObject [I] Handle to service or service control manager database
902 *
903 * RETURNS
904 * Success: TRUE
905 * Failure: FALSE
906 */
907 BOOL WINAPI
908 CloseServiceHandle( SC_HANDLE hSCObject )
909 {
910 TRACE("(%p)\n", hSCObject);
911
912 free_sc_handle( (struct sc_handle*) hSCObject );
913
914 return TRUE;
915 }
916
917
918 /******************************************************************************
919 * OpenServiceA [ADVAPI32.@]
920 *
921 * Open a handle to a service.
922 *
923 * PARAMS
924 * hSCManager [I] Handle of the service control manager database
925 * lpServiceName [I] Name of the service to open
926 * dwDesiredAccess [I] Access required to the service
927 *
928 * RETURNS
929 * Success: Handle to the service
930 * Failure: NULL
931 */
932 SC_HANDLE WINAPI OpenServiceA( SC_HANDLE hSCManager, LPCSTR lpServiceName,
933 DWORD dwDesiredAccess )
934 {
935 UNICODE_STRING lpServiceNameW;
936 SC_HANDLE ret;
937 RtlCreateUnicodeStringFromAsciiz (&lpServiceNameW,lpServiceName);
938 if(lpServiceName)
939 TRACE("Request for service %s\n",lpServiceName);
940 else
941 return FALSE;
942 ret = OpenServiceW( hSCManager, lpServiceNameW.Buffer, dwDesiredAccess);
943 RtlFreeUnicodeString(&lpServiceNameW);
944 return ret;
945 }
946
947
948 /******************************************************************************
949 * OpenServiceW [ADVAPI32.@]
950 *
951 * See OpenServiceA.
952 */
953 SC_HANDLE WINAPI OpenServiceW( SC_HANDLE hSCManager, LPCWSTR lpServiceName,
954 DWORD dwDesiredAccess)
955 {
956 struct sc_handle *hscm = hSCManager;
957 struct sc_handle *retval;
958 HKEY hKey;
959 long r;
960
961 TRACE("(%p,%p,%ld)\n",hSCManager, lpServiceName,
962 dwDesiredAccess);
963
964 retval = alloc_sc_handle( SC_HTYPE_SERVICE );
965 if( NULL == retval )
966 return NULL;
967
968 r = RegOpenKeyExW( hscm->u.manager.hkey_scm_db,
969 lpServiceName, 0, KEY_ALL_ACCESS, &hKey );
970 if (r!=ERROR_SUCCESS)
971 {
972 free_sc_handle( retval );
973 SetLastError( ERROR_SERVICE_DOES_NOT_EXIST );
974 return NULL;
975 }
976
977 init_service_handle( retval, hscm, hKey, lpServiceName );
978
979 TRACE("returning %p\n",retval);
980
981 return (SC_HANDLE) retval;
982 }
983
984 /******************************************************************************
985 * CreateServiceW [ADVAPI32.@]
986 */
987 SC_HANDLE WINAPI
988 CreateServiceW( SC_HANDLE hSCManager, LPCWSTR lpServiceName,
989 LPCWSTR lpDisplayName, DWORD dwDesiredAccess,
990 DWORD dwServiceType, DWORD dwStartType,
991 DWORD dwErrorControl, LPCWSTR lpBinaryPathName,
992 LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId,
993 LPCWSTR lpDependencies, LPCWSTR lpServiceStartName,
994 LPCWSTR lpPassword )
995 {
996 struct sc_handle *hscm = hSCManager;
997 struct sc_handle *retval;
998 HKEY hKey;
999 LONG r;
1000 DWORD dp;
1001 static const WCHAR szDisplayName[] = { 'D','i','s','p','l','a','y','N','a','m','e', 0 };
1002 static const WCHAR szType[] = {'T','y','p','e',0};
1003 static const WCHAR szStart[] = {'S','t','a','r','t',0};
1004 static const WCHAR szError[] = {'E','r','r','o','r','C','o','n','t','r','o','l', 0};
1005 static const WCHAR szImagePath[] = {'I','m','a','g','e','P','a','t','h',0};
1006 static const WCHAR szGroup[] = {'G','r','o','u','p',0};
1007 static const WCHAR szDependencies[] = { 'D','e','p','e','n','d','e','n','c','i','e','s',0};
1008
1009 FIXME("%p %s %s\n", hSCManager,
1010 debugstr_w(lpServiceName), debugstr_w(lpDisplayName));
1011
1012 retval = alloc_sc_handle( SC_HTYPE_SERVICE );
1013 if( NULL == retval )
1014 return NULL;
1015
1016 r = RegCreateKeyExW(hscm->u.manager.hkey_scm_db, lpServiceName, 0, NULL,
1017 REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &dp);
1018 if (r!=ERROR_SUCCESS)
1019 goto error;
1020
1021 init_service_handle( retval, hscm, hKey, lpServiceName );
1022
1023 if (dp != REG_CREATED_NEW_KEY)
1024 goto error;
1025
1026 if(lpDisplayName)
1027 {
1028 r = RegSetValueExW(hKey, szDisplayName, 0, REG_SZ, (const BYTE*)lpDisplayName,
1029 (strlenW(lpDisplayName)+1)*sizeof(WCHAR) );
1030 if (r!=ERROR_SUCCESS)
1031 goto error;
1032 }
1033
1034 r = RegSetValueExW(hKey, szType, 0, REG_DWORD, (LPVOID)&dwServiceType, sizeof (DWORD) );
1035 if (r!=ERROR_SUCCESS)
1036 goto error;
1037
1038 r = RegSetValueExW(hKey, szStart, 0, REG_DWORD, (LPVOID)&dwStartType, sizeof (DWORD) );
1039 if (r!=ERROR_SUCCESS)
1040 goto error;
1041
1042 r = RegSetValueExW(hKey, szError, 0, REG_DWORD,
1043 (LPVOID)&dwErrorControl, sizeof (DWORD) );
1044 if (r!=ERROR_SUCCESS)
1045 goto error;
1046
1047 if(lpBinaryPathName)
1048 {
1049 r = RegSetValueExW(hKey, szImagePath, 0, REG_SZ, (const BYTE*)lpBinaryPathName,
1050 (strlenW(lpBinaryPathName)+1)*sizeof(WCHAR) );
1051 if (r!=ERROR_SUCCESS)
1052 goto error;
1053 }
1054
1055 if(lpLoadOrderGroup)
1056 {
1057 r = RegSetValueExW(hKey, szGroup, 0, REG_SZ, (const BYTE*)lpLoadOrderGroup,
1058 (strlenW(lpLoadOrderGroup)+1)*sizeof(WCHAR) );
1059 if (r!=ERROR_SUCCESS)
1060 goto error;
1061 }
1062
1063 if(lpDependencies)
1064 {
1065 DWORD len = 0;
1066
1067 /* determine the length of a double null terminated multi string */
1068 do {
1069 len += (strlenW(&lpDependencies[len])+1);
1070 } while (lpDependencies[len++]);
1071
1072 r = RegSetValueExW(hKey, szDependencies, 0, REG_MULTI_SZ,
1073 (const BYTE*)lpDependencies, len );
1074 if (r!=ERROR_SUCCESS)
1075 goto error;
1076 }
1077
1078 if(lpPassword)
1079 {
1080 FIXME("Don't know how to add a Password for a service.\n");
1081 }
1082
1083 if(lpServiceStartName)
1084 {
1085 FIXME("Don't know how to add a ServiceStartName for a service.\n");
1086 }
1087
1088 return (SC_HANDLE) retval;
1089
1090 error:
1091 free_sc_handle( retval );
1092 return NULL;
1093 }
1094
1095
1096 /******************************************************************************
1097 * CreateServiceA [ADVAPI32.@]
1098 */
1099 SC_HANDLE WINAPI
1100 CreateServiceA( SC_HANDLE hSCManager, LPCSTR lpServiceName,
1101 LPCSTR lpDisplayName, DWORD dwDesiredAccess,
1102 DWORD dwServiceType, DWORD dwStartType,
1103 DWORD dwErrorControl, LPCSTR lpBinaryPathName,
1104 LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId,
1105 LPCSTR lpDependencies, LPCSTR lpServiceStartName,
1106 LPCSTR lpPassword )
1107 {
1108 LPWSTR lpServiceNameW, lpDisplayNameW, lpBinaryPathNameW,
1109 lpLoadOrderGroupW, lpDependenciesW, lpServiceStartNameW, lpPasswordW;
1110 SC_HANDLE r;
1111
1112 TRACE("%p %s %s\n", hSCManager,
1113 debugstr_a(lpServiceName), debugstr_a(lpDisplayName));
1114
1115 lpServiceNameW = SERV_dup( lpServiceName );
1116 lpDisplayNameW = SERV_dup( lpDisplayName );
1117 lpBinaryPathNameW = SERV_dup( lpBinaryPathName );
1118 lpLoadOrderGroupW = SERV_dup( lpLoadOrderGroup );
1119 lpDependenciesW = SERV_dupmulti( lpDependencies );
1120 lpServiceStartNameW = SERV_dup( lpServiceStartName );
1121 lpPasswordW = SERV_dup( lpPassword );
1122
1123 r = CreateServiceW( hSCManager, lpServiceNameW, lpDisplayNameW,
1124 dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
1125 lpBinaryPathNameW, lpLoadOrderGroupW, lpdwTagId,
1126 lpDependenciesW, lpServiceStartNameW, lpPasswordW );
1127
1128 SERV_free( lpServiceNameW );
1129 SERV_free( lpDisplayNameW );
1130 SERV_free( lpBinaryPathNameW );
1131 SERV_free( lpLoadOrderGroupW );
1132 SERV_free( lpDependenciesW );
1133 SERV_free( lpServiceStartNameW );
1134 SERV_free( lpPasswordW );
1135
1136 return r;
1137 }
1138
1139
1140 /******************************************************************************
1141 * DeleteService [ADVAPI32.@]
1142 *
1143 * Delete a service from the service control manager database.
1144 *
1145 * PARAMS
1146 * hService [I] Handle of the service to delete
1147 *
1148 * RETURNS
1149 * Success: TRUE
1150 * Failure: FALSE
1151 */
1152 BOOL WINAPI DeleteService( SC_HANDLE hService )
1153 {
1154 struct sc_handle *hsvc = hService;
1155 HKEY hKey = hsvc->u.service.hkey;
1156 WCHAR valname[MAX_PATH+1];
1157 INT index = 0;
1158 LONG rc;
1159 DWORD size;
1160
1161 size = MAX_PATH+1;
1162 /* Clean out the values */
1163 rc = RegEnumValueW(hKey, index, valname,&size,0,0,0,0);
1164 while (rc == ERROR_SUCCESS)
1165 {
1166 RegDeleteValueW(hKey,valname);
1167 index++;
1168 size = MAX_PATH+1;
1169 rc = RegEnumValueW(hKey, index, valname, &size,0,0,0,0);
1170 }
1171
1172 RegCloseKey(hKey);
1173 hsvc->u.service.hkey = NULL;
1174
1175 /* delete the key */
1176 RegDeleteKeyW(hsvc->u.service.sc_manager->u.manager.hkey_scm_db,
1177 hsvc->u.service.name);
1178
1179 return TRUE;
1180 }
1181
1182
1183 /******************************************************************************
1184 * StartServiceA [ADVAPI32.@]
1185 *
1186 * Start a service
1187 *
1188 * PARAMS
1189 * hService [I] Handle of service
1190 * dwNumServiceArgs [I] Number of arguments
1191 * lpServiceArgVectors [I] Address of array of argument strings
1192 *
1193 * NOTES
1194 * - NT implements this function using an obscure RPC call.
1195 * - You might need to do a "setenv SystemRoot \\WINNT" in your .cshrc
1196 * to get things like "%SystemRoot%\\System32\\service.exe" to load.
1197 * - This will only work for shared address space. How should the service
1198 * args be transferred when address spaces are separated?
1199 * - Can only start one service at a time.
1200 * - Has no concept of privilege.
1201 *
1202 * RETURNS
1203 * Success: TRUE.
1204 * Failure: FALSE
1205 */
1206 BOOL WINAPI
1207 StartServiceA( SC_HANDLE hService, DWORD dwNumServiceArgs,
1208 LPCSTR *lpServiceArgVectors )
1209 {
1210 LPWSTR *lpwstr=NULL;
1211 UNICODE_STRING usBuffer;
1212 unsigned int i;
1213
1214 TRACE("(%p,%ld,%p)\n",hService,dwNumServiceArgs,lpServiceArgVectors);
1215
1216 if(dwNumServiceArgs)
1217 lpwstr = (LPWSTR*) HeapAlloc( GetProcessHeap(), 0,
1218 dwNumServiceArgs*sizeof(LPWSTR) );
1219 else
1220 lpwstr = NULL;
1221
1222 for(i=0; i<dwNumServiceArgs; i++)
1223 {
1224 RtlCreateUnicodeStringFromAsciiz (&usBuffer,lpServiceArgVectors[i]);
1225 lpwstr[i]=usBuffer.Buffer;
1226 }
1227
1228 StartServiceW(hService, dwNumServiceArgs, (LPCWSTR *)lpwstr);
1229
1230 if(dwNumServiceArgs)
1231 {
1232 for(i=0; i<dwNumServiceArgs; i++)
1233 HeapFree(GetProcessHeap(), 0, lpwstr[i]);
1234 HeapFree(GetProcessHeap(), 0, lpwstr);
1235 }
1236
1237 return TRUE;
1238 }
1239
1240
1241 /******************************************************************************
1242 * StartServiceW [ADVAPI32.@]
1243 *
1244 * See StartServiceA.
1245 */
1246 BOOL WINAPI
1247 StartServiceW( SC_HANDLE hService, DWORD dwNumServiceArgs,
1248 LPCWSTR *lpServiceArgVectors )
1249 {
1250 static const WCHAR _ImagePathW[] = {'I','m','a','g','e','P','a','t','h',0};
1251
1252 struct sc_handle *hsvc = hService;
1253 WCHAR path[MAX_PATH],str[MAX_PATH];
1254 DWORD type,size;
1255 DWORD i;
1256 long r;
1257 HANDLE hLock;
1258 HANDLE hServiceShmem = NULL;
1259 HANDLE wait = NULL;
1260 LPWSTR shmem_lock = NULL;
1261 struct SEB *seb = NULL;
1262 LPWSTR argptr;
1263 PROCESS_INFORMATION procinfo;
1264 STARTUPINFOW startupinfo;
1265 BOOL ret = FALSE;
1266
1267 TRACE("(%p,%ld,%p)\n",hService,dwNumServiceArgs,
1268 lpServiceArgVectors);
1269
1270 size = sizeof(str);
1271 r = RegQueryValueExW(hsvc->u.service.hkey, _ImagePathW, NULL, &type, (LPVOID)str, &size);
1272 if (r!=ERROR_SUCCESS)
1273 return FALSE;
1274 ExpandEnvironmentStringsW(str,path,sizeof(path));
1275
1276 TRACE("Starting service %s\n", debugstr_w(path) );
1277
1278 hLock = LockServiceDatabase( hsvc->u.service.sc_manager );
1279 if( NULL == hLock )
1280 return FALSE;
1281
1282 /*
1283 * FIXME: start dependent services
1284 */
1285
1286 /* pass argv[0] (service name) to the service via global SCM lock object */
1287 shmem_lock = MapViewOfFile( hLock, FILE_MAP_ALL_ACCESS,
1288 0, 0, MAX_SERVICE_NAME * sizeof(WCHAR) );
1289 if( NULL == shmem_lock )
1290 {
1291 ERR("Couldn't map shared memory\n");
1292 goto done;
1293 }
1294 strcpyW( shmem_lock, hsvc->u.service.name );
1295
1296 /* create service environment block */
1297 size = sizeof(struct SEB);
1298 for( i = 0; i < dwNumServiceArgs; i++ )
1299 size += sizeof(WCHAR) * (1 + strlenW( lpServiceArgVectors[ i ] ));
1300
1301 snprintfW( str, MAX_PATH, szServiceShmemNameFmtW, hsvc->u.service.name );
1302 hServiceShmem = CreateFileMappingW( INVALID_HANDLE_VALUE,
1303 NULL, PAGE_READWRITE, 0, size, str );
1304 if( NULL == hServiceShmem )
1305 {
1306 ERR("Couldn't create shared memory object\n");
1307 goto done;
1308 }
1309 if( GetLastError() == ERROR_ALREADY_EXISTS )
1310 {
1311 SetLastError( ERROR_SERVICE_ALREADY_RUNNING );
1312 goto done;
1313 }
1314 seb = MapViewOfFile( hServiceShmem, FILE_MAP_ALL_ACCESS, 0, 0, 0 );
1315 if( NULL == seb )
1316 {
1317 ERR("Couldn't map shared memory\n");
1318 goto done;
1319 }
1320
1321 /* copy service args to SEB */
1322 seb->argc = dwNumServiceArgs;
1323 argptr = (LPWSTR) &seb[1];
1324 for( i = 0; i < dwNumServiceArgs; i++ )
1325 {
1326 strcpyW( argptr, lpServiceArgVectors[ i ] );
1327 argptr += 1 + strlenW( argptr );
1328 }
1329
1330 wait = CreateSemaphoreW(NULL,0,1,szWaitServiceStartW);
1331 if (!wait)
1332 {
1333 ERR("Couldn't create wait semaphore\n");
1334 goto done;
1335 }
1336
1337 ZeroMemory(&startupinfo,sizeof(STARTUPINFOW));
1338 startupinfo.cb = sizeof(STARTUPINFOW);
1339
1340 r = CreateProcessW(NULL,
1341 path,
1342 NULL, /* process security attribs */
1343 NULL, /* thread security attribs */
1344 FALSE, /* inherit handles */
1345 0, /* creation flags */
1346 NULL, /* environment */
1347 NULL, /* current directory */
1348 &startupinfo, /* startup info */
1349 &procinfo); /* process info */
1350
1351 if(r == FALSE)
1352 {
1353 ERR("Couldn't start process\n");
1354 goto done;
1355 }
1356 CloseHandle( procinfo.hThread );
1357
1358 /* docs for StartServiceCtrlDispatcher say this should be 30 sec */
1359 r = WaitForSingleObject(wait,30000);
1360 if( WAIT_FAILED == r )
1361 {
1362 CloseHandle( procinfo.hProcess );
1363 goto done;
1364 }
1365 if( WAIT_TIMEOUT == r )
1366 {
1367 TerminateProcess( procinfo.hProcess, 1 );
1368 CloseHandle( procinfo.hProcess );
1369 SetLastError( ERROR_SERVICE_REQUEST_TIMEOUT );
1370 goto done;
1371 }
1372
1373 /* allright */
1374 CloseHandle( procinfo.hProcess );
1375 ret = TRUE;
1376
1377 done:
1378 if( wait ) CloseHandle( wait );
1379 if( seb != NULL ) UnmapViewOfFile( seb );
1380 if( hServiceShmem != NULL ) CloseHandle( hServiceShmem );
1381 if( shmem_lock != NULL ) UnmapViewOfFile( shmem_lock );
1382 UnlockServiceDatabase( hLock );
1383 return ret;
1384 }
1385
1386 /******************************************************************************
1387 * QueryServiceStatus [ADVAPI32.@]
1388 *
1389 * PARAMS
1390 * hService []
1391 * lpservicestatus []
1392 *
1393 */
1394 BOOL WINAPI
1395 QueryServiceStatus( SC_HANDLE hService, LPSERVICE_STATUS lpservicestatus )
1396 {
1397 struct sc_handle *hsvc = hService;
1398 LONG r;
1399 DWORD type, val, size;
1400 WCHAR object_name[ MAX_PATH ];
1401 HANDLE mutex, shmem = NULL;
1402 struct SEB *seb = NULL;
1403 BOOL ret = FALSE, mutex_owned = FALSE;
1404
1405 /* try to open service mutex */
1406 snprintfW( object_name, MAX_PATH, szServiceMutexNameFmtW, hsvc->u.service.name );
1407 mutex = OpenMutexW( MUTEX_ALL_ACCESS, FALSE, object_name );
1408 if( NULL == mutex )
1409 goto stopped;
1410
1411 /* hold mutex */
1412 r = WaitForSingleObject( mutex, 30000 );
1413 if( WAIT_FAILED == r )
1414 goto done;
1415
1416 if( WAIT_TIMEOUT == r )
1417 {
1418 SetLastError( ERROR_SERVICE_REQUEST_TIMEOUT );
1419 goto done;
1420 }
1421 mutex_owned = TRUE;
1422
1423 /* get service environment block */
1424 seb = open_seb_shmem( hsvc->u.service.name, &shmem );
1425 if( NULL == seb )
1426 goto done;
1427
1428 /* get status */
1429 memcpy( lpservicestatus, &seb->status, sizeof(SERVICE_STATUS) );
1430 ret = TRUE;
1431
1432 done:
1433 if( seb ) UnmapViewOfFile( seb );
1434 if( shmem ) CloseHandle( shmem );
1435 if( mutex_owned ) ReleaseMutex( mutex );
1436 CloseHandle( mutex );
1437 return ret;
1438
1439 stopped:
1440 /* service stopped */
1441 /* read the service type from the registry */
1442 size = sizeof(val);
1443 r = RegQueryValueExA(hsvc->u.service.hkey, "Type", NULL, &type, (LPBYTE)&val, &size);
1444 if(type!=REG_DWORD)
1445 {
1446 ERR("invalid Type\n");
1447 return FALSE;
1448 }
1449 lpservicestatus->dwServiceType = val;
1450 lpservicestatus->dwCurrentState = 1; /* stopped */
1451 lpservicestatus->dwControlsAccepted = 0;
1452 lpservicestatus->dwWin32ExitCode = NO_ERROR;
1453 lpservicestatus->dwServiceSpecificExitCode = 0;
1454 lpservicestatus->dwCheckPoint = 0;
1455 lpservicestatus->dwWaitHint = 0;
1456
1457 return TRUE;
1458 }
1459
1460 /******************************************************************************
1461 * QueryServiceStatusEx [ADVAPI32.@]
1462 *
1463 * Get information about a service.
1464 *
1465 * PARAMS
1466 * hService [I] Handle to service to get information about
1467 * InfoLevel [I] Level of information to get
1468 * lpBuffer [O] Destination for requested information
1469 * cbBufSize [I] Size of lpBuffer in bytes
1470 * pcbBytesNeeded [O] Destination for number of bytes needed, if cbBufSize is too small
1471 *
1472 * RETURNS
1473 * Success: TRUE
1474 * FAILURE: FALSE
1475 */
1476 BOOL WINAPI QueryServiceStatusEx(SC_HANDLE hService, SC_STATUS_TYPE InfoLevel,
1477 LPBYTE lpBuffer, DWORD cbBufSize,
1478 LPDWORD pcbBytesNeeded)
1479 {
1480 FIXME("stub\n");
1481 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1482 return FALSE;
1483 }
1484
1485 /******************************************************************************
1486 * QueryServiceConfigA [ADVAPI32.@]
1487 */
1488 BOOL WINAPI
1489 QueryServiceConfigA( SC_HANDLE hService,
1490 LPQUERY_SERVICE_CONFIGA lpServiceConfig,
1491 DWORD cbBufSize, LPDWORD pcbBytesNeeded)
1492 {
1493 static const CHAR szDisplayName[] = "DisplayName";
1494 static const CHAR szType[] = "Type";
1495 static const CHAR szStart[] = "Start";
1496 static const CHAR szError[] = "ErrorControl";
1497 static const CHAR szImagePath[] = "ImagePath";
1498 static const CHAR szGroup[] = "Group";
1499 static const CHAR szDependencies[] = "Dependencies";
1500 HKEY hKey = ((struct sc_handle*) hService)->u.service.hkey;
1501 CHAR str_buffer[ MAX_PATH ];
1502 LONG r;
1503 DWORD type, val, sz, total, n;
1504 LPBYTE p;
1505
1506 TRACE("%p %p %ld %p\n", hService, lpServiceConfig,
1507 cbBufSize, pcbBytesNeeded);
1508
1509 /* calculate the size required first */
1510 total = sizeof (QUERY_SERVICE_CONFIGA);
1511
1512 sz = sizeof(str_buffer);
1513 r = RegQueryValueExA( hKey, szImagePath, 0, &type, str_buffer, &sz );
1514 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ || type == REG_EXPAND_SZ ) )
1515 {
1516 sz = ExpandEnvironmentStringsA(str_buffer,NULL,0);
1517 if( 0 == sz ) return FALSE;
1518
1519 total += sz;
1520 }
1521 else
1522 {
1523 /* FIXME: set last error */
1524 return FALSE;
1525 }
1526
1527 sz = 0;
1528 r = RegQueryValueExA( hKey, szGroup, 0, &type, NULL, &sz );
1529 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
1530 total += sz;
1531
1532 sz = 0;
1533 r = RegQueryValueExA( hKey, szDependencies, 0, &type, NULL, &sz );
1534 if( ( r == ERROR_SUCCESS ) && ( type == REG_MULTI_SZ ) )
1535 total += sz;
1536
1537 sz = 0;
1538 r = RegQueryValueExA( hKey, szStart, 0, &type, NULL, &sz );
1539 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
1540 total += sz;
1541
1542 sz = 0;
1543 r = RegQueryValueExA( hKey, szDisplayName, 0, &type, NULL, &sz );
1544 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
1545 total += sz;
1546
1547 /* if there's not enough memory, return an error */
1548 if( total > *pcbBytesNeeded )
1549 {
1550 *pcbBytesNeeded = total;
1551 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1552 return FALSE;
1553 }
1554
1555 *pcbBytesNeeded = total;
1556 ZeroMemory( lpServiceConfig, total );
1557
1558 sz = sizeof val;
1559 r = RegQueryValueExA( hKey, szType, 0, &type, (LPBYTE)&val, &sz );
1560 if( ( r == ERROR_SUCCESS ) || ( type == REG_DWORD ) )
1561 lpServiceConfig->dwServiceType = val;
1562
1563 sz = sizeof val;
1564 r = RegQueryValueExA( hKey, szStart, 0, &type, (LPBYTE)&val, &sz );
1565 if( ( r == ERROR_SUCCESS ) || ( type == REG_DWORD ) )
1566 lpServiceConfig->dwStartType = val;
1567
1568 sz = sizeof val;
1569 r = RegQueryValueExA( hKey, szError, 0, &type, (LPBYTE)&val, &sz );
1570 if( ( r == ERROR_SUCCESS ) || ( type == REG_DWORD ) )
1571 lpServiceConfig->dwErrorControl = val;
1572
1573 /* now do the strings */
1574 p = (LPBYTE) &lpServiceConfig[1];
1575 n = total - sizeof (QUERY_SERVICE_CONFIGA);
1576
1577 sz = sizeof(str_buffer);
1578 r = RegQueryValueExA( hKey, szImagePath, 0, &type, str_buffer, &sz );
1579 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ || type == REG_EXPAND_SZ ) )
1580 {
1581 sz = ExpandEnvironmentStringsA(str_buffer, p, n);
1582 if( 0 == sz || sz > n ) return FALSE;
1583
1584 lpServiceConfig->lpBinaryPathName = (LPSTR) p;
1585 p += sz;
1586 n -= sz;
1587 }
1588 else
1589 {
1590 /* FIXME: set last error */
1591 return FALSE;
1592 }
1593
1594 sz = n;
1595 r = RegQueryValueExA( hKey, szGroup, 0, &type, p, &sz );
1596 if( ( r == ERROR_SUCCESS ) || ( type == REG_SZ ) )
1597 {
1598 lpServiceConfig->lpLoadOrderGroup = (LPSTR) p;
1599 p += sz;
1600 n -= sz;
1601 }
1602
1603 sz = n;
1604 r = RegQueryValueExA( hKey, szDependencies, 0, &type, p, &sz );
1605 if( ( r == ERROR_SUCCESS ) || ( type == REG_SZ ) )
1606 {
1607 lpServiceConfig->lpDependencies = (LPSTR) p;
1608 p += sz;
1609 n -= sz;
1610 }
1611
1612 if( n < 0 )
1613 ERR("Buffer overflow!\n");
1614
1615 TRACE("Image path = %s\n", lpServiceConfig->lpBinaryPathName );
1616 TRACE("Group = %s\n", lpServiceConfig->lpLoadOrderGroup );
1617
1618 return TRUE;
1619 }
1620
1621 /******************************************************************************
1622 * QueryServiceConfigW [ADVAPI32.@]
1623 */
1624 BOOL WINAPI
1625 QueryServiceConfigW( SC_HANDLE hService,
1626 LPQUERY_SERVICE_CONFIGW lpServiceConfig,
1627 DWORD cbBufSize, LPDWORD pcbBytesNeeded)
1628 {
1629 static const WCHAR szDisplayName[] = {
1630 'D','i','s','p','l','a','y','N','a','m','e', 0 };
1631 static const WCHAR szType[] = {'T','y','p','e',0};
1632 static const WCHAR szStart[] = {'S','t','a','r','t',0};
1633 static const WCHAR szError[] = {
1634 'E','r','r','o','r','C','o','n','t','r','o','l', 0};
1635 static const WCHAR szImagePath[] = {'I','m','a','g','e','P','a','t','h',0};
1636 static const WCHAR szGroup[] = {'G','r','o','u','p',0};
1637 static const WCHAR szDependencies[] = {
1638 'D','e','p','e','n','d','e','n','c','i','e','s',0};
1639 HKEY hKey = ((struct sc_handle*) hService)->u.service.hkey;
1640 WCHAR str_buffer[ MAX_PATH ];
1641 LONG r;
1642 DWORD type, val, sz, total, n;
1643 LPBYTE p;
1644
1645 TRACE("%p %p %ld %p\n", hService, lpServiceConfig,
1646 cbBufSize, pcbBytesNeeded);
1647
1648 /* calculate the size required first */
1649 total = sizeof (QUERY_SERVICE_CONFIGW);
1650
1651 sz = sizeof(str_buffer);
1652 r = RegQueryValueExW( hKey, szImagePath, 0, &type, (LPBYTE) str_buffer, &sz );
1653 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ || type == REG_EXPAND_SZ ) )
1654 {
1655 sz = ExpandEnvironmentStringsW(str_buffer,NULL,0);
1656 if( 0 == sz ) return FALSE;
1657
1658 total += sizeof(WCHAR) * sz;
1659 }
1660 else
1661 {
1662 /* FIXME: set last error */
1663 return FALSE;
1664 }
1665
1666 sz = 0;
1667 r = RegQueryValueExW( hKey, szGroup, 0, &type, NULL, &sz );
1668 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
1669 total += sz;
1670
1671 sz = 0;
1672 r = RegQueryValueExW( hKey, szDependencies, 0, &type, NULL, &sz );
1673 if( ( r == ERROR_SUCCESS ) && ( type == REG_MULTI_SZ ) )
1674 total += sz;
1675
1676 sz = 0;
1677 r = RegQueryValueExW( hKey, szStart, 0, &type, NULL, &sz );
1678 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
1679 total += sz;
1680
1681 sz = 0;
1682 r = RegQueryValueExW( hKey, szDisplayName, 0, &type, NULL, &sz );
1683 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
1684 total += sz;
1685
1686 /* if there's not enough memory, return an error */
1687 if( total > *pcbBytesNeeded )
1688 {
1689 *pcbBytesNeeded = total;
1690 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1691 return FALSE;
1692 }
1693
1694 *pcbBytesNeeded = total;
1695 ZeroMemory( lpServiceConfig, total );
1696
1697 sz = sizeof val;
1698 r = RegQueryValueExW( hKey, szType, 0, &type, (LPBYTE)&val, &sz );
1699 if( ( r == ERROR_SUCCESS ) || ( type == REG_DWORD ) )
1700 lpServiceConfig->dwServiceType = val;
1701
1702 sz = sizeof val;
1703 r = RegQueryValueExW( hKey, szStart, 0, &type, (LPBYTE)&val, &sz );
1704 if( ( r == ERROR_SUCCESS ) || ( type == REG_DWORD ) )
1705 lpServiceConfig->dwStartType = val;
1706
1707 sz = sizeof val;
1708 r = RegQueryValueExW( hKey, szError, 0, &type, (LPBYTE)&val, &sz );
1709 if( ( r == ERROR_SUCCESS ) || ( type == REG_DWORD ) )
1710 lpServiceConfig->dwErrorControl = val;
1711
1712 /* now do the strings */
1713 p = (LPBYTE) &lpServiceConfig[1];
1714 n = total - sizeof (QUERY_SERVICE_CONFIGW);
1715
1716 sz = sizeof(str_buffer);
1717 r = RegQueryValueExW( hKey, szImagePath, 0, &type, (LPBYTE) str_buffer, &sz );
1718 if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ || type == REG_EXPAND_SZ ) )
1719 {
1720 sz = ExpandEnvironmentStringsW(str_buffer, (LPWSTR) p, n);
1721 sz *= sizeof(WCHAR);
1722 if( 0 == sz || sz > n ) return FALSE;
1723
1724 lpServiceConfig->lpBinaryPathName = (LPWSTR) p;
1725 p += sz;
1726 n -= sz;
1727 }
1728 else
1729 {
1730 /* FIXME: set last error */
1731 return FALSE;
1732 }
1733
1734 sz = n;
1735 r = RegQueryValueExW( hKey, szGroup, 0, &type, p, &sz );
1736 if( ( r == ERROR_SUCCESS ) || ( type == REG_SZ ) )
1737 {
1738 lpServiceConfig->lpLoadOrderGroup = (LPWSTR) p;
1739 p += sz;
1740 n -= sz;
1741 }
1742
1743 sz = n;
1744 r = RegQueryValueExW( hKey, szDependencies, 0, &type, p, &sz );
1745 if( ( r == ERROR_SUCCESS ) || ( type == REG_SZ ) )
1746 {
1747 lpServiceConfig->lpDependencies = (LPWSTR) p;
1748 p += sz;
1749 n -= sz;
1750 }
1751
1752 if( n < 0 )
1753 ERR("Buffer overflow!\n");
1754
1755 TRACE("Image path = %s\n", debugstr_w(lpServiceConfig->lpBinaryPathName) );
1756 TRACE("Group = %s\n", debugstr_w(lpServiceConfig->lpLoadOrderGroup) );
1757
1758 return TRUE;
1759 }
1760
1761
1762 /******************************************************************************
1763 * GetServiceDisplayNameA [ADVAPI32.@]
1764 */
1765 BOOL WINAPI GetServiceDisplayNameA( SC_HANDLE hSCManager, LPCSTR lpServiceName,
1766 LPSTR lpDisplayName, LPDWORD lpcchBuffer)
1767 {
1768 FIXME("%p %s %p %p\n", hSCManager,
1769 debugstr_a(lpServiceName), lpDisplayName, lpcchBuffer);
1770 return FALSE;
1771 }
1772
1773
1774 /******************************************************************************
1775 * GetServiceDisplayNameW [ADVAPI32.@]
1776 */
1777 BOOL WINAPI GetServiceDisplayNameW( SC_HANDLE hSCManager, LPCWSTR lpServiceName,
1778 LPWSTR lpDisplayName, LPDWORD lpcchBuffer)
1779 {
1780 FIXME("%p %s %p %p\n", hSCManager,
1781 debugstr_w(lpServiceName), lpDisplayName, lpcchBuffer);
1782 return FALSE;
1783 }
1784
1785
1786 /******************************************************************************
1787 * ChangeServiceConfigW [ADVAPI32.@]
1788 */
1789 BOOL WINAPI ChangeServiceConfigW( SC_HANDLE hService, DWORD dwServiceType,
1790 DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName,
1791 LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies,
1792 LPCWSTR lpServiceStartName, LPCWSTR lpPassword, LPCWSTR lpDisplayName)
1793 {
1794 FIXME("%p %ld %ld %ld %s %s %p %p %s %s %s\n",
1795 hService, dwServiceType, dwStartType, dwErrorControl,
1796 debugstr_w(lpBinaryPathName), debugstr_w(lpLoadOrderGroup),
1797 lpdwTagId, lpDependencies, debugstr_w(lpServiceStartName),
1798 debugstr_w(lpPassword), debugstr_w(lpDisplayName) );
1799 return TRUE;
1800 }
1801
1802 /******************************************************************************
1803 * ChangeServiceConfigA [ADVAPI32.@]
1804 */
1805 BOOL WINAPI ChangeServiceConfigA( SC_HANDLE hService, DWORD dwServiceType,
1806 DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpBinaryPathName,
1807 LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCSTR lpDependencies,
1808 LPCSTR lpServiceStartName, LPCSTR lpPassword, LPCSTR lpDisplayName)
1809 {
1810 LPWSTR wBinaryPathName, wLoadOrderGroup, wDependencies;
1811 LPWSTR wServiceStartName, wPassword, wDisplayName;
1812 BOOL r;
1813
1814 TRACE("%p %ld %ld %ld %s %s %p %p %s %s %s\n",
1815 hService, dwServiceType, dwStartType, dwErrorControl,
1816 debugstr_a(lpBinaryPathName), debugstr_a(lpLoadOrderGroup),
1817 lpdwTagId, lpDependencies, debugstr_a(lpServiceStartName),
1818 debugstr_a(lpPassword), debugstr_a(lpDisplayName) );
1819
1820 wBinaryPathName = SERV_dup( lpBinaryPathName );
1821 wLoadOrderGroup = SERV_dup( lpLoadOrderGroup );
1822 wDependencies = SERV_dupmulti( lpDependencies );
1823 wServiceStartName = SERV_dup( lpServiceStartName );
1824 wPassword = SERV_dup( lpPassword );
1825 wDisplayName = SERV_dup( lpDisplayName );
1826
1827 r = ChangeServiceConfigW( hService, dwServiceType,
1828 dwStartType, dwErrorControl, wBinaryPathName,
1829 wLoadOrderGroup, lpdwTagId, wDependencies,
1830 wServiceStartName, wPassword, wDisplayName);
1831
1832 SERV_free( wBinaryPathName );
1833 SERV_free( wLoadOrderGroup );
1834 SERV_free( wDependencies );
1835 SERV_free( wServiceStartName );
1836 SERV_free( wPassword );
1837 SERV_free( wDisplayName );
1838
1839 return r;
1840 }
1841
1842 /******************************************************************************
1843 * ChangeServiceConfig2A [ADVAPI32.@]
1844 */
1845 BOOL WINAPI ChangeServiceConfig2A( SC_HANDLE hService, DWORD dwInfoLevel,
1846 LPVOID lpInfo)
1847 {
1848 BOOL r = FALSE;
1849
1850 TRACE("%p %ld %p\n",hService, dwInfoLevel, lpInfo);
1851
1852 if (dwInfoLevel == SERVICE_CONFIG_DESCRIPTION)
1853 {
1854 LPSERVICE_DESCRIPTIONA sd = (LPSERVICE_DESCRIPTIONA) lpInfo;
1855 SERVICE_DESCRIPTIONW sdw;
1856
1857 sdw.lpDescription = SERV_dup( sd->lpDescription );
1858
1859 r = ChangeServiceConfig2W( hService, dwInfoLevel, &sdw );
1860
1861 SERV_free( sdw.lpDescription );
1862 }
1863 else if (dwInfoLevel == SERVICE_CONFIG_FAILURE_ACTIONS)
1864 {
1865 LPSERVICE_FAILURE_ACTIONSA fa = (LPSERVICE_FAILURE_ACTIONSA) lpInfo;
1866 SERVICE_FAILURE_ACTIONSW faw;
1867
1868 faw.dwResetPeriod = fa->dwResetPeriod;
1869 faw.lpRebootMsg = SERV_dup( fa->lpRebootMsg );
1870 faw.lpCommand = SERV_dup( fa->lpCommand );
1871 faw.cActions = fa->cActions;
1872 faw.lpsaActions = fa->lpsaActions;
1873
1874 r = ChangeServiceConfig2W( hService, dwInfoLevel, &faw );
1875
1876 SERV_free( faw.lpRebootMsg );
1877 SERV_free( faw.lpCommand );
1878 }
1879 else
1880 SetLastError( ERROR_INVALID_PARAMETER );
1881
1882 return r;
1883 }
1884
1885 /******************************************************************************
1886 * ChangeServiceConfig2W [ADVAPI32.@]
1887 */
1888 BOOL WINAPI ChangeServiceConfig2W( SC_HANDLE hService, DWORD dwInfoLevel,
1889 LPVOID lpInfo)
1890 {
1891 HKEY hKey = ((struct sc_handle*) hService)->u.service.hkey;
1892
1893 if (dwInfoLevel == SERVICE_CONFIG_DESCRIPTION)
1894 {
1895 static const WCHAR szDescription[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
1896 LPSERVICE_DESCRIPTIONW sd = (LPSERVICE_DESCRIPTIONW)lpInfo;
1897 if (sd->lpDescription)
1898 {
1899 TRACE("Setting Description to %s\n",debugstr_w(sd->lpDescription));
1900 if (sd->lpDescription[0] == 0)
1901 RegDeleteValueW(hKey,szDescription);
1902 else
1903 RegSetValueExW(hKey, szDescription, 0, REG_SZ,
1904 (LPVOID)sd->lpDescription,
1905 sizeof(WCHAR)*(strlenW(sd->lpDescription)+1));
1906 }
1907 }
1908 else
1909 FIXME("STUB: %p %ld %p\n",hService, dwInfoLevel, lpInfo);
1910 return TRUE;
1911 }
1912
1913 /******************************************************************************
1914 * QueryServiceObjectSecurity [ADVAPI32.@]
1915 */
1916 BOOL WINAPI QueryServiceObjectSecurity(SC_HANDLE hService,
1917 SECURITY_INFORMATION dwSecurityInformation,
1918 PSECURITY_DESCRIPTOR lpSecurityDescriptor,
1919 DWORD cbBufSize, LPDWORD pcbBytesNeeded)
1920 {
1921 PACL pACL = NULL;
1922 FIXME("%p %ld %p %lu %p\n", hService, dwSecurityInformation,
1923 lpSecurityDescriptor, cbBufSize, pcbBytesNeeded);
1924
1925
1926 InitializeSecurityDescriptor(lpSecurityDescriptor, SECURITY_DESCRIPTOR_REVISION);
1927
1928 pACL = HeapAlloc( GetProcessHeap(), 0, sizeof(ACL) );
1929 InitializeAcl(pACL, sizeof(ACL), ACL_REVISION);
1930 SetSecurityDescriptorDacl(lpSecurityDescriptor, TRUE, pACL, TRUE);
1931 return TRUE;
1932 }
1933
1934 /******************************************************************************
1935 * SetServiceObjectSecurity [ADVAPI32.@]
1936 */
1937 BOOL WINAPI SetServiceObjectSecurity(SC_HANDLE hService,
1938 SECURITY_INFORMATION dwSecurityInformation,
1939 PSECURITY_DESCRIPTOR lpSecurityDescriptor)
1940 {
1941 FIXME("%p %ld %p\n", hService, dwSecurityInformation, lpSecurityDescriptor);
1942 return TRUE;
1943 }
Windows API implementation