ReactOS  0.4.15-dev-1206-g731eddf
umpnpmgr.c
Go to the documentation of this file.
1 /*
2  * ReactOS kernel
3  * Copyright (C) 2005 ReactOS Team
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with this program; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18  */
19 /*
20  * COPYRIGHT: See COPYING in the top level directory
21  * PROJECT: ReactOS kernel
22  * FILE: base/services/umpnpmgr/umpnpmgr.c
23  * PURPOSE: User-mode Plug and Play manager
24  * PROGRAMMER: Eric Kohl (eric.kohl@reactos.org)
25  * Hervé Poussineau (hpoussin@reactos.org)
26  * Colin Finck (colin@reactos.org)
27  */
28 
29 /* INCLUDES *****************************************************************/
30 
31 #include "precomp.h"
32 
33 #define NDEBUG
34 #include <debug.h>
35 
36 
37 /* GLOBALS ******************************************************************/
38 
39 static WCHAR ServiceName[] = L"PlugPlay";
40 
43 
47 
48 /* FUNCTIONS *****************************************************************/
49 
50 static DWORD WINAPI
52 {
53  PLUGPLAY_CONTROL_USER_RESPONSE_DATA ResponseData = {0, 0, 0, 0};
54  DWORD dwRet = ERROR_SUCCESS;
56  RPC_STATUS RpcStatus;
57  PPLUGPLAY_EVENT_BLOCK PnpEvent, NewPnpEvent;
58  ULONG PnpEventSize;
59 
61 
62  PnpEventSize = 0x1000;
63  PnpEvent = HeapAlloc(GetProcessHeap(), 0, PnpEventSize);
64  if (PnpEvent == NULL)
65  return ERROR_OUTOFMEMORY;
66 
67  for (;;)
68  {
69  DPRINT("Calling NtGetPlugPlayEvent()\n");
70 
71  /* Wait for the next PnP event */
72  Status = NtGetPlugPlayEvent(0, 0, PnpEvent, PnpEventSize);
73 
74  /* Resize the buffer for the PnP event if it's too small */
76  {
77  PnpEventSize += 0x400;
78  NewPnpEvent = HeapReAlloc(GetProcessHeap(), 0, PnpEvent, PnpEventSize);
79  if (NewPnpEvent == NULL)
80  {
81  dwRet = ERROR_OUTOFMEMORY;
82  break;
83  }
84  PnpEvent = NewPnpEvent;
85  continue;
86  }
87 
88  if (!NT_SUCCESS(Status))
89  {
90  DPRINT1("NtGetPlugPlayEvent() failed (Status 0x%08lx)\n", Status);
91  break;
92  }
93 
94  /* Process the PnP event */
95  DPRINT("Received PnP Event\n");
96  if (UuidEqual(&PnpEvent->EventGuid, (UUID*)&GUID_DEVICE_ENUMERATED, &RpcStatus))
97  {
98  DeviceInstallParams* Params;
99  DWORD len;
100  DWORD DeviceIdLength;
101 
102  DPRINT("Device enumerated: %S\n", PnpEvent->TargetDevice.DeviceIds);
103 
104  DeviceIdLength = lstrlenW(PnpEvent->TargetDevice.DeviceIds);
105  if (DeviceIdLength)
106  {
107  /* Allocate a new device-install event */
108  len = FIELD_OFFSET(DeviceInstallParams, DeviceIds) + (DeviceIdLength + 1) * sizeof(WCHAR);
109  Params = HeapAlloc(GetProcessHeap(), 0, len);
110  if (Params)
111  {
112  wcscpy(Params->DeviceIds, PnpEvent->TargetDevice.DeviceIds);
113 
114  /* Queue the event (will be dequeued by DeviceInstallThread) */
118 
120  }
121  }
122  }
123  else if (UuidEqual(&PnpEvent->EventGuid, (UUID*)&GUID_DEVICE_ARRIVAL, &RpcStatus))
124  {
125 // DWORD dwRecipient;
126 
127  DPRINT("Device arrival: %S\n", PnpEvent->TargetDevice.DeviceIds);
128 
129 // dwRecipient = BSM_ALLDESKTOPS | BSM_APPLICATIONS;
130 // BroadcastSystemMessageW(BSF_POSTMESSAGE,
131 // &dwRecipient,
132 // WM_DEVICECHANGE,
133 // DBT_DEVNODES_CHANGED,
134 // 0);
136  }
137  else if (UuidEqual(&PnpEvent->EventGuid, (UUID*)&GUID_DEVICE_EJECT_VETOED, &RpcStatus))
138  {
139  DPRINT1("Eject vetoed: %S\n", PnpEvent->TargetDevice.DeviceIds);
140  }
141  else if (UuidEqual(&PnpEvent->EventGuid, (UUID*)&GUID_DEVICE_KERNEL_INITIATED_EJECT, &RpcStatus))
142  {
143  DPRINT1("Kernel initiated eject: %S\n", PnpEvent->TargetDevice.DeviceIds);
144  }
145  else if (UuidEqual(&PnpEvent->EventGuid, (UUID*)&GUID_DEVICE_SAFE_REMOVAL, &RpcStatus))
146  {
147 // DWORD dwRecipient;
148 
149  DPRINT1("Safe removal: %S\n", PnpEvent->TargetDevice.DeviceIds);
150 
151 // dwRecipient = BSM_ALLDESKTOPS | BSM_APPLICATIONS;
152 // BroadcastSystemMessageW(BSF_POSTMESSAGE,
153 // &dwRecipient,
154 // WM_DEVICECHANGE,
155 // DBT_DEVNODES_CHANGED,
156 // 0);
158  }
159  else if (UuidEqual(&PnpEvent->EventGuid, (UUID*)&GUID_DEVICE_SURPRISE_REMOVAL, &RpcStatus))
160  {
161 // DWORD dwRecipient;
162 
163  DPRINT1("Surprise removal: %S\n", PnpEvent->TargetDevice.DeviceIds);
164 
165 // dwRecipient = BSM_ALLDESKTOPS | BSM_APPLICATIONS;
166 // BroadcastSystemMessageW(BSF_POSTMESSAGE,
167 // &dwRecipient,
168 // WM_DEVICECHANGE,
169 // DBT_DEVNODES_CHANGED,
170 // 0);
172  }
173  else if (UuidEqual(&PnpEvent->EventGuid, (UUID*)&GUID_DEVICE_REMOVAL_VETOED, &RpcStatus))
174  {
175  DPRINT1("Removal vetoed: %S\n", PnpEvent->TargetDevice.DeviceIds);
176  }
177  else if (UuidEqual(&PnpEvent->EventGuid, (UUID*)&GUID_DEVICE_REMOVE_PENDING, &RpcStatus))
178  {
179  DPRINT1("Removal pending: %S\n", PnpEvent->TargetDevice.DeviceIds);
180  }
181  else
182  {
183  DPRINT1("Unknown event, GUID {%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}\n",
184  PnpEvent->EventGuid.Data1, PnpEvent->EventGuid.Data2, PnpEvent->EventGuid.Data3,
185  PnpEvent->EventGuid.Data4[0], PnpEvent->EventGuid.Data4[1], PnpEvent->EventGuid.Data4[2],
186  PnpEvent->EventGuid.Data4[3], PnpEvent->EventGuid.Data4[4], PnpEvent->EventGuid.Data4[5],
187  PnpEvent->EventGuid.Data4[6], PnpEvent->EventGuid.Data4[7]);
188  }
189 
190  /* Dequeue the current PnP event and signal the next one */
192  &ResponseData,
193  sizeof(ResponseData));
194  if (!NT_SUCCESS(Status))
195  {
196  DPRINT1("NtPlugPlayControl(PlugPlayControlUserResponse) failed (Status 0x%08lx)\n", Status);
197  break;
198  }
199  }
200 
201  HeapFree(GetProcessHeap(), 0, PnpEvent);
202 
203  return dwRet;
204 }
205 
206 
207 static VOID
209 {
211  ServiceStatus.dwCurrentState = dwState;
216 
217  if (dwState == SERVICE_START_PENDING ||
218  dwState == SERVICE_STOP_PENDING ||
219  dwState == SERVICE_PAUSE_PENDING ||
220  dwState == SERVICE_CONTINUE_PENDING)
221  ServiceStatus.dwWaitHint = 10000;
222  else
224 
226  &ServiceStatus);
227 }
228 
229 
230 static DWORD WINAPI
232  DWORD dwEventType,
233  LPVOID lpEventData,
234  LPVOID lpContext)
235 {
236  DPRINT1("ServiceControlHandler() called\n");
237 
238  switch (dwControl)
239  {
241  DPRINT1(" SERVICE_CONTROL_STOP received\n");
242  /* Stop listening to RPC Messages */
245  return ERROR_SUCCESS;
246 
248  DPRINT1(" SERVICE_CONTROL_PAUSE received\n");
250  return ERROR_SUCCESS;
251 
253  DPRINT1(" SERVICE_CONTROL_CONTINUE received\n");
255  return ERROR_SUCCESS;
256 
258  DPRINT1(" SERVICE_CONTROL_INTERROGATE received\n");
260  &ServiceStatus);
261  return ERROR_SUCCESS;
262 
264  DPRINT1(" SERVICE_CONTROL_SHUTDOWN received\n");
265  /* Stop listening to RPC Messages */
268  return ERROR_SUCCESS;
269 
270  default :
271  DPRINT1(" Control %lu received\n", dwControl);
273  }
274 }
275 
276 static DWORD
278  IN HKEY hKey,
279  IN PCWSTR lpSubKey,
280  IN PCWSTR lpValue,
281  OUT PBOOL pValue)
282 {
283  DWORD dwError, dwType, dwData;
284  DWORD cbData = sizeof(dwData);
285  HKEY hSubKey = NULL;
286 
287  /* Default value */
288  *pValue = FALSE;
289 
290  dwError = RegOpenKeyExW(hKey,
291  lpSubKey,
292  0,
293  KEY_READ,
294  &hSubKey);
295  if (dwError != ERROR_SUCCESS)
296  {
297  DPRINT("GetBooleanRegValue(): RegOpenKeyExW() has failed to open '%S' key! (Error: %lu)\n",
298  lpSubKey, dwError);
299  return dwError;
300  }
301 
302  dwError = RegQueryValueExW(hSubKey,
303  lpValue,
304  0,
305  &dwType,
306  (PBYTE)&dwData,
307  &cbData);
308  if (dwError != ERROR_SUCCESS)
309  {
310  DPRINT("GetBooleanRegValue(): RegQueryValueExW() has failed to query '%S' value! (Error: %lu)\n",
311  lpValue, dwError);
312  goto Cleanup;
313  }
314  if (dwType != REG_DWORD)
315  {
316  DPRINT("GetBooleanRegValue(): The value is not of REG_DWORD type!\n");
317  goto Cleanup;
318  }
319 
320  /* Return the value */
321  *pValue = (dwData == 1);
322 
323 Cleanup:
324  RegCloseKey(hSubKey);
325 
326  return dwError;
327 }
328 
329 BOOL
331 {
332  BOOL bSuppressNewHWUI = FALSE;
333 
334  /*
335  * Query the SuppressNewHWUI policy registry value. Don't cache it
336  * as we want to update our behaviour in consequence.
337  */
339  L"Software\\Policies\\Microsoft\\Windows\\DeviceInstall\\Settings",
340  L"SuppressNewHWUI",
341  &bSuppressNewHWUI);
342  if (bSuppressNewHWUI)
343  DPRINT("GetSuppressNewUIValue(): newdev.dll's wizard UI won't be shown!\n");
344 
345  return bSuppressNewHWUI;
346 }
347 
348 VOID WINAPI
350 {
351  HANDLE hThread;
353 
356 
357  DPRINT("ServiceMain() called\n");
358 
361  NULL);
362  if (!ServiceStatusHandle)
363  {
364  DPRINT1("RegisterServiceCtrlHandlerExW() failed! (Error %lu)\n", GetLastError());
365  return;
366  }
367 
369 
371  0,
373  NULL,
374  0,
375  &dwThreadId);
376  if (hThread != NULL)
378 
380  0,
382  NULL,
383  0,
384  &dwThreadId);
385  if (hThread != NULL)
387 
389  0,
391  NULL,
392  0,
393  &dwThreadId);
394  if (hThread != NULL)
396 
398 
399  DPRINT("ServiceMain() done\n");
400 }
401 
402 static DWORD
404 {
405  BOOLEAN OldValue;
406  DWORD dwError;
407 
408  DPRINT("UMPNPMGR: InitializePnPManager() started\n");
409 
410  /* We need this privilege for using CreateProcessAsUserW */
412 
414  if (hInstallEvent == NULL)
415  {
416  dwError = GetLastError();
417  DPRINT1("Could not create the Install Event! (Error %lu)\n", dwError);
418  return dwError;
419  }
420 
422  TRUE,
423  FALSE,
424  L"Global\\PnP_No_Pending_Install_Events");
425  if (hNoPendingInstalls == NULL)
426  {
427  dwError = GetLastError();
428  DPRINT1("Could not create the Pending-Install Event! (Error %lu)\n", dwError);
429  return dwError;
430  }
431 
432  /*
433  * Initialize the device-install event list
434  */
435 
438  {
439  dwError = GetLastError();
440  DPRINT1("Could not create the List Event! (Error %lu)\n", dwError);
441  return dwError;
442  }
443 
446  {
447  dwError = GetLastError();
448  DPRINT1("Could not create the List Mutex! (Error %lu)\n", dwError);
449  return dwError;
450  }
452 
453  /* Query the SuppressUI registry value and cache it for our whole lifetime */
455  L"System\\CurrentControlSet\\Services\\PlugPlay\\Parameters",
456  L"SuppressUI",
458  if (g_IsUISuppressed)
459  DPRINT("UMPNPMGR: newdev.dll's wizard UI won't be shown!\n");
460 
462  L"System\\CurrentControlSet\\Enum",
463  0,
465  &hEnumKey);
466  if (dwError != ERROR_SUCCESS)
467  {
468  DPRINT1("Could not open the Enum Key! (Error %lu)\n", dwError);
469  return dwError;
470  }
471 
473  L"System\\CurrentControlSet\\Control\\Class",
474  0,
476  &hClassKey);
477  if (dwError != ERROR_SUCCESS)
478  {
479  DPRINT1("Could not open the Class Key! (Error %lu)\n", dwError);
480  return dwError;
481  }
482 
483  DPRINT("UMPNPMGR: InitializePnPManager() done\n");
484 
485  return 0;
486 }
487 
488 BOOL WINAPI
490  DWORD fdwReason,
492 {
493  switch (fdwReason)
494  {
495  case DLL_PROCESS_ATTACH:
496  DisableThreadLibraryCalls(hinstDLL);
498  break;
499 
500  case DLL_PROCESS_DETACH:
501  break;
502  }
503 
504  return TRUE;
505 }
506 
507 /* EOF */
static int argc
Definition: ServiceArgs.c:12
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
Definition: umpnpmgr.c:489
const uint16_t * PCWSTR
Definition: typedefs.h:57
#define IN
Definition: typedefs.h:39
VOID WINAPI ServiceMain(DWORD argc, LPTSTR *argv)
Definition: umpnpmgr.c:349
#define CloseHandle
Definition: compat.h:598
RPC_STATUS WINAPI RpcMgmtStopServerListening(RPC_BINDING_HANDLE Binding)
Definition: rpc_server.c:1596
static SERVICE_STATUS ServiceStatus
Definition: umpnpmgr.c:42
#define ERROR_SUCCESS
Definition: deptool.c:10
BOOL g_IsUISuppressed
Definition: umpnpmgr.c:46
DWORD dwCurrentState
Definition: winsvc.h:100
#define DBT_DEVNODES_CHANGED
Definition: dbt.h:28
#define SERVICE_PAUSE_PENDING
Definition: winsvc.h:26
#define KEY_READ
Definition: nt_native.h:1023
#define TRUE
Definition: types.h:120
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
#define SERVICE_PAUSED
Definition: winsvc.h:27
HANDLE hInstallEvent
Definition: install.c:40
LONG NTSTATUS
Definition: precomp.h:26
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
static HANDLE ULONG_PTR dwData
Definition: file.c:35
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
NTSYSAPI NTSTATUS NTAPI RtlAdjustPrivilege(_In_ ULONG Privilege, _In_ BOOLEAN NewValue, _In_ BOOLEAN ForThread, _Out_ PBOOLEAN OldValue)
#define SERVICE_START_PENDING
Definition: winsvc.h:22
DWORD dwServiceSpecificExitCode
Definition: winsvc.h:103
static VOID UpdateServiceStatus(DWORD dwState)
Definition: umpnpmgr.c:208
#define DLL_PROCESS_ATTACH
Definition: compat.h:131
int WINAPI UuidEqual(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
Definition: rpcrt4_main.c:250
LIST_ENTRY DeviceInstallListHead
Definition: install.c:45
#define InsertTailList(ListHead, Entry)
#define argv
Definition: mplay32.c:18
#define lstrlenW
Definition: compat.h:609
CHAR * LPTSTR
Definition: xmlstorage.h:192
static IN DWORD IN LPVOID lpvReserved
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
BOOL GetSuppressNewUIValue(VOID)
Definition: umpnpmgr.c:330
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
BOOL WINAPI SetServiceStatus(SERVICE_STATUS_HANDLE hServiceStatus, LPSERVICE_STATUS lpServiceStatus)
Definition: sctrl.c:995
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
long RPC_STATUS
Definition: rpc.h:52
DWORD dwCheckPoint
Definition: winsvc.h:104
#define SERVICE_STOPPED
Definition: winsvc.h:21
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
NTSTATUS NTAPI NtGetPlugPlayEvent(IN ULONG Reserved1, IN ULONG Reserved2, OUT PPLUGPLAY_EVENT_BLOCK Buffer, IN ULONG BufferSize)
Definition: plugplay.c:1132
#define SERVICE_RUNNING
Definition: winsvc.h:24
static SERVICE_STATUS_HANDLE ServiceStatusHandle
Definition: umpnpmgr.c:41
static DWORD WINAPI PnpEventThread(LPVOID lpParameter)
Definition: umpnpmgr.c:51
HKEY hEnumKey
Definition: umpnpmgr.c:44
unsigned char BOOLEAN
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:136
static BOOL SetupIsActive(VOID)
Definition: setup.c:27
smooth NULL
Definition: ftsmooth.c:416
void DPRINT(...)
Definition: polytest.cpp:61
#define SERVICE_CONTROL_INTERROGATE
Definition: winsvc.h:39
static DWORD InitializePnPManager(VOID)
Definition: umpnpmgr.c:403
#define SERVICE_WIN32_OWN_PROCESS
Definition: cmtypes.h:962
BOOL * PBOOL
Definition: windef.h:161
HANDLE hNoPendingInstalls
Definition: install.c:41
#define DLL_PROCESS_DETACH
Definition: compat.h:130
static SERVICE_STATUS_HANDLE(WINAPI *pRegisterServiceCtrlHandlerExA)(LPCSTR
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4116
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
DWORD dwWaitHint
Definition: winsvc.h:105
#define WINAPI
Definition: msvc.h:6
DWORD dwWin32ExitCode
Definition: winsvc.h:102
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD dwServiceType
Definition: winsvc.h:99
LIST_ENTRY ListEntry
Definition: precomp.h:38
BOOL WINAPI DECLSPEC_HOTPATCH ReleaseMutex(IN HANDLE hMutex)
Definition: synch.c:618
#define SERVICE_CONTROL_PAUSE
Definition: winsvc.h:37
DWORD dwThreadId
Definition: fdebug.c:31
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
Status
Definition: gdiplustypes.h:24
static const WCHAR L[]
Definition: oid.c:1250
static DWORD WINAPI ServiceControlHandler(DWORD dwControl, DWORD dwEventType, LPVOID lpEventData, LPVOID lpContext)
Definition: umpnpmgr.c:231
LPVOID lpParameter
Definition: kernel32.h:241
static DWORD GetBooleanRegValue(IN HKEY hKey, IN PCWSTR lpSubKey, IN PCWSTR lpValue, OUT PBOOL pValue)
Definition: umpnpmgr.c:277
GLenum GLsizei len
Definition: glext.h:6722
SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerExW(LPCWSTR lpServiceName, LPHANDLER_FUNCTION_EX lpHandlerProc, LPVOID lpContext)
Definition: sctrl.c:810
static const WCHAR Cleanup[]
Definition: register.c:80
HANDLE hDeviceInstallListNotEmpty
Definition: install.c:46
DWORD dwControlsAccepted
Definition: winsvc.h:101
WCHAR DeviceIds[ANYSIZE_ARRAY]
Definition: precomp.h:39
NTSTATUS NTAPI NtPlugPlayControl(IN PLUGPLAY_CONTROL_CLASS PlugPlayControlClass, IN OUT PVOID Buffer, IN ULONG BufferLength)
Definition: plugplay.c:1262
#define SERVICE_CONTINUE_PENDING
Definition: winsvc.h:25
DWORD WINAPI RpcServerThread(LPVOID lpParameter)
Definition: rpcserver.c:45
struct _PLUGPLAY_EVENT_BLOCK::@2344::@2347 TargetDevice
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define SERVICE_CONTROL_CONTINUE
Definition: winsvc.h:38
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define HeapReAlloc
Definition: compat.h:593
HANDLE WINAPI DECLSPEC_HOTPATCH CreateMutexW(IN LPSECURITY_ATTRIBUTES lpMutexAttributes OPTIONAL, IN BOOL bInitialOwner, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:576
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
HANDLE hThread
Definition: wizard.c:27
#define WM_DEVICECHANGE
Definition: winuser.h:1793
#define DPRINT1
Definition: precomp.h:8
#define OUT
Definition: typedefs.h:40
#define SE_ASSIGNPRIMARYTOKEN_PRIVILEGE
Definition: security.c:657
unsigned int ULONG
Definition: retypes.h:1
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3366
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
static WCHAR ServiceName[]
Definition: umpnpmgr.c:39
#define SERVICE_CONTROL_STOP
Definition: winsvc.h:36
HANDLE hDeviceInstallListMutex
Definition: install.c:44
#define INFINITE
Definition: serial.h:102
#define REG_DWORD
Definition: sdbapi.c:596
#define HWND_BROADCAST
Definition: winuser.h:1190
DWORD WINAPI DeviceInstallThread(LPVOID lpParameter)
Definition: install.c:357
BYTE * PBYTE
Definition: pedump.c:66
#define SERVICE_STOP_PENDING
Definition: winsvc.h:23
#define HeapFree(x, y, z)
Definition: compat.h:594
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
HKEY hClassKey
Definition: umpnpmgr.c:45
#define SERVICE_CONTROL_SHUTDOWN
Definition: winsvc.h:40
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12