?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
include: Be consistent in naming regarding MSF's block.
[wine.git] / dlls / sechost / service.c
blobb00e5536edaefa9828628b105c624f19e86af936
1 /*
2 * Service control API
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 #define NONAMELESSUNION
24 #include <stdarg.h>
25 #define WINADVAPI
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winsvc.h"
29 #include "winternl.h"
30 #include "winuser.h"
31 #include "dbt.h"
32
33 #include "wine/debug.h"
34 #include "wine/exception.h"
35 #include "wine/heap.h"
36 #include "wine/list.h"
37
38 #include "svcctl.h"
39 #include "plugplay.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(service);
42
43 struct notify_data
44 {
45 SC_HANDLE service;
46 SC_RPC_NOTIFY_PARAMS params;
47 SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_2 cparams;
48 SC_NOTIFY_RPC_HANDLE notify_handle;
49 SERVICE_NOTIFYW *notify_buffer;
50 HANDLE calling_thread, ready_evt;
51 struct list entry;
52 };
53
54 static struct list notify_list = LIST_INIT(notify_list);
55
56 static CRITICAL_SECTION service_cs;
57 static CRITICAL_SECTION_DEBUG service_cs_debug =
58 {
59 0, 0, &service_cs,
60 { &service_cs_debug.ProcessLocksList,
61 &service_cs_debug.ProcessLocksList },
62 0, 0, { (DWORD_PTR)(__FILE__ ": service_cs") }
63 };
64 static CRITICAL_SECTION service_cs = { &service_cs_debug, -1, 0, 0, 0, 0 };
65
66 struct service_data
67 {
68 LPHANDLER_FUNCTION_EX handler;
69 void *context;
70 HANDLE thread;
71 SC_HANDLE handle;
72 SC_HANDLE full_access_handle;
73 unsigned int unicode : 1;
74 union
75 {
76 LPSERVICE_MAIN_FUNCTIONA a;
77 LPSERVICE_MAIN_FUNCTIONW w;
78 } proc;
79 WCHAR *args;
80 WCHAR name[1];
81 };
82
83 struct dispatcher_data
84 {
85 SC_HANDLE manager;
86 HANDLE pipe;
87 };
88
89 static struct service_data **services;
90 static unsigned int nb_services;
91 static HANDLE service_event;
92 static BOOL stop_service;
93
94 static WCHAR *heap_strdupAtoW( const char *src )
95 {
96 WCHAR *dst = NULL;
97 if (src)
98 {
99 DWORD len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 );
100 if ((dst = heap_alloc( len * sizeof(WCHAR) ))) MultiByteToWideChar( CP_ACP, 0, src, -1, dst, len );
101 }
102 return dst;
103 }
104
105 static WCHAR *heap_strdup_multi_AtoW( const char *src )
106 {
107 WCHAR *dst = NULL;
108 const char *p = src;
109 DWORD len;
110
111 if (!src) return NULL;
112
113 while (*p) p += strlen(p) + 1;
114 for (p = src; *p; p += strlen(p) + 1);
115 p++; /* final null */
116 len = MultiByteToWideChar( CP_ACP, 0, src, p - src, NULL, 0 );
117 if ((dst = heap_alloc( len * sizeof(WCHAR) ))) MultiByteToWideChar( CP_ACP, 0, src, p - src, dst, len );
118 return dst;
119 }
120
121 static inline DWORD multisz_size( const WCHAR *str )
122 {
123 const WCHAR *p = str;
124
125 if (!str) return 0;
126
127 while (*p) p += wcslen(p) + 1;
128 return (p - str + 1) * sizeof(WCHAR);
129 }
130
131 void __RPC_FAR * __RPC_USER MIDL_user_allocate( SIZE_T len )
132 {
133 return heap_alloc(len);
134 }
135
136 void __RPC_USER MIDL_user_free( void __RPC_FAR *ptr )
137 {
138 heap_free(ptr);
139 }
140
141 static LONG WINAPI rpc_filter( EXCEPTION_POINTERS *eptr )
142 {
143 return I_RpcExceptionFilter( eptr->ExceptionRecord->ExceptionCode );
144 }
145
146 static DWORD map_exception_code( DWORD exception_code )
147 {
148 switch (exception_code)
149 {
150 case RPC_X_NULL_REF_POINTER:
151 return ERROR_INVALID_ADDRESS;
152 case RPC_X_ENUM_VALUE_OUT_OF_RANGE:
153 case RPC_X_BYTE_COUNT_TOO_SMALL:
154 return ERROR_INVALID_PARAMETER;
155 case RPC_S_INVALID_BINDING:
156 case RPC_X_SS_IN_NULL_CONTEXT:
157 return ERROR_INVALID_HANDLE;
158 default:
159 return exception_code;
160 }
161 }
162
163 static handle_t rpc_wstr_bind( RPC_WSTR str )
164 {
165 WCHAR transport[] = SVCCTL_TRANSPORT;
166 WCHAR endpoint[] = SVCCTL_ENDPOINT;
167 RPC_WSTR binding_str;
168 RPC_STATUS status;
169 handle_t rpc_handle;
170
171 status = RpcStringBindingComposeW( NULL, transport, str, endpoint, NULL, &binding_str );
172 if (status != RPC_S_OK)
173 {
174 ERR("RpcStringBindingComposeW failed, error %ld\n", status);
175 return NULL;
176 }
177
178 status = RpcBindingFromStringBindingW( binding_str, &rpc_handle );
179 RpcStringFreeW( &binding_str );
180
181 if (status != RPC_S_OK)
182 {
183 ERR("Couldn't connect to services.exe, error %ld\n", status);
184 return NULL;
185 }
186
187 return rpc_handle;
188 }
189
190 static handle_t rpc_cstr_bind(RPC_CSTR str)
191 {
192 RPC_CSTR transport = (RPC_CSTR)SVCCTL_TRANSPORTA;
193 RPC_CSTR endpoint = (RPC_CSTR)SVCCTL_ENDPOINTA;
194 RPC_CSTR binding_str;
195 RPC_STATUS status;
196 handle_t rpc_handle;
197
198 status = RpcStringBindingComposeA( NULL, transport, str, endpoint, NULL, &binding_str );
199 if (status != RPC_S_OK)
200 {
201 ERR("RpcStringBindingComposeA failed, error %ld\n", status);
202 return NULL;
203 }
204
205 status = RpcBindingFromStringBindingA( binding_str, &rpc_handle );
206 RpcStringFreeA( &binding_str );
207
208 if (status != RPC_S_OK)
209 {
210 ERR("Couldn't connect to services.exe, error %ld\n", status);
211 return NULL;
212 }
213
214 return rpc_handle;
215 }
216
217 DECLSPEC_HIDDEN handle_t __RPC_USER MACHINE_HANDLEA_bind( MACHINE_HANDLEA name )
218 {
219 return rpc_cstr_bind( (RPC_CSTR)name );
220 }
221
222 DECLSPEC_HIDDEN void __RPC_USER MACHINE_HANDLEA_unbind( MACHINE_HANDLEA name, handle_t h )
223 {
224 RpcBindingFree( &h );
225 }
226
227 DECLSPEC_HIDDEN handle_t __RPC_USER MACHINE_HANDLEW_bind( MACHINE_HANDLEW name )
228 {
229 return rpc_wstr_bind( (RPC_WSTR)name );
230 }
231
232 DECLSPEC_HIDDEN void __RPC_USER MACHINE_HANDLEW_unbind( MACHINE_HANDLEW name, handle_t h )
233 {
234 RpcBindingFree( &h );
235 }
236
237 DECLSPEC_HIDDEN handle_t __RPC_USER SVCCTL_HANDLEW_bind( SVCCTL_HANDLEW name )
238 {
239 return rpc_wstr_bind( (RPC_WSTR)name );
240 }
241
242 DECLSPEC_HIDDEN void __RPC_USER SVCCTL_HANDLEW_unbind( SVCCTL_HANDLEW name, handle_t h )
243 {
244 RpcBindingFree( &h );
245 }
246
247 static BOOL set_error( DWORD err )
248 {
249 if (err) SetLastError( err );
250 return !err;
251 }
252
253 /******************************************************************************
254 * OpenSCManagerA (sechost.@)
255 */
256 SC_HANDLE WINAPI DECLSPEC_HOTPATCH OpenSCManagerA( const char *machine, const char *database, DWORD access )
257 {
258 WCHAR *machineW, *databaseW;
259 SC_HANDLE ret;
260
261 machineW = heap_strdupAtoW( machine );
262 databaseW = heap_strdupAtoW( database );
263 ret = OpenSCManagerW( machineW, databaseW, access );
264 heap_free( databaseW );
265 heap_free( machineW );
266 return ret;
267 }
268
269 /******************************************************************************
270 * OpenSCManagerW (sechost.@)
271 */
272 SC_HANDLE WINAPI DECLSPEC_HOTPATCH OpenSCManagerW( const WCHAR *machine, const WCHAR *database, DWORD access )
273 {
274 SC_RPC_HANDLE handle = NULL;
275 DWORD err;
276
277 TRACE( "%s %s %#lx\n", debugstr_w(machine), debugstr_w(database), access );
278
279 __TRY
280 {
281 err = svcctl_OpenSCManagerW( machine, database, access, &handle );
282 }
283 __EXCEPT(rpc_filter)
284 {
285 err = map_exception_code( GetExceptionCode() );
286 }
287 __ENDTRY
288
289 if (!err) return handle;
290 SetLastError( err );
291 return NULL;
292 }
293
294 /******************************************************************************
295 * OpenServiceA (sechost.@)
296 */
297 SC_HANDLE WINAPI DECLSPEC_HOTPATCH OpenServiceA( SC_HANDLE manager, const char *name, DWORD access )
298 {
299 WCHAR *nameW;
300 SC_HANDLE ret;
301
302 TRACE( "%p %s %#lx\n", manager, debugstr_a(name), access );
303
304 nameW = heap_strdupAtoW( name );
305 ret = OpenServiceW( manager, nameW, access );
306 heap_free( nameW );
307 return ret;
308 }
309
310 /******************************************************************************
311 * OpenServiceW (sechost.@)
312 */
313 SC_HANDLE WINAPI DECLSPEC_HOTPATCH OpenServiceW( SC_HANDLE manager, const WCHAR *name, DWORD access )
314 {
315 SC_RPC_HANDLE handle = NULL;
316 DWORD err;
317
318 TRACE( "%p %s %#lx\n", manager, debugstr_w(name), access );
319
320 if (!manager)
321 {
322 SetLastError( ERROR_INVALID_HANDLE );
323 return NULL;
324 }
325
326 __TRY
327 {
328 err = svcctl_OpenServiceW( manager, name, access, &handle );
329 }
330 __EXCEPT(rpc_filter)
331 {
332 err = map_exception_code( GetExceptionCode() );
333 }
334 __ENDTRY
335
336 if (!err) return handle;
337 SetLastError( err );
338 return 0;
339 }
340
341 /******************************************************************************
342 * CreateServiceA (sechost.@)
343 */
344 SC_HANDLE WINAPI DECLSPEC_HOTPATCH CreateServiceA( SC_HANDLE manager, const char *name, const char *display_name,
345 DWORD access, DWORD service_type, DWORD start_type,
346 DWORD error_control, const char *path, const char *group,
347 DWORD *tag, const char *dependencies, const char *username,
348 const char *password )
349 {
350 WCHAR *nameW, *display_nameW, *pathW, *groupW, *dependenciesW, *usernameW, *passwordW;
351 SC_HANDLE handle;
352
353 TRACE( "%p %s %s\n", manager, debugstr_a(name), debugstr_a(display_name) );
354
355 nameW = heap_strdupAtoW( name );
356 display_nameW = heap_strdupAtoW( display_name );
357 pathW = heap_strdupAtoW( path );
358 groupW = heap_strdupAtoW( group );
359 dependenciesW = heap_strdup_multi_AtoW( dependencies );
360 usernameW = heap_strdupAtoW( username );
361 passwordW = heap_strdupAtoW( password );
362
363 handle = CreateServiceW( manager, nameW, display_nameW, access, service_type, start_type, error_control,
364 pathW, groupW, tag, dependenciesW, usernameW, passwordW );
365
366 heap_free( nameW );
367 heap_free( display_nameW );
368 heap_free( pathW );
369 heap_free( groupW );
370 heap_free( dependenciesW );
371 heap_free( usernameW );
372 heap_free( passwordW );
373
374 return handle;
375 }
376
377 /******************************************************************************
378 * CreateServiceW (sechost.@)
379 */
380 SC_HANDLE WINAPI DECLSPEC_HOTPATCH CreateServiceW( SC_HANDLE manager, const WCHAR *name, const WCHAR *display_name,
381 DWORD access, DWORD service_type, DWORD start_type,
382 DWORD error_control, const WCHAR *path, const WCHAR *group,
383 DWORD *tag, const WCHAR *dependencies, const WCHAR *username,
384 const WCHAR *password )
385 {
386 SC_RPC_HANDLE handle = NULL;
387 DWORD err;
388 SIZE_T password_size = 0;
389
390 TRACE( "%p %s %s\n", manager, debugstr_w(name), debugstr_w(display_name) );
391
392 if (!manager)
393 {
394 SetLastError( ERROR_INVALID_HANDLE );
395 return 0;
396 }
397
398 if (password) password_size = (wcslen(password) + 1) * sizeof(WCHAR);
399
400 __TRY
401 {
402 BOOL is_wow64;
403
404 if (IsWow64Process(GetCurrentProcess(), &is_wow64) && is_wow64)
405 err = svcctl_CreateServiceWOW64W( manager, name, display_name, access, service_type, start_type,
406 error_control, path, group, tag, (const BYTE *)dependencies,
407 multisz_size( dependencies ), username, (const BYTE *)password,
408 password_size, &handle );
409 else
410 err = svcctl_CreateServiceW( manager, name, display_name, access, service_type, start_type,
411 error_control, path, group, tag, (const BYTE *)dependencies,
412 multisz_size( dependencies ), username, (const BYTE *)password,
413 password_size, &handle );
414 }
415 __EXCEPT(rpc_filter)
416 {
417 err = map_exception_code( GetExceptionCode() );
418 }
419 __ENDTRY
420
421 if (!err) return handle;
422 SetLastError( err );
423 return NULL;
424 }
425
426 /******************************************************************************
427 * DeleteService (sechost.@)
428 */
429 BOOL WINAPI DECLSPEC_HOTPATCH DeleteService( SC_HANDLE service )
430 {
431 DWORD err;
432
433 TRACE( "%p\n", service );
434
435 __TRY
436 {
437 err = svcctl_DeleteService( service );
438 }
439 __EXCEPT(rpc_filter)
440 {
441 err = map_exception_code( GetExceptionCode() );
442 }
443 __ENDTRY
444
445 return set_error( err );
446 }
447
448 /******************************************************************************
449 * CloseServiceHandle (sechost.@)
450 */
451 BOOL WINAPI DECLSPEC_HOTPATCH CloseServiceHandle( SC_HANDLE handle )
452 {
453 DWORD err;
454
455 TRACE( "%p\n", handle );
456
457 __TRY
458 {
459 err = svcctl_CloseServiceHandle( (SC_RPC_HANDLE *)&handle );
460 }
461 __EXCEPT(rpc_filter)
462 {
463 err = map_exception_code( GetExceptionCode() );
464 }
465 __ENDTRY
466
467 return set_error( err );
468 }
469
470 /******************************************************************************
471 * ChangeServiceConfig2A (sechost.@)
472 */
473 BOOL WINAPI DECLSPEC_HOTPATCH ChangeServiceConfig2A( SC_HANDLE service, DWORD level, void *info)
474 {
475 BOOL r = FALSE;
476
477 TRACE( "%p %ld %p\n", service, level, info );
478
479 if (level == SERVICE_CONFIG_DESCRIPTION)
480 {
481 SERVICE_DESCRIPTIONA *sd = info;
482 SERVICE_DESCRIPTIONW sdw;
483
484 sdw.lpDescription = heap_strdupAtoW( sd->lpDescription );
485
486 r = ChangeServiceConfig2W( service, level, &sdw );
487
488 heap_free( sdw.lpDescription );
489 }
490 else if (level == SERVICE_CONFIG_FAILURE_ACTIONS)
491 {
492 SERVICE_FAILURE_ACTIONSA *fa = info;
493 SERVICE_FAILURE_ACTIONSW faw;
494
495 faw.dwResetPeriod = fa->dwResetPeriod;
496 faw.lpRebootMsg = heap_strdupAtoW( fa->lpRebootMsg );
497 faw.lpCommand = heap_strdupAtoW( fa->lpCommand );
498 faw.cActions = fa->cActions;
499 faw.lpsaActions = fa->lpsaActions;
500
501 r = ChangeServiceConfig2W( service, level, &faw );
502
503 heap_free( faw.lpRebootMsg );
504 heap_free( faw.lpCommand );
505 }
506 else if (level == SERVICE_CONFIG_PRESHUTDOWN_INFO)
507 {
508 r = ChangeServiceConfig2W( service, level, info );
509 }
510 else
511 SetLastError( ERROR_INVALID_PARAMETER );
512
513 return r;
514 }
515
516 /******************************************************************************
517 * ChangeServiceConfig2W (sechost.@)
518 */
519 BOOL WINAPI DECLSPEC_HOTPATCH ChangeServiceConfig2W( SC_HANDLE service, DWORD level, void *info )
520 {
521 SERVICE_RPC_REQUIRED_PRIVILEGES_INFO rpc_privinfo;
522 DWORD err;
523
524 __TRY
525 {
526 SC_RPC_CONFIG_INFOW rpc_info;
527
528 rpc_info.dwInfoLevel = level;
529 if (level == SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO)
530 {
531 SERVICE_REQUIRED_PRIVILEGES_INFOW *privinfo = info;
532
533 rpc_privinfo.cbRequiredPrivileges = multisz_size( privinfo->pmszRequiredPrivileges );
534 rpc_privinfo.pRequiredPrivileges = (BYTE *)privinfo->pmszRequiredPrivileges;
535 rpc_info.privinfo = &rpc_privinfo;
536 }
537 else
538 rpc_info.descr = info;
539 err = svcctl_ChangeServiceConfig2W( service, rpc_info );
540 }
541 __EXCEPT(rpc_filter)
542 {
543 err = map_exception_code( GetExceptionCode() );
544 }
545 __ENDTRY
546
547 return set_error( err );
548 }
549
550 /******************************************************************************
551 * ChangeServiceConfigA (sechost.@)
552 */
553 BOOL WINAPI DECLSPEC_HOTPATCH ChangeServiceConfigA( SC_HANDLE service, DWORD service_type, DWORD start_type,
554 DWORD error_control, const char *path, const char *group,
555 DWORD *tag, const char *dependencies, const char *username,
556 const char *password, const char *display_name )
557 {
558 WCHAR *pathW, *groupW, *dependenciesW, *usernameW, *passwordW, *display_nameW;
559 BOOL r;
560
561 TRACE( "%p %ld %ld %ld %s %s %p %p %s %s %s\n", service, service_type, start_type,
562 error_control, debugstr_a(path), debugstr_a(group), tag, dependencies,
563 debugstr_a(username), debugstr_a(password), debugstr_a(display_name) );
564
565 pathW = heap_strdupAtoW( path );
566 groupW = heap_strdupAtoW( group );
567 dependenciesW = heap_strdup_multi_AtoW( dependencies );
568 usernameW = heap_strdupAtoW( username );
569 passwordW = heap_strdupAtoW( password );
570 display_nameW = heap_strdupAtoW( display_name );
571
572 r = ChangeServiceConfigW( service, service_type, start_type, error_control, pathW,
573 groupW, tag, dependenciesW, usernameW, passwordW, display_nameW );
574
575 heap_free( pathW );
576 heap_free( groupW );
577 heap_free( dependenciesW );
578 heap_free( usernameW );
579 heap_free( passwordW );
580 heap_free( display_nameW );
581
582 return r;
583 }
584
585 /******************************************************************************
586 * ChangeServiceConfigW (sechost.@)
587 */
588 BOOL WINAPI DECLSPEC_HOTPATCH ChangeServiceConfigW( SC_HANDLE service, DWORD service_type, DWORD start_type,
589 DWORD error_control, const WCHAR *path, const WCHAR *group,
590 DWORD *tag, const WCHAR *dependencies, const WCHAR *username,
591 const WCHAR *password, const WCHAR *display_name )
592 {
593 DWORD password_size;
594 DWORD err;
595
596 TRACE( "%p %ld %ld %ld %s %s %p %p %s %s %s\n", service, service_type, start_type,
597 error_control, debugstr_w(path), debugstr_w(group), tag, dependencies,
598 debugstr_w(username), debugstr_w(password), debugstr_w(display_name) );
599
600 password_size = password ? (wcslen(password) + 1) * sizeof(WCHAR) : 0;
601
602 __TRY
603 {
604 err = svcctl_ChangeServiceConfigW( service, service_type, start_type, error_control, path, group, tag,
605 (const BYTE *)dependencies, multisz_size(dependencies), username,
606 (const BYTE *)password, password_size, display_name );
607 }
608 __EXCEPT(rpc_filter)
609 {
610 err = map_exception_code( GetExceptionCode() );
611 }
612 __ENDTRY
613
614 return set_error( err );
615 }
616
617 /******************************************************************************
618 * QueryServiceConfigA (sechost.@)
619 */
620 BOOL WINAPI DECLSPEC_HOTPATCH QueryServiceConfigA( SC_HANDLE service, QUERY_SERVICE_CONFIGA *config,
621 DWORD size, DWORD *ret_size )
622 {
623 DWORD n;
624 char *p, *buffer;
625 BOOL ret;
626 QUERY_SERVICE_CONFIGW *configW;
627
628 TRACE( "%p %p %ld %p\n", service, config, size, ret_size );
629
630 if (!(buffer = heap_alloc( 2 * size ))) return set_error( ERROR_NOT_ENOUGH_MEMORY );
631 configW = (QUERY_SERVICE_CONFIGW *)buffer;
632 ret = QueryServiceConfigW( service, configW, 2 * size, ret_size );
633 if (!ret) goto done;
634
635 config->dwServiceType = configW->dwServiceType;
636 config->dwStartType = configW->dwStartType;
637 config->dwErrorControl = configW->dwErrorControl;
638 config->lpBinaryPathName = NULL;
639 config->lpLoadOrderGroup = NULL;
640 config->dwTagId = configW->dwTagId;
641 config->lpDependencies = NULL;
642 config->lpServiceStartName = NULL;
643 config->lpDisplayName = NULL;
644
645 p = (char *)(config + 1);
646 n = size - sizeof(*config);
647 ret = FALSE;
648
649 #define MAP_STR(str) \
650 do { \
651 if (configW->str) \
652 { \
653 DWORD sz = WideCharToMultiByte( CP_ACP, 0, configW->str, -1, p, n, NULL, NULL ); \
654 if (!sz) goto done; \
655 config->str = p; \
656 p += sz; \
657 n -= sz; \
658 } \
659 } while (0)
660
661 MAP_STR( lpBinaryPathName );
662 MAP_STR( lpLoadOrderGroup );
663 MAP_STR( lpDependencies );
664 MAP_STR( lpServiceStartName );
665 MAP_STR( lpDisplayName );
666 #undef MAP_STR
667
668 *ret_size = p - (char *)config;
669 ret = TRUE;
670
671 done:
672 heap_free( buffer );
673 return ret;
674 }
675
676 static DWORD move_string_to_buffer(BYTE **buf, WCHAR **string_ptr)
677 {
678 DWORD cb;
679
680 if (!*string_ptr)
681 {
682 cb = sizeof(WCHAR);
683 memset(*buf, 0, cb);
684 }
685 else
686 {
687 cb = (wcslen( *string_ptr ) + 1) * sizeof(WCHAR);
688 memcpy(*buf, *string_ptr, cb);
689 MIDL_user_free( *string_ptr );
690 }
691
692 *string_ptr = (WCHAR *)*buf;
693 *buf += cb;
694
695 return cb;
696 }
697
698 static DWORD size_string( const WCHAR *string )
699 {
700 return (string ? (wcslen( string ) + 1) * sizeof(WCHAR) : sizeof(WCHAR));
701 }
702
703 /******************************************************************************
704 * QueryServiceConfigW (sechost.@)
705 */
706 BOOL WINAPI DECLSPEC_HOTPATCH QueryServiceConfigW( SC_HANDLE service, QUERY_SERVICE_CONFIGW *ret_config,
707 DWORD size, DWORD *ret_size )
708 {
709 QUERY_SERVICE_CONFIGW config;
710 DWORD total;
711 DWORD err;
712 BYTE *bufpos;
713
714 TRACE( "%p %p %ld %p\n", service, ret_config, size, ret_size );
715
716 memset(&config, 0, sizeof(config));
717
718 __TRY
719 {
720 err = svcctl_QueryServiceConfigW( service, &config, size, ret_size );
721 }
722 __EXCEPT(rpc_filter)
723 {
724 err = map_exception_code( GetExceptionCode() );
725 }
726 __ENDTRY
727
728 if (err) return set_error( err );
729
730 /* calculate the size required first */
731 total = sizeof(QUERY_SERVICE_CONFIGW);
732 total += size_string( config.lpBinaryPathName );
733 total += size_string( config.lpLoadOrderGroup );
734 total += size_string( config.lpDependencies );
735 total += size_string( config.lpServiceStartName );
736 total += size_string( config.lpDisplayName );
737
738 *ret_size = total;
739
740 /* if there's not enough memory, return an error */
741 if (size < total)
742 {
743 SetLastError( ERROR_INSUFFICIENT_BUFFER );
744 MIDL_user_free( config.lpBinaryPathName );
745 MIDL_user_free( config.lpLoadOrderGroup );
746 MIDL_user_free( config.lpDependencies );
747 MIDL_user_free( config.lpServiceStartName );
748 MIDL_user_free( config.lpDisplayName );
749 return FALSE;
750 }
751
752 *ret_config = config;
753 bufpos = ((BYTE *)ret_config) + sizeof(QUERY_SERVICE_CONFIGW);
754 move_string_to_buffer( &bufpos, &ret_config->lpBinaryPathName );
755 move_string_to_buffer( &bufpos, &ret_config->lpLoadOrderGroup );
756 move_string_to_buffer( &bufpos, &ret_config->lpDependencies );
757 move_string_to_buffer( &bufpos, &ret_config->lpServiceStartName );
758 move_string_to_buffer( &bufpos, &ret_config->lpDisplayName );
759
760 TRACE( "Image path = %s\n", debugstr_w( ret_config->lpBinaryPathName ) );
761 TRACE( "Group = %s\n", debugstr_w( ret_config->lpLoadOrderGroup ) );
762 TRACE( "Dependencies = %s\n", debugstr_w( ret_config->lpDependencies ) );
763 TRACE( "Service account name = %s\n", debugstr_w( ret_config->lpServiceStartName ) );
764 TRACE( "Display name = %s\n", debugstr_w( ret_config->lpDisplayName ) );
765
766 return TRUE;
767 }
768
769 /******************************************************************************
770 * QueryServiceConfig2A (sechost.@)
771 */
772 BOOL WINAPI DECLSPEC_HOTPATCH QueryServiceConfig2A( SC_HANDLE service, DWORD level, BYTE *buffer,
773 DWORD size, DWORD *ret_size )
774 {
775 BYTE *bufferW = NULL;
776
777 TRACE( "%p %lu %p %lu %p\n", service, level, buffer, size, ret_size );
778
779 if (buffer && size)
780 bufferW = heap_alloc( size );
781
782 if (!QueryServiceConfig2W( service, level, bufferW, size, ret_size ))
783 {
784 heap_free( bufferW );
785 return FALSE;
786 }
787
788 switch (level)
789 {
790 case SERVICE_CONFIG_DESCRIPTION:
791 if (buffer && bufferW) {
792 SERVICE_DESCRIPTIONA *configA = (SERVICE_DESCRIPTIONA *)buffer;
793 SERVICE_DESCRIPTIONW *configW = (SERVICE_DESCRIPTIONW *)bufferW;
794 if (configW->lpDescription && size > sizeof(SERVICE_DESCRIPTIONA))
795 {
796 configA->lpDescription = (char *)(configA + 1);
797 WideCharToMultiByte( CP_ACP, 0, configW->lpDescription, -1, configA->lpDescription,
798 size - sizeof(SERVICE_DESCRIPTIONA), NULL, NULL );
799 }
800 else configA->lpDescription = NULL;
801 }
802 break;
803 case SERVICE_CONFIG_PRESHUTDOWN_INFO:
804 if (buffer && bufferW && *ret_size <= size)
805 memcpy(buffer, bufferW, *ret_size);
806 break;
807 default:
808 FIXME("conversion W->A not implemented for level %ld\n", level);
809 heap_free( bufferW );
810 return FALSE;
811 }
812
813 heap_free( bufferW );
814 return TRUE;
815 }
816
817 /******************************************************************************
818 * QueryServiceConfig2W (sechost.@)
819 */
820 BOOL WINAPI DECLSPEC_HOTPATCH QueryServiceConfig2W( SC_HANDLE service, DWORD level, BYTE *buffer,
821 DWORD size, DWORD *ret_size )
822 {
823 BYTE *bufptr;
824 DWORD err;
825
826 TRACE( "%p %lu %p %lu %p\n", service, level, buffer, size, ret_size );
827
828 if (!buffer && size)
829 {
830 SetLastError(ERROR_INVALID_ADDRESS);
831 return FALSE;
832 }
833
834 switch (level)
835 {
836 case SERVICE_CONFIG_DESCRIPTION:
837 if (!(bufptr = heap_alloc( size )))
838 {
839 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
840 return FALSE;
841 }
842 break;
843
844 case SERVICE_CONFIG_PRESHUTDOWN_INFO:
845 bufptr = buffer;
846 break;
847
848 default:
849 FIXME("Level %ld not implemented\n", level);
850 SetLastError(ERROR_INVALID_LEVEL);
851 return FALSE;
852 }
853
854 if (!ret_size)
855 {
856 if (level == SERVICE_CONFIG_DESCRIPTION) heap_free( bufptr );
857 SetLastError(ERROR_INVALID_ADDRESS);
858 return FALSE;
859 }
860
861 __TRY
862 {
863 err = svcctl_QueryServiceConfig2W( service, level, bufptr, size, ret_size );
864 }
865 __EXCEPT(rpc_filter)
866 {
867 err = map_exception_code( GetExceptionCode() );
868 }
869 __ENDTRY
870
871 switch (level)
872 {
873 case SERVICE_CONFIG_DESCRIPTION:
874 {
875 SERVICE_DESCRIPTIONW *desc = (SERVICE_DESCRIPTIONW *)buffer;
876 struct service_description *s = (struct service_description *)bufptr;
877
878 if (err != ERROR_SUCCESS && err != ERROR_INSUFFICIENT_BUFFER)
879 {
880 heap_free( bufptr );
881 SetLastError( err );
882 return FALSE;
883 }
884
885 /* adjust for potentially larger SERVICE_DESCRIPTIONW structure */
886 if (*ret_size == sizeof(*s))
887 *ret_size = sizeof(*desc);
888 else
889 *ret_size = *ret_size - FIELD_OFFSET(struct service_description, description) + sizeof(*desc);
890
891 if (size < *ret_size)
892 {
893 heap_free( bufptr );
894 SetLastError( ERROR_INSUFFICIENT_BUFFER );
895 return FALSE;
896 }
897 if (desc)
898 {
899 if (!s->size) desc->lpDescription = NULL;
900 else
901 {
902 desc->lpDescription = (WCHAR *)(desc + 1);
903 memcpy( desc->lpDescription, s->description, s->size );
904 }
905 }
906 heap_free( bufptr );
907 break;
908 }
909 case SERVICE_CONFIG_PRESHUTDOWN_INFO:
910 return set_error( err );
911
912 default:
913 break;
914 }
915
916 return TRUE;
917 }
918
919 /******************************************************************************
920 * GetServiceDisplayNameW (sechost.@)
921 */
922 BOOL WINAPI DECLSPEC_HOTPATCH GetServiceDisplayNameW( SC_HANDLE manager, const WCHAR *service,
923 WCHAR *display_name, DWORD *len )
924 {
925 DWORD err;
926 DWORD size;
927 WCHAR buffer[2];
928
929 TRACE( "%p %s %p %p\n", manager, debugstr_w(service), display_name, len );
930
931 if (!manager)
932 {
933 SetLastError( ERROR_INVALID_HANDLE );
934 return FALSE;
935 }
936
937 /* provide a buffer if the caller didn't */
938 if (!display_name || *len < sizeof(WCHAR))
939 {
940 display_name = buffer;
941 /* A size of 1 would be enough, but tests show that Windows returns 2,
942 * probably because of a WCHAR/bytes mismatch in their code. */
943 *len = 2;
944 }
945
946 /* RPC call takes size excluding nul-terminator, whereas *len
947 * includes the nul-terminator on input. */
948 size = *len - 1;
949
950 __TRY
951 {
952 err = svcctl_GetServiceDisplayNameW( manager, service, display_name, &size );
953 }
954 __EXCEPT(rpc_filter)
955 {
956 err = map_exception_code( GetExceptionCode() );
957 }
958 __ENDTRY
959
960 /* The value of *len excludes nul-terminator on output. */
961 if (err == ERROR_SUCCESS || err == ERROR_INSUFFICIENT_BUFFER)
962 *len = size;
963 return set_error( err );
964 }
965
966 /******************************************************************************
967 * GetServiceKeyNameW (sechost.@)
968 */
969 BOOL WINAPI DECLSPEC_HOTPATCH GetServiceKeyNameW( SC_HANDLE manager, const WCHAR *display_name,
970 WCHAR *key_name, DWORD *len )
971 {
972 DWORD err;
973 WCHAR buffer[2];
974 DWORD size;
975
976 TRACE( "%p %s %p %p\n", manager, debugstr_w(display_name), key_name, len );
977
978 if (!manager)
979 {
980 SetLastError( ERROR_INVALID_HANDLE );
981 return FALSE;
982 }
983
984 /* provide a buffer if the caller didn't */
985 if (!key_name || *len < 2)
986 {
987 key_name = buffer;
988 /* A size of 1 would be enough, but tests show that Windows returns 2,
989 * probably because of a WCHAR/bytes mismatch in their code.
990 */
991 *len = 2;
992 }
993
994 /* RPC call takes size excluding nul-terminator, whereas *len
995 * includes the nul-terminator on input. */
996 size = *len - 1;
997
998 __TRY
999 {
1000 err = svcctl_GetServiceKeyNameW( manager, display_name, key_name, &size );
1001 }
1002 __EXCEPT(rpc_filter)
1003 {
1004 err = map_exception_code( GetExceptionCode() );
1005 }
1006 __ENDTRY
1007
1008 /* The value of *lpcchBuffer excludes nul-terminator on output. */
1009 if (err == ERROR_SUCCESS || err == ERROR_INSUFFICIENT_BUFFER)
1010 *len = size;
1011 return set_error( err );
1012 }
1013
1014 /******************************************************************************
1015 * StartServiceA (sechost.@)
1016 */
1017 BOOL WINAPI DECLSPEC_HOTPATCH StartServiceA( SC_HANDLE service, DWORD argc, const char **argv )
1018 {
1019 WCHAR **argvW = NULL;
1020 DWORD i;
1021 BOOL r;
1022
1023 if (argc)
1024 argvW = heap_alloc( argc * sizeof(*argvW) );
1025
1026 for (i = 0; i < argc; i++)
1027 argvW[i] = heap_strdupAtoW( argv[i] );
1028
1029 r = StartServiceW( service, argc, (const WCHAR **)argvW );
1030
1031 for (i = 0; i < argc; i++)
1032 heap_free( argvW[i] );
1033 heap_free( argvW );
1034 return r;
1035 }
1036
1037
1038 /******************************************************************************
1039 * StartServiceW (sechost.@)
1040 */
1041 BOOL WINAPI DECLSPEC_HOTPATCH StartServiceW( SC_HANDLE service, DWORD argc, const WCHAR **argv )
1042 {
1043 DWORD err;
1044
1045 TRACE( "%p %lu %p\n", service, argc, argv );
1046
1047 __TRY
1048 {
1049 err = svcctl_StartServiceW( service, argc, argv );
1050 }
1051 __EXCEPT(rpc_filter)
1052 {
1053 err = map_exception_code( GetExceptionCode() );
1054 }
1055 __ENDTRY
1056
1057 return set_error( err );
1058 }
1059
1060 /******************************************************************************
1061 * ControlService (sechost.@)
1062 */
1063 BOOL WINAPI DECLSPEC_HOTPATCH ControlService( SC_HANDLE service, DWORD control, SERVICE_STATUS *status )
1064 {
1065 DWORD err;
1066
1067 TRACE( "%p %ld %p\n", service, control, status );
1068
1069 __TRY
1070 {
1071 err = svcctl_ControlService( service, control, status );
1072 }
1073 __EXCEPT(rpc_filter)
1074 {
1075 err = map_exception_code( GetExceptionCode() );
1076 }
1077 __ENDTRY
1078
1079 return set_error( err );
1080 }
1081
1082 /******************************************************************************
1083 * QueryServiceStatus (sechost.@)
1084 */
1085 BOOL WINAPI DECLSPEC_HOTPATCH QueryServiceStatus( SC_HANDLE service, SERVICE_STATUS *status )
1086 {
1087 SERVICE_STATUS_PROCESS process_status;
1088 BOOL ret;
1089 DWORD size;
1090
1091 TRACE( "%p %p\n", service, status );
1092
1093 if (!service) return set_error( ERROR_INVALID_HANDLE );
1094 if (!status) return set_error( ERROR_INVALID_ADDRESS );
1095
1096 ret = QueryServiceStatusEx( service, SC_STATUS_PROCESS_INFO, (BYTE *)&process_status,
1097 sizeof(SERVICE_STATUS_PROCESS), &size );
1098 if (ret) memcpy(status, &process_status, sizeof(SERVICE_STATUS) );
1099 return ret;
1100 }
1101
1102 /******************************************************************************
1103 * QueryServiceStatusEx (sechost.@)
1104 */
1105 BOOL WINAPI DECLSPEC_HOTPATCH QueryServiceStatusEx( SC_HANDLE service, SC_STATUS_TYPE level,
1106 BYTE *buffer, DWORD size, DWORD *ret_size )
1107 {
1108 DWORD err;
1109
1110 TRACE( "%p %d %p %ld %p\n", service, level, buffer, size, ret_size );
1111
1112 if (level != SC_STATUS_PROCESS_INFO) return set_error( ERROR_INVALID_LEVEL );
1113
1114 if (size < sizeof(SERVICE_STATUS_PROCESS))
1115 {
1116 *ret_size = sizeof(SERVICE_STATUS_PROCESS);
1117 return set_error( ERROR_INSUFFICIENT_BUFFER );
1118 }
1119
1120 __TRY
1121 {
1122 err = svcctl_QueryServiceStatusEx( service, level, buffer, size, ret_size );
1123 }
1124 __EXCEPT(rpc_filter)
1125 {
1126 err = map_exception_code( GetExceptionCode() );
1127 }
1128 __ENDTRY
1129
1130 return set_error( err );
1131 }
1132
1133 /******************************************************************************
1134 * EnumServicesStatusExW (sechost.@)
1135 */
1136 BOOL WINAPI DECLSPEC_HOTPATCH EnumServicesStatusExW( SC_HANDLE manager, SC_ENUM_TYPE level, DWORD type, DWORD state,
1137 BYTE *buffer, DWORD size, DWORD *needed, DWORD *returned,
1138 DWORD *resume_handle, const WCHAR *group )
1139 {
1140 DWORD err, i, offset, buflen, count, total_size = 0;
1141 ENUM_SERVICE_STATUS_PROCESSW *services = (ENUM_SERVICE_STATUS_PROCESSW *)buffer;
1142 struct enum_service_status_process *entry;
1143 const WCHAR *str;
1144 BYTE *buf;
1145
1146 TRACE( "%p %u 0x%lx 0x%lx %p %lu %p %p %p %s\n", manager, level, type, state, buffer,
1147 size, needed, returned, resume_handle, debugstr_w(group) );
1148
1149 if (level != SC_ENUM_PROCESS_INFO) return set_error( ERROR_INVALID_LEVEL );
1150 if (!manager) return set_error( ERROR_INVALID_HANDLE );
1151 if (!needed || !returned) return set_error( ERROR_INVALID_ADDRESS );
1152
1153 /* make sure we pass a valid pointer */
1154 buflen = max( size, sizeof(*services) );
1155 if (!(buf = heap_alloc( buflen ))) return set_error( ERROR_NOT_ENOUGH_MEMORY );
1156
1157 __TRY
1158 {
1159 err = svcctl_EnumServicesStatusExW( manager, SC_ENUM_PROCESS_INFO, type, state, buf, buflen, needed,
1160 &count, resume_handle, group );
1161 }
1162 __EXCEPT(rpc_filter)
1163 {
1164 err = map_exception_code( GetExceptionCode() );
1165 }
1166 __ENDTRY
1167
1168 *returned = 0;
1169 if (err != ERROR_SUCCESS)
1170 {
1171 /* double the needed size to fit the potentially larger ENUM_SERVICE_STATUS_PROCESSW */
1172 if (err == ERROR_MORE_DATA) *needed *= 2;
1173 heap_free( buf );
1174 SetLastError( err );
1175 return FALSE;
1176 }
1177
1178 entry = (struct enum_service_status_process *)buf;
1179 for (i = 0; i < count; i++)
1180 {
1181 total_size += sizeof(*services);
1182 if (entry->service_name)
1183 {
1184 str = (const WCHAR *)(buf + entry->service_name);
1185 total_size += (wcslen( str ) + 1) * sizeof(WCHAR);
1186 }
1187 if (entry->display_name)
1188 {
1189 str = (const WCHAR *)(buf + entry->display_name);
1190 total_size += (wcslen( str ) + 1) * sizeof(WCHAR);
1191 }
1192 entry++;
1193 }
1194
1195 if (total_size > size)
1196 {
1197 heap_free( buf );
1198 *needed = total_size;
1199 SetLastError( ERROR_MORE_DATA );
1200 return FALSE;
1201 }
1202
1203 offset = count * sizeof(*services);
1204 entry = (struct enum_service_status_process *)buf;
1205 for (i = 0; i < count; i++)
1206 {
1207 DWORD str_size;
1208 str = (const WCHAR *)(buf + entry->service_name);
1209 str_size = (wcslen( str ) + 1) * sizeof(WCHAR);
1210 services[i].lpServiceName = (WCHAR *)((char *)services + offset);
1211 memcpy( services[i].lpServiceName, str, str_size );
1212 offset += str_size;
1213
1214 if (!entry->display_name) services[i].lpDisplayName = NULL;
1215 else
1216 {
1217 str = (const WCHAR *)(buf + entry->display_name);
1218 str_size = (wcslen( str ) + 1) * sizeof(WCHAR);
1219 services[i].lpDisplayName = (WCHAR *)((char *)services + offset);
1220 memcpy( services[i].lpDisplayName, str, str_size );
1221 offset += str_size;
1222 }
1223 services[i].ServiceStatusProcess = entry->service_status_process;
1224 entry++;
1225 }
1226
1227 heap_free( buf );
1228 *needed = 0;
1229 *returned = count;
1230 return TRUE;
1231 }
1232
1233 /******************************************************************************
1234 * EnumDependentServicesW (sechost.@)
1235 */
1236 BOOL WINAPI EnumDependentServicesW( SC_HANDLE hService, DWORD dwServiceState,
1237 LPENUM_SERVICE_STATUSW lpServices, DWORD cbBufSize,
1238 LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned )
1239 {
1240 FIXME("%p 0x%08lx %p 0x%08lx %p %p - stub\n", hService, dwServiceState,
1241 lpServices, cbBufSize, pcbBytesNeeded, lpServicesReturned);
1242
1243 *lpServicesReturned = 0;
1244 return TRUE;
1245 }
1246
1247 /******************************************************************************
1248 * QueryServiceObjectSecurity (sechost.@)
1249 */
1250 BOOL WINAPI DECLSPEC_HOTPATCH QueryServiceObjectSecurity( SC_HANDLE service, SECURITY_INFORMATION type,
1251 PSECURITY_DESCRIPTOR ret_descriptor, DWORD size, DWORD *ret_size )
1252 {
1253 SECURITY_DESCRIPTOR descriptor;
1254 NTSTATUS status;
1255 ACL acl;
1256
1257 FIXME( "%p %ld %p %lu %p - semi-stub\n", service, type, ret_descriptor, size, ret_size );
1258
1259 if (type != DACL_SECURITY_INFORMATION)
1260 FIXME("information %ld not supported\n", type);
1261
1262 InitializeSecurityDescriptor( &descriptor, SECURITY_DESCRIPTOR_REVISION );
1263
1264 InitializeAcl( &acl, sizeof(ACL), ACL_REVISION );
1265 SetSecurityDescriptorDacl( &descriptor, TRUE, &acl, TRUE );
1266
1267 status = RtlMakeSelfRelativeSD( &descriptor, ret_descriptor, &size );
1268 *ret_size = size;
1269
1270 return set_error( RtlNtStatusToDosError( status ) );
1271 }
1272
1273 /******************************************************************************
1274 * SetServiceObjectSecurity (sechost.@)
1275 */
1276 BOOL WINAPI SetServiceObjectSecurity(SC_HANDLE hService,
1277 SECURITY_INFORMATION dwSecurityInformation,
1278 PSECURITY_DESCRIPTOR lpSecurityDescriptor)
1279 {
1280 FIXME("%p %ld %p\n", hService, dwSecurityInformation, lpSecurityDescriptor);
1281 return TRUE;
1282 }
1283
1284 static DWORD WINAPI notify_thread(void *user)
1285 {
1286 DWORD err;
1287 struct notify_data *data = user;
1288 SC_RPC_NOTIFY_PARAMS_LIST *list = NULL;
1289 SERVICE_NOTIFY_STATUS_CHANGE_PARAMS_2 *cparams;
1290 BOOL dummy;
1291
1292 SetThreadDescription(GetCurrentThread(), L"wine_sechost_notify_service_status");
1293
1294 __TRY
1295 {
1296 /* GetNotifyResults blocks until there is an event */
1297 err = svcctl_GetNotifyResults(data->notify_handle, &list);
1298 }
1299 __EXCEPT(rpc_filter)
1300 {
1301 err = map_exception_code(GetExceptionCode());
1302 }
1303 __ENDTRY
1304
1305 EnterCriticalSection( &service_cs );
1306
1307 list_remove(&data->entry);
1308
1309 LeaveCriticalSection( &service_cs );
1310
1311 if (err == ERROR_SUCCESS && list)
1312 {
1313 cparams = list->NotifyParamsArray[0].params;
1314
1315 data->notify_buffer->dwNotificationStatus = cparams->dwNotificationStatus;
1316 memcpy(&data->notify_buffer->ServiceStatus, &cparams->ServiceStatus,
1317 sizeof(SERVICE_STATUS_PROCESS));
1318 data->notify_buffer->dwNotificationTriggered = cparams->dwNotificationTriggered;
1319 data->notify_buffer->pszServiceNames = NULL;
1320
1321 QueueUserAPC((PAPCFUNC)data->notify_buffer->pfnNotifyCallback,
1322 data->calling_thread, (ULONG_PTR)data->notify_buffer);
1323
1324 HeapFree(GetProcessHeap(), 0, list);
1325 }
1326 else
1327 WARN("GetNotifyResults server call failed: %lu\n", err);
1328
1329
1330 __TRY
1331 {
1332 err = svcctl_CloseNotifyHandle(&data->notify_handle, &dummy);
1333 }
1334 __EXCEPT(rpc_filter)
1335 {
1336 err = map_exception_code(GetExceptionCode());
1337 }
1338 __ENDTRY
1339
1340 if (err != ERROR_SUCCESS)
1341 WARN("CloseNotifyHandle server call failed: %lu\n", err);
1342
1343 CloseHandle(data->calling_thread);
1344 HeapFree(GetProcessHeap(), 0, data);
1345
1346 return 0;
1347 }
1348
1349 /******************************************************************************
1350 * NotifyServiceStatusChangeW (sechost.@)
1351 */
1352 DWORD WINAPI DECLSPEC_HOTPATCH NotifyServiceStatusChangeW( SC_HANDLE service, DWORD mask,
1353 SERVICE_NOTIFYW *notify_buffer )
1354 {
1355 DWORD err;
1356 BOOL b_dummy = FALSE;
1357 GUID g_dummy = {0};
1358 struct notify_data *data;
1359
1360 TRACE( "%p 0x%lx %p\n", service, mask, notify_buffer );
1361
1362 if (!(data = heap_alloc_zero( sizeof(*data) )))
1363 return ERROR_NOT_ENOUGH_MEMORY;
1364
1365 data->service = service;
1366 data->notify_buffer = notify_buffer;
1367 if (!DuplicateHandle( GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(),
1368 &data->calling_thread, 0, FALSE, DUPLICATE_SAME_ACCESS ))
1369 {
1370 ERR("DuplicateHandle failed: %lu\n", GetLastError());
1371 heap_free( data );
1372 return ERROR_NOT_ENOUGH_MEMORY;
1373 }
1374
1375 data->params.dwInfoLevel = 2;
1376 data->params.params = &data->cparams;
1377
1378 data->cparams.dwNotifyMask = mask;
1379
1380 EnterCriticalSection( &service_cs );
1381
1382 __TRY
1383 {
1384 err = svcctl_NotifyServiceStatusChange( service, data->params, &g_dummy,
1385 &g_dummy, &b_dummy, &data->notify_handle );
1386 }
1387 __EXCEPT(rpc_filter)
1388 {
1389 err = map_exception_code( GetExceptionCode() );
1390 }
1391 __ENDTRY
1392
1393 if (err != ERROR_SUCCESS)
1394 {
1395 WARN("NotifyServiceStatusChange server call failed: %lu\n", err);
1396 LeaveCriticalSection( &service_cs );
1397 CloseHandle( data->calling_thread );
1398 CloseHandle( data->ready_evt );
1399 heap_free( data );
1400 return err;
1401 }
1402
1403 CloseHandle( CreateThread( NULL, 0, &notify_thread, data, 0, NULL ) );
1404
1405 list_add_tail( &notify_list, &data->entry );
1406
1407 LeaveCriticalSection( &service_cs );
1408
1409 return ERROR_SUCCESS;
1410 }
1411
1412 /* thunk for calling the RegisterServiceCtrlHandler handler function */
1413 static DWORD WINAPI ctrl_handler_thunk( DWORD control, DWORD type, void *data, void *context )
1414 {
1415 LPHANDLER_FUNCTION func = context;
1416
1417 func( control );
1418 return ERROR_SUCCESS;
1419 }
1420
1421 /******************************************************************************
1422 * RegisterServiceCtrlHandlerA (sechost.@)
1423 */
1424 SERVICE_STATUS_HANDLE WINAPI DECLSPEC_HOTPATCH RegisterServiceCtrlHandlerA(
1425 const char *name, LPHANDLER_FUNCTION handler )
1426 {
1427 return RegisterServiceCtrlHandlerExA( name, ctrl_handler_thunk, handler );
1428 }
1429
1430 /******************************************************************************
1431 * RegisterServiceCtrlHandlerW (sechost.@)
1432 */
1433 SERVICE_STATUS_HANDLE WINAPI DECLSPEC_HOTPATCH RegisterServiceCtrlHandlerW(
1434 const WCHAR *name, LPHANDLER_FUNCTION handler )
1435 {
1436 return RegisterServiceCtrlHandlerExW( name, ctrl_handler_thunk, handler );
1437 }
1438
1439 /******************************************************************************
1440 * RegisterServiceCtrlHandlerExA (sechost.@)
1441 */
1442 SERVICE_STATUS_HANDLE WINAPI DECLSPEC_HOTPATCH RegisterServiceCtrlHandlerExA(
1443 const char *name, LPHANDLER_FUNCTION_EX handler, void *context )
1444 {
1445 WCHAR *nameW;
1446 SERVICE_STATUS_HANDLE ret;
1447
1448 nameW = heap_strdupAtoW( name );
1449 ret = RegisterServiceCtrlHandlerExW( nameW, handler, context );
1450 heap_free( nameW );
1451 return ret;
1452 }
1453
1454 static struct service_data *find_service_by_name( const WCHAR *name )
1455 {
1456 unsigned int i;
1457
1458 if (nb_services == 1) /* only one service (FIXME: should depend on OWN_PROCESS etc.) */
1459 return services[0];
1460 for (i = 0; i < nb_services; i++)
1461 if (!wcsicmp( name, services[i]->name )) return services[i];
1462 return NULL;
1463 }
1464
1465 /******************************************************************************
1466 * RegisterServiceCtrlHandlerExW (sechost.@)
1467 */
1468 SERVICE_STATUS_HANDLE WINAPI DECLSPEC_HOTPATCH RegisterServiceCtrlHandlerExW(
1469 const WCHAR *name, LPHANDLER_FUNCTION_EX handler, void *context )
1470 {
1471 struct service_data *service;
1472 SC_HANDLE handle = 0;
1473
1474 TRACE( "%s %p %p\n", debugstr_w(name), handler, context );
1475
1476 EnterCriticalSection( &service_cs );
1477 if ((service = find_service_by_name( name )))
1478 {
1479 service->handler = handler;
1480 service->context = context;
1481 handle = service->handle;
1482 }
1483 LeaveCriticalSection( &service_cs );
1484
1485 if (!handle) SetLastError( ERROR_SERVICE_DOES_NOT_EXIST );
1486 return (SERVICE_STATUS_HANDLE)handle;
1487 }
1488
1489 /******************************************************************************
1490 * SetServiceStatus (sechost.@)
1491 */
1492 BOOL WINAPI DECLSPEC_HOTPATCH SetServiceStatus( SERVICE_STATUS_HANDLE service, SERVICE_STATUS *status )
1493 {
1494 DWORD err;
1495
1496 TRACE( "%p %#lx %#lx %#lx %#lx %#lx %#lx %#lx\n", service, status->dwServiceType,
1497 status->dwCurrentState, status->dwControlsAccepted, status->dwWin32ExitCode,
1498 status->dwServiceSpecificExitCode, status->dwCheckPoint, status->dwWaitHint );
1499
1500 __TRY
1501 {
1502 err = svcctl_SetServiceStatus( service, status );
1503 }
1504 __EXCEPT(rpc_filter)
1505 {
1506 err = map_exception_code( GetExceptionCode() );
1507 }
1508 __ENDTRY
1509
1510 if (!set_error( err ))
1511 return FALSE;
1512
1513 if (status->dwCurrentState == SERVICE_STOPPED)
1514 {
1515 unsigned int i, count = 0;
1516 EnterCriticalSection( &service_cs );
1517 for (i = 0; i < nb_services; i++)
1518 {
1519 if (services[i]->handle == (SC_HANDLE)service) continue;
1520 if (services[i]->thread) count++;
1521 }
1522 if (!count)
1523 {
1524 stop_service = TRUE;
1525 SetEvent( service_event ); /* notify the main loop */
1526 }
1527 LeaveCriticalSection( &service_cs );
1528 }
1529
1530 return TRUE;
1531 }
1532
1533 static WCHAR *service_get_pipe_name(void)
1534 {
1535 static const WCHAR format[] = L"\\\\.\\pipe\\net\\NtControlPipe%u";
1536 WCHAR *name;
1537 DWORD len;
1538 HKEY service_current_key;
1539 DWORD service_current;
1540 LONG ret;
1541 DWORD type;
1542
1543 ret = RegOpenKeyExW( HKEY_LOCAL_MACHINE,
1544 L"SYSTEM\\CurrentControlSet\\Control\\ServiceCurrent",
1545 0, KEY_QUERY_VALUE, &service_current_key );
1546 if (ret != ERROR_SUCCESS)
1547 return NULL;
1548
1549 len = sizeof(service_current);
1550 ret = RegQueryValueExW( service_current_key, NULL, NULL, &type,
1551 (BYTE *)&service_current, &len );
1552 RegCloseKey(service_current_key);
1553 if (ret != ERROR_SUCCESS || type != REG_DWORD)
1554 return NULL;
1555
1556 len = ARRAY_SIZE(format) + 10 /* strlenW("4294967295") */;
1557 name = heap_alloc(len * sizeof(WCHAR));
1558 if (!name)
1559 return NULL;
1560
1561 swprintf( name, len, format, service_current );
1562 return name;
1563 }
1564
1565 static HANDLE service_open_pipe(void)
1566 {
1567 WCHAR *pipe_name = service_get_pipe_name();
1568 HANDLE handle = INVALID_HANDLE_VALUE;
1569
1570 do
1571 {
1572 handle = CreateFileW( pipe_name, GENERIC_READ|GENERIC_WRITE,
1573 0, NULL, OPEN_ALWAYS, 0, NULL );
1574 if (handle != INVALID_HANDLE_VALUE)
1575 break;
1576 if (GetLastError() != ERROR_PIPE_BUSY)
1577 break;
1578 } while (WaitNamedPipeW( pipe_name, NMPWAIT_USE_DEFAULT_WAIT ));
1579 heap_free(pipe_name);
1580
1581 return handle;
1582 }
1583
1584 static DWORD WINAPI service_thread( void *arg )
1585 {
1586 struct service_data *info = arg;
1587 WCHAR *str = info->args;
1588 DWORD argc = 0, len = 0;
1589
1590 TRACE("%p\n", arg);
1591 SetThreadDescription(GetCurrentThread(), L"wine_sechost_service");
1592
1593 while (str[len])
1594 {
1595 len += wcslen( &str[len] ) + 1;
1596 argc++;
1597 }
1598 len++;
1599
1600 if (info->unicode)
1601 {
1602 WCHAR **argv, *p;
1603
1604 argv = heap_alloc( (argc+1)*sizeof(*argv) );
1605 for (argc = 0, p = str; *p; p += wcslen( p ) + 1)
1606 argv[argc++] = p;
1607 argv[argc] = NULL;
1608
1609 info->proc.w( argc, argv );
1610 heap_free( argv );
1611 }
1612 else
1613 {
1614 char *strA, **argv, *p;
1615 DWORD lenA;
1616
1617 lenA = WideCharToMultiByte( CP_ACP,0, str, len, NULL, 0, NULL, NULL );
1618 strA = heap_alloc(lenA);
1619 WideCharToMultiByte(CP_ACP,0, str, len, strA, lenA, NULL, NULL);
1620
1621 argv = heap_alloc( (argc+1)*sizeof(*argv) );
1622 for (argc = 0, p = strA; *p; p += strlen( p ) + 1)
1623 argv[argc++] = p;
1624 argv[argc] = NULL;
1625
1626 info->proc.a( argc, argv );
1627 heap_free( argv );
1628 heap_free( strA );
1629 }
1630 return 0;
1631 }
1632
1633 static DWORD service_handle_start( struct service_data *service, const void *data, DWORD data_size )
1634 {
1635 DWORD count = data_size / sizeof(WCHAR);
1636
1637 if (service->thread)
1638 {
1639 WARN("service is not stopped\n");
1640 return ERROR_SERVICE_ALREADY_RUNNING;
1641 }
1642
1643 heap_free( service->args );
1644 service->args = heap_alloc( (count + 2) * sizeof(WCHAR) );
1645 if (count) memcpy( service->args, data, count * sizeof(WCHAR) );
1646 service->args[count++] = 0;
1647 service->args[count++] = 0;
1648
1649 service->thread = CreateThread( NULL, 0, service_thread,
1650 service, 0, NULL );
1651 SetEvent( service_event ); /* notify the main loop */
1652 return 0;
1653 }
1654
1655 static DWORD service_handle_control( struct service_data *service, DWORD control, const void *data, DWORD data_size )
1656 {
1657 DWORD ret = ERROR_INVALID_SERVICE_CONTROL;
1658
1659 TRACE( "%s control %lu data %p data_size %lu\n", debugstr_w(service->name), control, data, data_size );
1660
1661 if (control == SERVICE_CONTROL_START)
1662 ret = service_handle_start( service, data, data_size );
1663 else if (service->handler)
1664 ret = service->handler( control, 0, (void *)data, service->context );
1665 return ret;
1666 }
1667
1668 static DWORD WINAPI service_control_dispatcher( void *arg )
1669 {
1670 struct dispatcher_data *disp = arg;
1671
1672 /* dispatcher loop */
1673 while (1)
1674 {
1675 struct service_data *service;
1676 service_start_info info;
1677 BYTE *data = NULL;
1678 WCHAR *name;
1679 BOOL r;
1680 DWORD data_size = 0, count, result;
1681
1682 r = ReadFile( disp->pipe, &info, FIELD_OFFSET(service_start_info,data), &count, NULL );
1683 if (!r)
1684 {
1685 if (GetLastError() != ERROR_BROKEN_PIPE)
1686 ERR( "pipe read failed error %lu\n", GetLastError() );
1687 break;
1688 }
1689 if (count != FIELD_OFFSET(service_start_info,data))
1690 {
1691 ERR( "partial pipe read %lu\n", count );
1692 break;
1693 }
1694 if (count < info.total_size)
1695 {
1696 data_size = info.total_size - FIELD_OFFSET(service_start_info,data);
1697 data = heap_alloc( data_size );
1698 r = ReadFile( disp->pipe, data, data_size, &count, NULL );
1699 if (!r)
1700 {
1701 if (GetLastError() != ERROR_BROKEN_PIPE)
1702 ERR( "pipe read failed error %lu\n", GetLastError() );
1703 heap_free( data );
1704 break;
1705 }
1706 if (count != data_size)
1707 {
1708 ERR( "partial pipe read %lu/%lu\n", count, data_size );
1709 heap_free( data );
1710 break;
1711 }
1712 }
1713
1714 EnterCriticalSection( &service_cs );
1715
1716 /* validate service name */
1717 name = (WCHAR *)data;
1718 if (!info.name_size || data_size < info.name_size * sizeof(WCHAR) || name[info.name_size - 1])
1719 {
1720 ERR( "got request without valid service name\n" );
1721 result = ERROR_INVALID_PARAMETER;
1722 goto done;
1723 }
1724
1725 if (info.magic != SERVICE_PROTOCOL_MAGIC)
1726 {
1727 ERR( "received invalid request for service %s\n", debugstr_w(name) );
1728 result = ERROR_INVALID_PARAMETER;
1729 goto done;
1730 }
1731
1732 /* find the service */
1733 if (!(service = find_service_by_name( name )))
1734 {
1735 FIXME( "got request for unknown service %s\n", debugstr_w(name) );
1736 result = ERROR_INVALID_PARAMETER;
1737 goto done;
1738 }
1739
1740 if (!service->handle)
1741 {
1742 if (!(service->handle = OpenServiceW( disp->manager, name, SERVICE_SET_STATUS )) ||
1743 !(service->full_access_handle = OpenServiceW( disp->manager, name,
1744 GENERIC_READ|GENERIC_WRITE )))
1745 FIXME( "failed to open service %s\n", debugstr_w(name) );
1746 }
1747
1748 data_size -= info.name_size * sizeof(WCHAR);
1749 result = service_handle_control(service, info.control, data_size ?
1750 &data[info.name_size * sizeof(WCHAR)] : NULL, data_size);
1751
1752 done:
1753 LeaveCriticalSection( &service_cs );
1754 WriteFile( disp->pipe, &result, sizeof(result), &count, NULL );
1755 heap_free( data );
1756 }
1757
1758 CloseHandle( disp->pipe );
1759 CloseServiceHandle( disp->manager );
1760 heap_free( disp );
1761 return 1;
1762 }
1763
1764 /* wait for services which accept this type of message to become STOPPED */
1765 static void handle_shutdown_msg(DWORD msg, DWORD accept)
1766 {
1767 SERVICE_STATUS st;
1768 SERVICE_PRESHUTDOWN_INFO spi;
1769 DWORD i, n = 0, sz, timeout = 2000;
1770 ULONGLONG stop_time;
1771 BOOL res, done = TRUE;
1772 SC_HANDLE *wait_handles = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SC_HANDLE) * nb_services );
1773
1774 EnterCriticalSection( &service_cs );
1775 for (i = 0; i < nb_services; i++)
1776 {
1777 res = QueryServiceStatus( services[i]->full_access_handle, &st );
1778 if (!res || st.dwCurrentState == SERVICE_STOPPED || !(st.dwControlsAccepted & accept))
1779 continue;
1780
1781 done = FALSE;
1782
1783 if (accept == SERVICE_ACCEPT_PRESHUTDOWN)
1784 {
1785 res = QueryServiceConfig2W( services[i]->full_access_handle, SERVICE_CONFIG_PRESHUTDOWN_INFO,
1786 (BYTE *)&spi, sizeof(spi), &sz );
1787 if (res)
1788 {
1789 FIXME( "service should be able to delay shutdown\n" );
1790 timeout = max( spi.dwPreshutdownTimeout, timeout );
1791 }
1792 }
1793
1794 service_handle_control( services[i], msg, NULL, 0 );
1795 wait_handles[n++] = services[i]->full_access_handle;
1796 }
1797 LeaveCriticalSection( &service_cs );
1798
1799 /* FIXME: these timeouts should be more generous, but we can't currently delay prefix shutdown */
1800 timeout = min( timeout, 3000 );
1801 stop_time = GetTickCount64() + timeout;
1802
1803 while (!done && GetTickCount64() < stop_time)
1804 {
1805 done = TRUE;
1806 for (i = 0; i < n; i++)
1807 {
1808 res = QueryServiceStatus( wait_handles[i], &st );
1809 if (!res || st.dwCurrentState == SERVICE_STOPPED)
1810 continue;
1811
1812 done = FALSE;
1813 Sleep( 100 );
1814 break;
1815 }
1816 }
1817
1818 HeapFree( GetProcessHeap(), 0, wait_handles );
1819 }
1820
1821 static BOOL service_run_main_thread(void)
1822 {
1823 DWORD i, n, ret;
1824 HANDLE wait_handles[MAXIMUM_WAIT_OBJECTS];
1825 UINT wait_services[MAXIMUM_WAIT_OBJECTS];
1826 struct dispatcher_data *disp = heap_alloc( sizeof(*disp) );
1827
1828 disp->manager = OpenSCManagerW( NULL, NULL, SC_MANAGER_CONNECT );
1829 if (!disp->manager)
1830 {
1831 ERR("failed to open service manager error %lu\n", GetLastError());
1832 heap_free( disp );
1833 return FALSE;
1834 }
1835
1836 disp->pipe = service_open_pipe();
1837 if (disp->pipe == INVALID_HANDLE_VALUE)
1838 {
1839 WARN("failed to create control pipe error %lu\n", GetLastError());
1840 CloseServiceHandle( disp->manager );
1841 heap_free( disp );
1842 SetLastError( ERROR_FAILED_SERVICE_CONTROLLER_CONNECT );
1843 return FALSE;
1844 }
1845
1846 service_event = CreateEventW( NULL, FALSE, FALSE, NULL );
1847 stop_service = FALSE;
1848
1849 /* FIXME: service_control_dispatcher should be merged into the main thread */
1850 NtSetInformationProcess( GetCurrentProcess(), ProcessWineMakeProcessSystem,
1851 &wait_handles[0], sizeof(HANDLE *) );
1852 wait_handles[1] = CreateThread( NULL, 0, service_control_dispatcher, disp, 0, NULL );
1853 wait_handles[2] = service_event;
1854
1855 TRACE("Starting %d services running as process %ld\n",
1856 nb_services, GetCurrentProcessId());
1857
1858 /* wait for all the threads to pack up and exit */
1859 while (!stop_service)
1860 {
1861 EnterCriticalSection( &service_cs );
1862 for (i = 0, n = 3; i < nb_services && n < MAXIMUM_WAIT_OBJECTS; i++)
1863 {
1864 if (!services[i]->thread) continue;
1865 wait_services[n] = i;
1866 wait_handles[n++] = services[i]->thread;
1867 }
1868 LeaveCriticalSection( &service_cs );
1869
1870 ret = WaitForMultipleObjects( n, wait_handles, FALSE, INFINITE );
1871 if (!ret) /* system process event */
1872 {
1873 handle_shutdown_msg(SERVICE_CONTROL_PRESHUTDOWN, SERVICE_ACCEPT_PRESHUTDOWN);
1874 handle_shutdown_msg(SERVICE_CONTROL_SHUTDOWN, SERVICE_ACCEPT_SHUTDOWN);
1875 ExitProcess(0);
1876 }
1877 else if (ret == 1)
1878 {
1879 TRACE( "control dispatcher exited, shutting down\n" );
1880 /* FIXME: we should maybe send a shutdown control to running services */
1881 ExitProcess(0);
1882 }
1883 else if (ret == 2)
1884 {
1885 continue; /* rebuild the list */
1886 }
1887 else if (ret < n)
1888 {
1889 i = wait_services[ret];
1890 EnterCriticalSection( &service_cs );
1891 CloseHandle( services[i]->thread );
1892 services[i]->thread = NULL;
1893 LeaveCriticalSection( &service_cs );
1894 }
1895 else return FALSE;
1896 }
1897
1898 return TRUE;
1899 }
1900
1901 /******************************************************************************
1902 * StartServiceCtrlDispatcherA (sechost.@)
1903 */
1904 BOOL WINAPI DECLSPEC_HOTPATCH StartServiceCtrlDispatcherA( const SERVICE_TABLE_ENTRYA *servent )
1905 {
1906 struct service_data *info;
1907 unsigned int i;
1908
1909 TRACE("%p\n", servent);
1910
1911 if (nb_services)
1912 {
1913 SetLastError( ERROR_SERVICE_ALREADY_RUNNING );
1914 return FALSE;
1915 }
1916 while (servent[nb_services].lpServiceName) nb_services++;
1917 if (!nb_services)
1918 {
1919 SetLastError( ERROR_INVALID_PARAMETER );
1920 return FALSE;
1921 }
1922
1923 services = heap_alloc( nb_services * sizeof(*services) );
1924
1925 for (i = 0; i < nb_services; i++)
1926 {
1927 DWORD len = MultiByteToWideChar( CP_ACP, 0, servent[i].lpServiceName, -1, NULL, 0 );
1928 DWORD sz = FIELD_OFFSET( struct service_data, name[len] );
1929 info = heap_alloc_zero( sz );
1930 MultiByteToWideChar( CP_ACP, 0, servent[i].lpServiceName, -1, info->name, len );
1931 info->proc.a = servent[i].lpServiceProc;
1932 info->unicode = FALSE;
1933 services[i] = info;
1934 }
1935
1936 return service_run_main_thread();
1937 }
1938
1939 /******************************************************************************
1940 * StartServiceCtrlDispatcherW (sechost.@)
1941 */
1942 BOOL WINAPI DECLSPEC_HOTPATCH StartServiceCtrlDispatcherW( const SERVICE_TABLE_ENTRYW *servent )
1943 {
1944 struct service_data *info;
1945 unsigned int i;
1946
1947 TRACE("%p\n", servent);
1948
1949 if (nb_services)
1950 {
1951 SetLastError( ERROR_SERVICE_ALREADY_RUNNING );
1952 return FALSE;
1953 }
1954 while (servent[nb_services].lpServiceName) nb_services++;
1955 if (!nb_services)
1956 {
1957 SetLastError( ERROR_INVALID_PARAMETER );
1958 return FALSE;
1959 }
1960
1961 services = heap_alloc( nb_services * sizeof(*services) );
1962
1963 for (i = 0; i < nb_services; i++)
1964 {
1965 DWORD len = wcslen( servent[i].lpServiceName ) + 1;
1966 DWORD sz = FIELD_OFFSET( struct service_data, name[len] );
1967 info = heap_alloc_zero( sz );
1968 wcscpy( info->name, servent[i].lpServiceName );
1969 info->proc.w = servent[i].lpServiceProc;
1970 info->unicode = TRUE;
1971 services[i] = info;
1972 }
1973
1974 return service_run_main_thread();
1975 }
1976
1977 struct device_notification_details
1978 {
1979 DWORD (CALLBACK *cb)(HANDLE handle, DWORD flags, DEV_BROADCAST_HDR *header);
1980 HANDLE handle;
1981 union
1982 {
1983 DEV_BROADCAST_HDR header;
1984 DEV_BROADCAST_DEVICEINTERFACE_W iface;
1985 } filter;
1986 };
1987
1988 static HANDLE device_notify_thread;
1989 static struct list device_notify_list = LIST_INIT(device_notify_list);
1990
1991 struct device_notify_registration
1992 {
1993 struct list entry;
1994 struct device_notification_details details;
1995 };
1996
1997 static BOOL notification_filter_matches( DEV_BROADCAST_HDR *filter, DEV_BROADCAST_HDR *event )
1998 {
1999 if (!filter->dbch_devicetype) return TRUE;
2000 if (filter->dbch_devicetype != event->dbch_devicetype) return FALSE;
2001
2002 if (filter->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE)
2003 {
2004 DEV_BROADCAST_DEVICEINTERFACE_W *filter_iface = (DEV_BROADCAST_DEVICEINTERFACE_W *)filter;
2005 DEV_BROADCAST_DEVICEINTERFACE_W *event_iface = (DEV_BROADCAST_DEVICEINTERFACE_W *)event;
2006 if (filter_iface->dbcc_size == offsetof(DEV_BROADCAST_DEVICEINTERFACE_W, dbcc_classguid)) return TRUE;
2007 return IsEqualGUID( &filter_iface->dbcc_classguid, &event_iface->dbcc_classguid );
2008 }
2009
2010 FIXME( "Filter dbch_devicetype %lu not implemented\n", filter->dbch_devicetype );
2011 return TRUE;
2012 }
2013
2014 static DWORD WINAPI device_notify_proc( void *arg )
2015 {
2016 WCHAR endpoint[] = L"\\pipe\\wine_plugplay";
2017 WCHAR protseq[] = L"ncacn_np";
2018 RPC_WSTR binding_str;
2019 DWORD err = ERROR_SUCCESS;
2020 struct device_notify_registration *registration;
2021 struct device_notification_details *details_copy;
2022 unsigned int details_copy_nelems, details_copy_size;
2023 plugplay_rpc_handle handle = NULL;
2024 DWORD code = 0;
2025 unsigned int i, size;
2026 BYTE *buf;
2027
2028 SetThreadDescription( GetCurrentThread(), L"wine_sechost_device_notify" );
2029
2030 if ((err = RpcStringBindingComposeW( NULL, protseq, NULL, endpoint, NULL, &binding_str )))
2031 {
2032 ERR("RpcStringBindingCompose() failed, error %#lx\n", err);
2033 return err;
2034 }
2035 err = RpcBindingFromStringBindingW( binding_str, &plugplay_binding_handle );
2036 RpcStringFreeW( &binding_str );
2037 if (err)
2038 {
2039 ERR("RpcBindingFromStringBinding() failed, error %#lx\n", err);
2040 return err;
2041 }
2042
2043 __TRY
2044 {
2045 handle = plugplay_register_listener();
2046 }
2047 __EXCEPT(rpc_filter)
2048 {
2049 err = map_exception_code( GetExceptionCode() );
2050 }
2051 __ENDTRY
2052
2053 if (!handle)
2054 {
2055 ERR("failed to open RPC handle, error %lu\n", err);
2056 return 1;
2057 }
2058
2059 details_copy_size = 8;
2060 details_copy = heap_alloc( details_copy_size * sizeof(*details_copy) );
2061
2062 for (;;)
2063 {
2064 buf = NULL;
2065 __TRY
2066 {
2067 code = plugplay_get_event( handle, &buf, &size );
2068 err = ERROR_SUCCESS;
2069 }
2070 __EXCEPT(rpc_filter)
2071 {
2072 err = map_exception_code( GetExceptionCode() );
2073 }
2074 __ENDTRY
2075
2076 if (err)
2077 {
2078 ERR("failed to get event, error %lu\n", err);
2079 break;
2080 }
2081
2082 /* Make a copy to avoid a hang if a callback tries to register or unregister for notifications. */
2083 i = 0;
2084 details_copy_nelems = 0;
2085 EnterCriticalSection( &service_cs );
2086 LIST_FOR_EACH_ENTRY(registration, &device_notify_list, struct device_notify_registration, entry)
2087 {
2088 details_copy[i++] = registration->details;
2089 details_copy_nelems++;
2090 if (i == details_copy_size)
2091 {
2092 details_copy_size *= 2;
2093 details_copy = heap_realloc( details_copy, details_copy_size * sizeof(*details_copy) );
2094 }
2095 }
2096 LeaveCriticalSection(&service_cs);
2097
2098 for (i = 0; i < details_copy_nelems; i++)
2099 {
2100 if (!notification_filter_matches( &details_copy[i].filter.header, (DEV_BROADCAST_HDR *)buf )) continue;
2101 details_copy[i].cb( details_copy[i].handle, code, (DEV_BROADCAST_HDR *)buf );
2102 }
2103 MIDL_user_free(buf);
2104 }
2105
2106 heap_free( details_copy );
2107
2108 __TRY
2109 {
2110 plugplay_unregister_listener( handle );
2111 }
2112 __EXCEPT(rpc_filter)
2113 {
2114 }
2115 __ENDTRY
2116
2117 RpcBindingFree( &plugplay_binding_handle );
2118 return 0;
2119 }
2120
2121 /******************************************************************************
2122 * I_ScRegisterDeviceNotification (sechost.@)
2123 */
2124 HDEVNOTIFY WINAPI I_ScRegisterDeviceNotification( struct device_notification_details *details,
2125 void *filter, DWORD flags )
2126 {
2127 struct device_notify_registration *registration;
2128
2129 TRACE("callback %p, handle %p, filter %p, flags %#lx\n", details->cb, details->handle, filter, flags);
2130
2131 if (!(registration = heap_alloc(sizeof(struct device_notify_registration))))
2132 {
2133 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2134 return NULL;
2135 }
2136
2137 registration->details = *details;
2138
2139 EnterCriticalSection( &service_cs );
2140 list_add_tail( &device_notify_list, &registration->entry );
2141
2142 if (!device_notify_thread)
2143 device_notify_thread = CreateThread( NULL, 0, device_notify_proc, NULL, 0, NULL );
2144
2145 LeaveCriticalSection( &service_cs );
2146
2147 return registration;
2148 }
2149
2150 /******************************************************************************
2151 * I_ScUnregisterDeviceNotification (sechost.@)
2152 */
2153 BOOL WINAPI I_ScUnregisterDeviceNotification( HDEVNOTIFY handle )
2154 {
2155 struct device_notify_registration *registration = handle;
2156
2157 TRACE("%p\n", handle);
2158
2159 if (!handle)
2160 return FALSE;
2161
2162 EnterCriticalSection( &service_cs );
2163 list_remove( &registration->entry );
2164 LeaveCriticalSection(&service_cs);
2165 heap_free( registration );
2166 return TRUE;
2167 }
Windows API implementation