Debian Codegraph @

libgpo/gpext/gpext.c

raw
1 /*
2 * Unix SMB/CIFS implementation.
3 * Group Policy Support
4 * Copyright (C) Guenther Deschner 2007-2008
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "../libgpo/gpo.h"
22 #include "../libgpo/gpext/gpext.h"
23 #include "librpc/gen_ndr/ndr_misc.h"
24 #include "lib/util/dlinklist.h"
25 #include "../libcli/registry/util_reg.h"
26 #include "libgpo/gpo_proto.h"
27 #include "registry.h"
28 #include "registry/reg_api.h"
29 #include "lib/util/util_paths.h"
30 #include "lib/util/string_wrappers.h"
31
32 static struct gp_extension *extensions = NULL;
33
34 /****************************************************************
35 ****************************************************************/
36
37 struct gp_extension *gpext_get_gp_extension_list(void)
38 {
39 return extensions;
40 }
41
42 /****************************************************************
43 ****************************************************************/
44
45
46 struct gp_extension_reg_table gpext_reg_vals[] = {
47 {
48 .val = "DllName",
49 .type = REG_EXPAND_SZ,
50 },
51 {
52 .val = "ProcessGroupPolicy",
53 .type = REG_SZ,
54 },
55 {
56 .val = "NoMachinePolicy",
57 .type = REG_DWORD,
58 },
59 {
60 .val = "NoUserPolicy",
61 .type = REG_DWORD,
62 },
63 {
64 .val = "NoSlowLink",
65 .type = REG_DWORD,
66 },
67 {
68 .val = "NoBackgroundPolicy",
69 .type = REG_DWORD,
70 },
71 {
72 .val = "NoGPOListChanges",
73 .type = REG_DWORD,
74 },
75 {
76 .val = "PerUserLocalSettings",
77 .type = REG_DWORD,
78 },
79 {
80 .val = "RequiresSuccessfulRegistry",
81 .type = REG_DWORD,
82 },
83 {
84 .val = "EnableAsynchronousProcessing",
85 .type = REG_DWORD,
86 },
87 {
88 .val = "ExtensionDebugLevel",
89 .type = REG_DWORD,
90 },
91 /* new */
92 {
93 .val = "GenerateGroupPolicy", /* not supported on w2k */
94 .type = REG_SZ,
95 },
96 {
97 .val = "NotifyLinkTransition",
98 .type = REG_DWORD,
99 },
100 {
101 .val = "ProcessGroupPolicyEx", /* not supported on w2k */
102 .type = REG_SZ,
103 },
104 {
105 .val = "ExtensionEventSource", /* not supported on w2k */
106 .type = REG_MULTI_SZ,
107 },
108 {
109 .val = "MaxNoGPOListChangesInterval",
110 .type = REG_DWORD,
111 },
112 { .type = REG_NONE }
113 };
114
115 /****************************************************************
116 ****************************************************************/
117
118 static struct gp_extension *get_extension_by_name(struct gp_extension *be,
119 const char *name)
120 {
121 struct gp_extension *b;
122
123 for (b = be; b; b = b->next) {
124 if (strequal(b->name, name)) {
125 return b;
126 }
127 }
128
129 return NULL;
130 }
131
132 /****************************************************************
133 ****************************************************************/
134
135 static struct gp_extension_methods *get_methods_by_name(struct gp_extension *be,
136 const char *name)
137 {
138 struct gp_extension *b;
139
140 for (b = be; b; b = b->next) {
141 if (strequal(b->name, name)) {
142 return b->methods;
143 }
144 }
145
146 return NULL;
147 }
148
149 /****************************************************************
150 ****************************************************************/
151
152 NTSTATUS gpext_unregister_gp_extension(const char *name)
153 {
154 struct gp_extension *ext;
155
156 ext = get_extension_by_name(extensions, name);
157 if (!ext) {
158 return NT_STATUS_OK;
159 }
160
161 DLIST_REMOVE(extensions, ext);
162 talloc_free(ext);
163
164 DEBUG(2,("Successfully removed GP extension '%s'\n", name));
165
166 return NT_STATUS_OK;
167 }
168
169 /****************************************************************
170 ****************************************************************/
171
172 NTSTATUS gpext_register_gp_extension(TALLOC_CTX *gpext_ctx,
173 int version,
174 const char *name,
175 const char *guid,
176 struct gp_extension_methods *methods)
177 {
178 struct gp_extension_methods *test;
179 struct gp_extension *entry;
180 NTSTATUS status;
181
182 if (!gpext_ctx) {
183 return NT_STATUS_INTERNAL_DB_ERROR;
184 }
185
186 if ((version != SMB_GPEXT_INTERFACE_VERSION)) {
187 DEBUG(0,("Failed to register gp extension.\n"
188 "The module was compiled against "
189 "SMB_GPEXT_INTERFACE_VERSION %d,\n"
190 "current SMB_GPEXT_INTERFACE_VERSION is %d.\n"
191 "Please recompile against the current "
192 "version of samba!\n",
193 version, SMB_GPEXT_INTERFACE_VERSION));
194 return NT_STATUS_OBJECT_TYPE_MISMATCH;
195 }
196
197 if (!guid || !name || !name[0] || !methods) {
198 DEBUG(0,("Called with NULL pointer or empty name!\n"));
199 return NT_STATUS_INVALID_PARAMETER;
200 }
201
202 test = get_methods_by_name(extensions, name);
203 if (test) {
204 DEBUG(0,("GP extension module %s already registered!\n",
205 name));
206 return NT_STATUS_OBJECT_NAME_COLLISION;
207 }
208
209 entry = talloc_zero(gpext_ctx, struct gp_extension);
210 NT_STATUS_HAVE_NO_MEMORY(entry);
211
212 entry->name = talloc_strdup(gpext_ctx, name);
213 NT_STATUS_HAVE_NO_MEMORY(entry->name);
214
215 entry->guid = talloc_zero(gpext_ctx, struct GUID);
216 NT_STATUS_HAVE_NO_MEMORY(entry->guid);
217 status = GUID_from_string(guid, entry->guid);
218 NT_STATUS_NOT_OK_RETURN(status);
219
220 entry->methods = methods;
221 DLIST_ADD(extensions, entry);
222
223 DEBUG(2,("Successfully added GP extension '%s' %s\n",
224 name, GUID_string2(gpext_ctx, entry->guid)));
225
226 return NT_STATUS_OK;
227 }
228
229 /****************************************************************
230 ****************************************************************/
231
232 static NTSTATUS gp_extension_init_module(TALLOC_CTX *mem_ctx,
233 const char *name,
234 struct gp_extension **gpext)
235 {
236 NTSTATUS status;
237 struct gp_extension *ext = NULL;
238
239 ext = talloc_zero(mem_ctx, struct gp_extension);
240 NT_STATUS_HAVE_NO_MEMORY(gpext);
241
242 ext->methods = get_methods_by_name(extensions, name);
243 if (!ext->methods) {
244
245 status = smb_probe_module(SAMBA_SUBSYSTEM_GPEXT,
246 name);
247 if (!NT_STATUS_IS_OK(status)) {
248 return status;
249 }
250
251 ext->methods = get_methods_by_name(extensions, name);
252 if (!ext->methods) {
253 return NT_STATUS_DLL_INIT_FAILED;
254 }
255 }
256
257 *gpext = ext;
258
259 return NT_STATUS_OK;
260 }
261
262 /****************************************************************
263 ****************************************************************/
264
265 static bool add_gp_extension_reg_entry_to_array(TALLOC_CTX *mem_ctx,
266 struct gp_extension_reg_entry *entry,
267 struct gp_extension_reg_entry **entries,
268 size_t *num)
269 {
270 *entries = talloc_realloc(mem_ctx, *entries,
271 struct gp_extension_reg_entry,
272 (*num)+1);
273 if (*entries == NULL) {
274 *num = 0;
275 return false;
276 }
277
278 (*entries)[*num].value = entry->value;
279 (*entries)[*num].data = entry->data;
280
281 *num += 1;
282 return true;
283 }
284
285 /****************************************************************
286 ****************************************************************/
287
288 static bool add_gp_extension_reg_info_entry_to_array(TALLOC_CTX *mem_ctx,
289 struct gp_extension_reg_info_entry *entry,
290 struct gp_extension_reg_info_entry **entries,
291 size_t *num)
292 {
293 *entries = talloc_realloc(mem_ctx, *entries,
294 struct gp_extension_reg_info_entry,
295 (*num)+1);
296 if (*entries == NULL) {
297 *num = 0;
298 return false;
299 }
300
301 (*entries)[*num].guid = entry->guid;
302 (*entries)[*num].num_entries = entry->num_entries;
303 (*entries)[*num].entries = entry->entries;
304
305 *num += 1;
306 return true;
307 }
308
309 /****************************************************************
310 ****************************************************************/
311
312 static NTSTATUS gp_ext_info_add_reg(TALLOC_CTX *mem_ctx,
313 struct gp_extension_reg_info_entry *entry,
314 const char *value,
315 enum winreg_Type type,
316 const char *data_s)
317 {
318 struct gp_extension_reg_entry *reg_entry = NULL;
319 struct registry_value *data = NULL;
320
321 reg_entry = talloc_zero(mem_ctx, struct gp_extension_reg_entry);
322 NT_STATUS_HAVE_NO_MEMORY(reg_entry);
323
324 data = talloc_zero(mem_ctx, struct registry_value);
325 NT_STATUS_HAVE_NO_MEMORY(data);
326
327 data->type = type;
328
329 switch (type) {
330 case REG_SZ:
331 case REG_EXPAND_SZ:
332 if (!push_reg_sz(mem_ctx, &data->data, data_s)) {
333 return NT_STATUS_NO_MEMORY;
334 }
335 break;
336 case REG_DWORD: {
337 uint32_t v = atoi(data_s);
338 data->data = data_blob_talloc(mem_ctx, NULL, 4);
339 SIVAL(data->data.data, 0, v);
340 break;
341 }
342 default:
343 return NT_STATUS_NOT_SUPPORTED;
344 }
345
346 reg_entry->value = value;
347 reg_entry->data = data;
348
349 if (!add_gp_extension_reg_entry_to_array(mem_ctx, reg_entry,
350 &entry->entries,
351 &entry->num_entries)) {
352 return NT_STATUS_NO_MEMORY;
353 }
354
355 return NT_STATUS_OK;
356 }
357
358 /****************************************************************
359 ****************************************************************/
360
361 static NTSTATUS gp_ext_info_add_reg_table(TALLOC_CTX *mem_ctx,
362 const char *module,
363 struct gp_extension_reg_info_entry *entry,
364 struct gp_extension_reg_table *table)
365 {
366 NTSTATUS status;
367 const char *module_name = NULL;
368 int i;
369
370 module_name = talloc_asprintf(mem_ctx, "%s.%s", module, shlib_ext());
371 NT_STATUS_HAVE_NO_MEMORY(module_name);
372
373 status = gp_ext_info_add_reg(mem_ctx, entry,
374 "DllName", REG_EXPAND_SZ, module_name);
375 NT_STATUS_NOT_OK_RETURN(status);
376
377 for (i=0; table[i].val; i++) {
378 status = gp_ext_info_add_reg(mem_ctx, entry,
379 table[i].val,
380 table[i].type,
381 table[i].data);
382 NT_STATUS_NOT_OK_RETURN(status);
383 }
384
385 return status;
386 }
387
388 /****************************************************************
389 ****************************************************************/
390
391 NTSTATUS gpext_info_add_entry(TALLOC_CTX *mem_ctx,
392 const char *module,
393 const char *ext_guid,
394 struct gp_extension_reg_table *table,
395 struct gp_extension_reg_info *info)
396 {
397 NTSTATUS status;
398 struct gp_extension_reg_info_entry *entry = NULL;
399
400 entry = talloc_zero(mem_ctx, struct gp_extension_reg_info_entry);
401 NT_STATUS_HAVE_NO_MEMORY(entry);
402
403 status = GUID_from_string(ext_guid, &entry->guid);
404 NT_STATUS_NOT_OK_RETURN(status);
405
406 status = gp_ext_info_add_reg_table(mem_ctx, module, entry, table);
407 NT_STATUS_NOT_OK_RETURN(status);
408
409 if (!add_gp_extension_reg_info_entry_to_array(mem_ctx, entry,
410 &info->entries,
411 &info->num_entries)) {
412 return NT_STATUS_NO_MEMORY;
413 }
414
415 return NT_STATUS_OK;
416 }
417
418 /****************************************************************
419 ****************************************************************/
420
421 static bool gp_extension_reg_info_verify_entry(struct gp_extension_reg_entry *entry)
422 {
423 int i;
424
425 for (i=0; gpext_reg_vals[i].val; i++) {
426
427 if ((strequal(entry->value, gpext_reg_vals[i].val)) &&
428 (entry->data->type == gpext_reg_vals[i].type)) {
429 return true;
430 }
431 }
432
433 return false;
434 }
435
436 /****************************************************************
437 ****************************************************************/
438
439 static bool gp_extension_reg_info_verify(struct gp_extension_reg_info_entry *entry)
440 {
441 int i;
442
443 for (i=0; i < entry->num_entries; i++) {
444 if (!gp_extension_reg_info_verify_entry(&entry->entries[i])) {
445 return false;
446 }
447 }
448
449 return true;
450 }
451
452 /****************************************************************
453 ****************************************************************/
454
455 static WERROR gp_extension_store_reg_vals(TALLOC_CTX *mem_ctx,
456 struct registry_key *key,
457 struct gp_extension_reg_info_entry *entry)
458 {
459 WERROR werr = WERR_OK;
460 size_t i;
461
462 for (i=0; i < entry->num_entries; i++) {
463
464 werr = reg_setvalue(key,
465 entry->entries[i].value,
466 entry->entries[i].data);
467 W_ERROR_NOT_OK_RETURN(werr);
468 }
469
470 return werr;
471 }
472
473 /****************************************************************
474 ****************************************************************/
475
476 static WERROR gp_extension_store_reg_entry(TALLOC_CTX *mem_ctx,
477 struct gp_registry_context *reg_ctx,
478 struct gp_extension_reg_info_entry *entry)
479 {
480 WERROR werr;
481 struct registry_key *key = NULL;
482 const char *subkeyname = NULL;
483
484 if (!gp_extension_reg_info_verify(entry)) {
485 return WERR_INVALID_PARAMETER;
486 }
487
488 subkeyname = GUID_string2(mem_ctx, &entry->guid);
489 W_ERROR_HAVE_NO_MEMORY(subkeyname);
490
491 if (!strupper_m(discard_const_p(char, subkeyname))) {
492 return WERR_INVALID_PARAMETER;
493 }
494
495 werr = gp_store_reg_subkey(mem_ctx,
496 subkeyname,
497 reg_ctx->curr_key,
498 &key);
499 W_ERROR_NOT_OK_RETURN(werr);
500
501 werr = gp_extension_store_reg_vals(mem_ctx,
502 key,
503 entry);
504 W_ERROR_NOT_OK_RETURN(werr);
505
506 return werr;
507 }
508
509 /****************************************************************
510 ****************************************************************/
511
512 static WERROR gp_extension_store_reg(TALLOC_CTX *mem_ctx,
513 struct gp_registry_context *reg_ctx,
514 struct gp_extension_reg_info *info)
515 {
516 WERROR werr = WERR_OK;
517 int i;
518
519 if (!info) {
520 return WERR_OK;
521 }
522
523 for (i=0; i < info->num_entries; i++) {
524 werr = gp_extension_store_reg_entry(mem_ctx,
525 reg_ctx,
526 &info->entries[i]);
527 W_ERROR_NOT_OK_RETURN(werr);
528 }
529
530 return werr;
531 }
532
533 /****************************************************************
534 ****************************************************************/
535
536 static NTSTATUS gp_glob_ext_list(TALLOC_CTX *mem_ctx,
537 const char ***ext_list,
538 size_t *ext_list_len)
539 {
540 DIR *dir = NULL;
541 struct dirent *dirent = NULL;
542
543 dir = opendir(modules_path(talloc_tos(),
544 SAMBA_SUBSYSTEM_GPEXT));
545 if (!dir) {
546 return map_nt_error_from_unix_common(errno);
547 }
548
549 while ((dirent = readdir(dir))) {
550
551 fstring name; /* forgive me... */
552 char *p;
553
554 if ((strequal(dirent->d_name, ".")) ||
555 (strequal(dirent->d_name, ".."))) {
556 continue;
557 }
558
559 p = strrchr(dirent->d_name, '.');
560 if (!p) {
561 closedir(dir);
562 return NT_STATUS_NO_MEMORY;
563 }
564
565 if (!strcsequal(p+1, shlib_ext())) {
566 DEBUG(10,("gp_glob_ext_list: not a *.so file: %s\n",
567 dirent->d_name));
568 continue;
569 }
570
571 fstrcpy(name, dirent->d_name);
572 name[PTR_DIFF(p, dirent->d_name)] = 0;
573
574 if (!add_string_to_array(mem_ctx, name, ext_list,
575 ext_list_len)) {
576 closedir(dir);
577 return NT_STATUS_NO_MEMORY;
578 }
579 }
580
581 closedir(dir);
582
583 return NT_STATUS_OK;
584 }
585
586 /****************************************************************
587 ****************************************************************/
588
589 NTSTATUS gpext_shutdown_gp_extensions(void)
590 {
591 struct gp_extension *ext = NULL;
592
593 for (ext = extensions; ext; ext = ext->next) {
594 if (ext->methods && ext->methods->shutdown) {
595 ext->methods->shutdown();
596 }
597 }
598
599 return NT_STATUS_OK;
600 }
601
602 /****************************************************************
603 ****************************************************************/
604
605 NTSTATUS gpext_init_gp_extensions(TALLOC_CTX *mem_ctx)
606 {
607 NTSTATUS status;
608 WERROR werr;
609 int i = 0;
610 const char **ext_array = NULL;
611 size_t ext_array_len = 0;
612 struct gp_extension *gpext = NULL;
613 struct gp_registry_context *reg_ctx = NULL;
614
615 if (gpext_get_gp_extension_list()) {
616 return NT_STATUS_OK;
617 }
618
619 status = gp_glob_ext_list(mem_ctx, &ext_array, &ext_array_len);
620 NT_STATUS_NOT_OK_RETURN(status);
621
622 for (i=0; i<ext_array_len; i++) {
623
624 struct gp_extension_reg_info *info = NULL;
625
626 status = gp_extension_init_module(mem_ctx, ext_array[i],
627 &gpext);
628 if (!NT_STATUS_IS_OK(status)) {
629 goto out;
630 }
631
632 if (gpext->methods->get_reg_config) {
633
634 status = gpext->methods->initialize(mem_ctx);
635 if (!NT_STATUS_IS_OK(status)) {
636 gpext->methods->shutdown();
637 goto out;
638 }
639
640 status = gpext->methods->get_reg_config(mem_ctx,
641 &info);
642 if (!NT_STATUS_IS_OK(status)) {
643 gpext->methods->shutdown();
644 goto out;
645 }
646
647 if (!reg_ctx) {
648 struct security_token *token;
649
650 token = registry_create_system_token(mem_ctx);
651 NT_STATUS_HAVE_NO_MEMORY(token);
652
653 werr = gp_init_reg_ctx(mem_ctx,
654 KEY_WINLOGON_GPEXT_PATH,
655 REG_KEY_WRITE,
656 token,
657 &reg_ctx);
658 if (!W_ERROR_IS_OK(werr)) {
659 status = werror_to_ntstatus(werr);
660 gpext->methods->shutdown();
661 goto out;
662 }
663 }
664
665 werr = gp_extension_store_reg(mem_ctx, reg_ctx, info);
666 if (!W_ERROR_IS_OK(werr)) {
667 DEBUG(1,("gp_extension_store_reg failed: %s\n",
668 win_errstr(werr)));
669 TALLOC_FREE(info);
670 gpext->methods->shutdown();
671 status = werror_to_ntstatus(werr);
672 goto out;
673 }
674 TALLOC_FREE(info);
675 }
676
677 }
678
679 out:
680 TALLOC_FREE(reg_ctx);
681
682 return status;
683 }
684
685 /****************************************************************
686 ****************************************************************/
687
688 NTSTATUS gpext_free_gp_extensions(void)
689 {
690 struct gp_extension *ext, *ext_next = NULL;
691
692 for (ext = extensions; ext; ext = ext_next) {
693 ext_next = ext->next;
694 DLIST_REMOVE(extensions, ext);
695 TALLOC_FREE(ext);
696 }
697
698 extensions = NULL;
699
700 return NT_STATUS_OK;
701 }
702
703 /****************************************************************
704 ****************************************************************/
705
706 void gpext_debug_header(int lvl,
707 const char *name,
708 uint32_t flags,
709 const struct GROUP_POLICY_OBJECT *gpo,
710 const char *extension_guid,
711 const char *snapin_guid)
712 {
713 char *flags_str = NULL;
714
715 DEBUG(lvl,("%s\n", name));
716 DEBUGADD(lvl,("\tgpo: %s (%s)\n", gpo->name,
717 gpo->display_name));
718 DEBUGADD(lvl,("\tcse extension: %s (%s)\n", extension_guid,
719 cse_gpo_guid_string_to_name(extension_guid)));
720 DEBUGADD(lvl,("\tgplink: %s\n", gpo->link));
721 DEBUGADD(lvl,("\tsnapin: %s (%s)\n", snapin_guid,
722 cse_snapin_gpo_guid_string_to_name(snapin_guid)));
723
724 flags_str = gpo_flag_str(NULL, flags);
725 DEBUGADD(lvl,("\tflags: 0x%08x %s\n", flags, flags_str));
726 TALLOC_FREE(flags_str);
727 }
728
729 /****************************************************************
730 ****************************************************************/
731
732 static NTSTATUS gpext_check_gpo_for_gpext_presence(TALLOC_CTX *mem_ctx,
733 uint32_t flags,
734 const struct GROUP_POLICY_OBJECT *gpo,
735 const struct GUID *guid,
736 bool *gpext_guid_present)
737 {
738 struct GP_EXT *gp_ext = NULL;
739 int i;
740 bool ok;
741
742 *gpext_guid_present = false;
743
744
745 if (gpo->link_type == GP_LINK_LOCAL) {
746 return NT_STATUS_OK;
747 }
748
749 ok = gpo_get_gp_ext_from_gpo(mem_ctx, flags, gpo, &gp_ext);
750 if (!ok) {
751 return NT_STATUS_INVALID_PARAMETER;
752 }
753
754 if (gp_ext == NULL) {
755 return NT_STATUS_OK;
756 }
757
758 for (i = 0; i < gp_ext->num_exts; i++) {
759 struct GUID guid2;
760 NTSTATUS status;
761
762 status = GUID_from_string(gp_ext->extensions_guid[i], &guid2);
763 if (!NT_STATUS_IS_OK(status)) {
764 return status;
765 }
766 if (GUID_equal(guid, &guid2)) {
767 *gpext_guid_present = true;
768 return NT_STATUS_OK;
769 }
770 }
771
772 return NT_STATUS_OK;
773 }
774
775 /****************************************************************
776 ****************************************************************/
777
778 NTSTATUS gpext_process_extension(TALLOC_CTX *mem_ctx,
779 uint32_t flags,
780 const struct security_token *token,
781 struct registry_key *root_key,
782 const struct GROUP_POLICY_OBJECT *deleted_gpo_list,
783 const struct GROUP_POLICY_OBJECT *changed_gpo_list,
784 const char *extension_guid_filter)
785 {
786 NTSTATUS status;
787 struct gp_extension *ext = NULL;
788 const struct GROUP_POLICY_OBJECT *gpo;
789 struct GUID extension_guid_filter_guid;
790
791 status = gpext_init_gp_extensions(mem_ctx);
792 if (!NT_STATUS_IS_OK(status)) {
793 DEBUG(1,("gpext_init_gp_extensions failed: %s\n",
794 nt_errstr(status)));
795 return status;
796 }
797
798 if (extension_guid_filter) {
799 status = GUID_from_string(extension_guid_filter,
800 &extension_guid_filter_guid);
801 if (!NT_STATUS_IS_OK(status)) {
802 return status;
803 }
804 }
805
806 for (ext = extensions; ext; ext = ext->next) {
807
808 struct GROUP_POLICY_OBJECT *deleted_gpo_list_filtered = NULL;
809 struct GROUP_POLICY_OBJECT *changed_gpo_list_filtered = NULL;
810
811 if (extension_guid_filter) {
812 if (!GUID_equal(&extension_guid_filter_guid, ext->guid)) {
813 continue;
814 }
815 }
816
817 for (gpo = deleted_gpo_list; gpo; gpo = gpo->next) {
818
819 bool is_present = false;
820
821 status = gpext_check_gpo_for_gpext_presence(mem_ctx,
822 flags,
823 gpo,
824 ext->guid,
825 &is_present);
826 if (!NT_STATUS_IS_OK(status)) {
827 return status;
828 }
829
830 if (is_present) {
831 struct GROUP_POLICY_OBJECT *new_gpo;
832
833 status = gpo_copy(mem_ctx, gpo, &new_gpo);
834 if (!NT_STATUS_IS_OK(status)) {
835 return status;
836 }
837
838 DLIST_ADD(deleted_gpo_list_filtered, new_gpo);
839 }
840 }
841
842 for (gpo = changed_gpo_list; gpo; gpo = gpo->next) {
843
844 bool is_present = false;
845
846 status = gpext_check_gpo_for_gpext_presence(mem_ctx,
847 flags,
848 gpo,
849 ext->guid,
850 &is_present);
851 if (!NT_STATUS_IS_OK(status)) {
852 return status;
853 }
854
855 if (is_present) {
856 struct GROUP_POLICY_OBJECT *new_gpo;
857
858 status = gpo_copy(mem_ctx, gpo, &new_gpo);
859 if (!NT_STATUS_IS_OK(status)) {
860 return status;
861 }
862
863 DLIST_ADD(changed_gpo_list_filtered, new_gpo);
864 }
865 }
866
867 status = ext->methods->initialize(mem_ctx);
868 NT_STATUS_NOT_OK_RETURN(status);
869
870 status = ext->methods->process_group_policy(mem_ctx,
871 flags,
872 root_key,
873 token,
874 deleted_gpo_list_filtered,
875 changed_gpo_list_filtered);
876 if (!NT_STATUS_IS_OK(status)) {
877 ext->methods->shutdown();
878 }
879 }
880
881 return status;
882 }