[USERENV]
[reactos.git] / reactos / dll / win32 / userenv / gpolicy.c
1 /*
2 * ReactOS kernel
3 * Copyright (C) 2006 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 system libraries
22 * FILE: dll/win32/userenv/gpolicy.c
23 * PURPOSE: Group policy functions
24 * PROGRAMMER: Thomas Weidenmueller <w3seek@reactos.com>
25 */
26
27 #include "precomp.h"
28
29 #define NDEBUG
30 #include <debug.h>
31
32 typedef struct _GP_NOTIFY
33 {
34 struct _GP_NOTIFY *Next;
35 HANDLE hEvent;
36 BOOL bMachine;
37 } GP_NOTIFY, *PGP_NOTIFY;
38
39 typedef enum
40 {
41 gpaUpdate = 0,
42 gpaTerminate
43 } GP_ACTION;
44
45 static const WCHAR szLocalGPApplied[] = L"userenv: User Group Policy has been applied";
46 static const WCHAR szLocalGPMutex[] = L"userenv: user policy mutex";
47 static const WCHAR szLocalGPRefreshEvent[] = L"userenv: user policy refresh event";
48 static const WCHAR szLocalGPForceRefreshEvent[] = L"userenv: user policy force refresh event";
49 static const WCHAR szLocalGPDoneEvent[] = L"userenv: User Policy Foreground Done Event";
50 static const WCHAR szMachineGPApplied[] = L"Global\\userenv: Machine Group Policy has been applied";
51 static const WCHAR szMachineGPMutex[] = L"Global\\userenv: machine policy mutex";
52 static const WCHAR szMachineGPRefreshEvent[] = L"Global\\userenv: machine policy refresh event";
53 static const WCHAR szMachineGPForceRefreshEvent[] = L"Global\\userenv: machine policy force refresh event";
54 static const WCHAR szMachineGPDoneEvent[] = L"Global\\userenv: Machine Policy Foreground Done Event";
55
56 static CRITICAL_SECTION GPNotifyLock;
57 static PGP_NOTIFY NotificationList = NULL;
58 static GP_ACTION GPNotificationAction = gpaUpdate;
59 static HANDLE hNotificationThread = NULL;
60 static HANDLE hNotificationThreadEvent = NULL;
61 static HANDLE hLocalGPAppliedEvent = NULL;
62 static HANDLE hMachineGPAppliedEvent = NULL;
63
64 VOID
65 InitializeGPNotifications(VOID)
66 {
67 InitializeCriticalSection(&GPNotifyLock);
68 }
69
70 VOID
71 UninitializeGPNotifications(VOID)
72 {
73 EnterCriticalSection(&GPNotifyLock);
74
75 /* rundown the notification thread */
76 if (hNotificationThread != NULL)
77 {
78 ASSERT(hNotificationThreadEvent != NULL);
79
80 /* notify the thread */
81 GPNotificationAction = gpaTerminate;
82 SetEvent(hNotificationThreadEvent);
83
84 LeaveCriticalSection(&GPNotifyLock);
85
86 /* wait for the thread to terminate itself */
87 WaitForSingleObject(hNotificationThread,
88 INFINITE);
89
90 EnterCriticalSection(&GPNotifyLock);
91
92 if (hNotificationThread != NULL)
93 {
94 /* the handle should be closed by the thread,
95 just in case that didn't happen for an unknown reason */
96 CloseHandle(hNotificationThread);
97 hNotificationThread = NULL;
98 }
99 }
100
101 if (hNotificationThreadEvent != NULL)
102 {
103 CloseHandle(hNotificationThreadEvent);
104 hNotificationThreadEvent = NULL;
105 }
106
107 LeaveCriticalSection(&GPNotifyLock);
108
109 DeleteCriticalSection(&GPNotifyLock);
110 }
111
112 static
113 VOID
114 NotifyGPEvents(IN BOOL bMachine)
115 {
116 PGP_NOTIFY Notify = NotificationList;
117
118 while (Notify != NULL)
119 {
120 if (Notify->bMachine == bMachine)
121 {
122 SetEvent(Notify->hEvent);
123 }
124
125 Notify = Notify->Next;
126 }
127 }
128
129 static
130 DWORD
131 WINAPI
132 GPNotificationThreadProc(IN LPVOID lpParameter)
133 {
134 HMODULE hModule;
135 DWORD WaitResult, WaitCount;
136 HANDLE WaitHandles[3];
137
138 /* reference the library so we don't screw up if the application
139 causes the DLL to unload while this thread is still running */
140 if (GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
141 (LPCWSTR)hInstance,
142 &hModule))
143 {
144 ASSERT(hModule == hInstance);
145
146 EnterCriticalSection(&GPNotifyLock);
147
148 ASSERT(hNotificationThreadEvent != NULL);
149 WaitHandles[0] = hNotificationThreadEvent;
150 for (;;)
151 {
152 ASSERT(hMachineGPAppliedEvent != NULL);
153
154 if (NotificationList == NULL)
155 break;
156
157 WaitCount = 2;
158 WaitHandles[1] = hMachineGPAppliedEvent;
159
160 if (hLocalGPAppliedEvent != NULL)
161 {
162 WaitHandles[2] = hLocalGPAppliedEvent;
163 WaitCount++;
164 }
165
166 LeaveCriticalSection(&GPNotifyLock);
167
168 WaitResult = WaitForMultipleObjects(WaitCount,
169 WaitHandles,
170 FALSE,
171 INFINITE);
172
173 EnterCriticalSection(&GPNotifyLock);
174
175 if (WaitResult != WAIT_FAILED)
176 {
177 if (WaitResult == WAIT_OBJECT_0)
178 {
179 ResetEvent(hNotificationThreadEvent);
180
181 if (GPNotificationAction == gpaTerminate)
182 {
183 /* terminate the thread */
184 break;
185 }
186 }
187 else if (WaitResult == WAIT_OBJECT_0 + 1 || WaitResult == WAIT_OBJECT_0 + 2)
188 {
189 /* group policies have been applied */
190 if (NotificationList != NULL)
191 {
192 NotifyGPEvents((WaitResult == WAIT_OBJECT_0 + 1));
193 }
194 }
195 else if (WaitResult == WAIT_ABANDONED_0 + 2)
196 {
197 /* In case the local group policies event was abandoned, keep watching!
198 But close the handle as it's no longer of any use. */
199 if (hLocalGPAppliedEvent != NULL)
200 {
201 CloseHandle(hLocalGPAppliedEvent);
202 hLocalGPAppliedEvent = NULL;
203 }
204 }
205 else if (WaitResult == WAIT_ABANDONED_0 || WaitResult == WAIT_ABANDONED_0 + 1)
206 {
207 /* terminate the thread if the machine group policies event was abandoned
208 or for some reason the rundown event got abandoned. */
209 break;
210 }
211 else
212 {
213 DPRINT("Unexpected wait result watching the group policy events: 0x%x\n", WaitResult);
214 ASSERT(FALSE);
215 break;
216 }
217
218 if (NotificationList == NULL)
219 break;
220 }
221 else
222 break;
223
224 }
225
226 /* cleanup handles no longer used */
227 ASSERT(hNotificationThread != NULL);
228 ASSERT(hNotificationThreadEvent != NULL);
229
230 CloseHandle(hNotificationThread);
231 CloseHandle(hNotificationThreadEvent);
232 hNotificationThread = NULL;
233 hNotificationThreadEvent = NULL;
234
235 if (hLocalGPAppliedEvent != NULL)
236 {
237 CloseHandle(hLocalGPAppliedEvent);
238 hLocalGPAppliedEvent = NULL;
239 }
240 if (hMachineGPAppliedEvent != NULL)
241 {
242 CloseHandle(hMachineGPAppliedEvent);
243 hMachineGPAppliedEvent = NULL;
244 }
245
246 LeaveCriticalSection(&GPNotifyLock);
247
248 /* dereference the library and exit */
249 FreeLibraryAndExitThread(hModule,
250 0);
251 }
252 else
253 {
254 DPRINT1("Referencing the library failed!\n");
255 }
256
257 return 1;
258 }
259
260 static
261 HANDLE
262 CreateGPEvent(IN BOOL bMachine,
263 IN PSECURITY_DESCRIPTOR lpSecurityDescriptor)
264 {
265 HANDLE hEvent;
266 SECURITY_ATTRIBUTES SecurityAttributes;
267
268 SecurityAttributes.nLength = sizeof(SECURITY_ATTRIBUTES);
269 SecurityAttributes.lpSecurityDescriptor = lpSecurityDescriptor;
270 SecurityAttributes.bInheritHandle = FALSE;
271
272 hEvent = CreateEventW(&SecurityAttributes,
273 TRUE,
274 FALSE,
275 (bMachine ? szMachineGPApplied : szLocalGPApplied));
276
277 return hEvent;
278 }
279
280 BOOL
281 WINAPI
282 RegisterGPNotification(IN HANDLE hEvent,
283 IN BOOL bMachine)
284 {
285 PGP_NOTIFY Notify;
286 PSECURITY_DESCRIPTOR lpSecurityDescriptor = NULL;
287 BOOL Ret = FALSE;
288
289 EnterCriticalSection(&GPNotifyLock);
290
291 /* create the thread notification event */
292 if (hNotificationThreadEvent == NULL)
293 {
294 hNotificationThreadEvent = CreateEvent(NULL,
295 TRUE,
296 FALSE,
297 NULL);
298 if (hNotificationThreadEvent == NULL)
299 {
300 goto Cleanup;
301 }
302 }
303
304 /* create or open the machine group policy event */
305 if (hMachineGPAppliedEvent == NULL)
306 {
307 lpSecurityDescriptor = CreateDefaultSecurityDescriptor();
308 if (lpSecurityDescriptor == NULL)
309 {
310 goto Cleanup;
311 }
312
313 hMachineGPAppliedEvent = CreateGPEvent(TRUE,
314 lpSecurityDescriptor);
315 if (hMachineGPAppliedEvent == NULL)
316 {
317 goto Cleanup;
318 }
319 }
320
321 /* create or open the local group policy event only if necessary */
322 if (!bMachine && hLocalGPAppliedEvent == NULL)
323 {
324 if (lpSecurityDescriptor == NULL)
325 {
326 lpSecurityDescriptor = CreateDefaultSecurityDescriptor();
327 if (lpSecurityDescriptor == NULL)
328 {
329 goto Cleanup;
330 }
331 }
332
333 hLocalGPAppliedEvent = CreateGPEvent(FALSE,
334 lpSecurityDescriptor);
335 if (hLocalGPAppliedEvent == NULL)
336 {
337 goto Cleanup;
338 }
339 }
340
341 if (hNotificationThread == NULL)
342 {
343 hNotificationThread = CreateThread(NULL,
344 0,
345 GPNotificationThreadProc,
346 NULL,
347 0,
348 NULL);
349 }
350
351 if (hNotificationThread != NULL)
352 {
353 Notify = (PGP_NOTIFY)LocalAlloc(LMEM_FIXED,
354 sizeof(GP_NOTIFY));
355 if (Notify != NULL)
356 {
357 /* add the item to the beginning of the list */
358 Notify->Next = NotificationList;
359 Notify->hEvent = hEvent;
360 Notify->bMachine = bMachine;
361
362 NotificationList = Notify;
363
364 /* notify the thread */
365 GPNotificationAction = gpaUpdate;
366 SetEvent(hNotificationThreadEvent);
367
368 Ret = TRUE;
369 }
370 }
371
372 Cleanup:
373 LeaveCriticalSection(&GPNotifyLock);
374
375 if (lpSecurityDescriptor != NULL)
376 {
377 LocalFree((HLOCAL)lpSecurityDescriptor);
378 }
379
380 /* NOTE: don't delete the events or close the handles created */
381
382 return Ret;
383 }
384
385 BOOL
386 WINAPI
387 UnregisterGPNotification(IN HANDLE hEvent)
388 {
389 PGP_NOTIFY Notify = NULL, *NotifyLink;
390 BOOL Ret = FALSE;
391
392 EnterCriticalSection(&GPNotifyLock);
393
394 Notify = NotificationList;
395 NotifyLink = &NotificationList;
396
397 while (Notify != NULL)
398 {
399 if (Notify->hEvent == hEvent)
400 {
401 /* remove and free the item */
402 *NotifyLink = Notify->Next;
403 LocalFree((HLOCAL)Notify);
404
405 /* notify the thread */
406 if (hNotificationThread != NULL &&
407 hNotificationThreadEvent != NULL)
408 {
409 GPNotificationAction = gpaUpdate;
410 SetEvent(hNotificationThreadEvent);
411 }
412
413 Ret = TRUE;
414 break;
415 }
416
417 NotifyLink = &Notify->Next;
418 Notify = Notify->Next;
419 }
420
421 LeaveCriticalSection(&GPNotifyLock);
422
423 return Ret;
424 }
425
426 BOOL
427 WINAPI
428 RefreshPolicy(IN BOOL bMachine)
429 {
430 HANDLE hEvent;
431 BOOL Ret = TRUE;
432
433 hEvent = OpenEventW(EVENT_MODIFY_STATE,
434 FALSE,
435 (bMachine ? szMachineGPRefreshEvent : szLocalGPRefreshEvent));
436 if (hEvent != NULL)
437 {
438 Ret = SetEvent(hEvent);
439 CloseHandle(hEvent);
440 }
441
442 /* return TRUE even if the mutex doesn't exist! */
443 return Ret;
444 }
445
446 BOOL
447 WINAPI
448 RefreshPolicyEx(IN BOOL bMachine,
449 IN DWORD dwOptions)
450 {
451 if (dwOptions & ~RP_FORCE)
452 {
453 SetLastError(ERROR_INVALID_PARAMETER);
454 return FALSE;
455 }
456
457 if (dwOptions & RP_FORCE)
458 {
459 HANDLE hEvent;
460 BOOL Ret = TRUE;
461
462 hEvent = OpenEventW(EVENT_MODIFY_STATE,
463 FALSE,
464 (bMachine ? szMachineGPForceRefreshEvent : szLocalGPForceRefreshEvent));
465 if (hEvent != NULL)
466 {
467 Ret = SetEvent(hEvent);
468 CloseHandle(hEvent);
469 }
470
471 /* return TRUE even if the mutex doesn't exist! */
472 return Ret;
473 }
474 else
475 {
476 return RefreshPolicy(bMachine);
477 }
478 }
479
480 HANDLE
481 WINAPI
482 EnterCriticalPolicySection(IN BOOL bMachine)
483 {
484 SECURITY_ATTRIBUTES SecurityAttributes;
485 PSECURITY_DESCRIPTOR lpSecurityDescriptor;
486 HANDLE hSection;
487
488 /* create or open the mutex */
489 lpSecurityDescriptor = CreateDefaultSecurityDescriptor();
490 if (lpSecurityDescriptor != NULL)
491 {
492 SecurityAttributes.nLength = sizeof(SECURITY_ATTRIBUTES);
493 SecurityAttributes.lpSecurityDescriptor = lpSecurityDescriptor;
494 SecurityAttributes.bInheritHandle = FALSE;
495
496 hSection = CreateMutexW(&SecurityAttributes,
497 FALSE,
498 (bMachine ? szMachineGPMutex : szLocalGPMutex));
499
500 LocalFree((HLOCAL)lpSecurityDescriptor);
501
502 if (hSection != NULL)
503 {
504 /* wait up to 10 minutes */
505 if (WaitForSingleObject(hSection,
506 600000) != WAIT_FAILED)
507 {
508 return hSection;
509 }
510
511 CloseHandle(hSection);
512 }
513 }
514
515 return NULL;
516 }
517
518 BOOL
519 WINAPI
520 LeaveCriticalPolicySection(IN HANDLE hSection)
521 {
522 BOOL Ret;
523
524 if (hSection == NULL)
525 {
526 SetLastError(ERROR_INVALID_PARAMETER);
527 return FALSE;
528 }
529
530 Ret = ReleaseMutex(hSection);
531 CloseHandle(hSection);
532
533 return Ret;
534 }
535
536 BOOL
537 WINAPI
538 WaitForUserPolicyForegroundProcessing(VOID)
539 {
540 HANDLE hEvent;
541 BOOL Ret = FALSE;
542
543 hEvent = OpenEventW(SYNCHRONIZE,
544 FALSE,
545 szLocalGPDoneEvent);
546 if (hEvent != NULL)
547 {
548 Ret = WaitForSingleObject(hEvent,
549 INFINITE) != WAIT_FAILED;
550 CloseHandle(hEvent);
551 }
552
553 return Ret;
554 }
555
556 BOOL
557 WINAPI
558 WaitForMachinePolicyForegroundProcessing(VOID)
559 {
560 HANDLE hEvent;
561 BOOL Ret = FALSE;
562
563 hEvent = OpenEventW(SYNCHRONIZE,
564 FALSE,
565 szMachineGPDoneEvent);
566 if (hEvent != NULL)
567 {
568 Ret = WaitForSingleObject(hEvent,
569 INFINITE) != WAIT_FAILED;
570 CloseHandle(hEvent);
571 }
572
573 return Ret;
574 }
575
576 DWORD
577 WINAPI
578 GetAppliedGPOListA(
579 _In_ DWORD dwFlags,
580 _In_ LPCSTR pMachineName,
581 _In_ PSID pSidUser,
582 _In_ GUID *pGuidExtension,
583 _Out_ PGROUP_POLICY_OBJECTA *ppGPOList
584 )
585 {
586 DPRINT1("GetAppliedGPOListA is UNIMPLEMENTED!\n");
587 return ERROR_CALL_NOT_IMPLEMENTED;
588 }
589
590 DWORD
591 WINAPI
592 GetAppliedGPOListW(
593 _In_ DWORD dwFlags,
594 _In_ LPCWSTR pMachineName,
595 _In_ PSID pSidUser,
596 _In_ GUID *pGuidExtension,
597 _Out_ PGROUP_POLICY_OBJECTW *ppGPOList
598 )
599 {
600 DPRINT1("GetAppliedGPOListW is UNIMPLEMENTED!\n");
601 return ERROR_CALL_NOT_IMPLEMENTED;
602 }