f38d87358abc0085556e0440245e1bff07d91fd2
[sfrench/samba-autobuild/.git] / libgpo / gpext / gpext.c
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 #if _SAMBA_BUILD_ == 3
27 #include "libgpo/gpo_proto.h"
28 #include "registry.h"
29 #include "registry/reg_api.h"
30 #endif
31
32 static struct gp_extension *extensions = NULL;
33
34 /****************************************************************
35 ****************************************************************/
36
37 struct gp_extension *get_gp_extension_list(void)
38 {
39         return extensions;
40 }
41
42 /****************************************************************
43 ****************************************************************/
44
45 /* see http://support.microsoft.com/kb/216358/en-us/ for more info */
46
47 struct gp_extension_reg_table gpext_reg_vals[] = {
48         { "DllName", REG_EXPAND_SZ },
49         { "ProcessGroupPolicy", REG_SZ },
50         { "NoMachinePolicy", REG_DWORD },
51         { "NoUserPolicy", REG_DWORD },
52         { "NoSlowLink", REG_DWORD },
53         { "NoBackgroundPolicy", REG_DWORD },
54         { "NoGPOListChanges", REG_DWORD },
55         { "PerUserLocalSettings", REG_DWORD },
56         { "RequiresSuccessfulRegistry", REG_DWORD },
57         { "EnableAsynchronousProcessing", REG_DWORD },
58         { "ExtensionDebugLevel", REG_DWORD },
59         /* new */
60         { "GenerateGroupPolicy", REG_SZ }, /* not supported on w2k */
61         { "NotifyLinkTransition", REG_DWORD },
62         { "ProcessGroupPolicyEx", REG_SZ }, /* not supported on w2k */
63         { "ExtensionEventSource", REG_MULTI_SZ }, /* not supported on w2k */
64         { "GenerateGroupPolicy", REG_SZ },
65         { "MaxNoGPOListChangesInterval", REG_DWORD },
66         { NULL, REG_NONE }
67 };
68
69 /****************************************************************
70 ****************************************************************/
71
72 static struct gp_extension *get_extension_by_name(struct gp_extension *be,
73                                                   const char *name)
74 {
75         struct gp_extension *b;
76
77         for (b = be; b; b = b->next) {
78                 if (strequal(b->name, name)) {
79                         return b;
80                 }
81         }
82
83         return NULL;
84 }
85
86 /****************************************************************
87 ****************************************************************/
88
89 static struct gp_extension_methods *get_methods_by_name(struct gp_extension *be,
90                                                         const char *name)
91 {
92         struct gp_extension *b;
93
94         for (b = be; b; b = b->next) {
95                 if (strequal(b->name, name)) {
96                         return b->methods;
97                 }
98         }
99
100         return NULL;
101 }
102
103 /****************************************************************
104 ****************************************************************/
105
106 NTSTATUS unregister_gp_extension(const char *name)
107 {
108         struct gp_extension *ext;
109
110         ext = get_extension_by_name(extensions, name);
111         if (!ext) {
112                 return NT_STATUS_OK;
113         }
114
115         DLIST_REMOVE(extensions, ext);
116         talloc_free(ext);
117
118         DEBUG(2,("Successfully removed GP extension '%s'\n", name));
119
120         return NT_STATUS_OK;
121 }
122
123 /****************************************************************
124 ****************************************************************/
125
126 NTSTATUS register_gp_extension(TALLOC_CTX *gpext_ctx,
127                                int version,
128                                const char *name,
129                                const char *guid,
130                                struct gp_extension_methods *methods)
131 {
132         struct gp_extension_methods *test;
133         struct gp_extension *entry;
134         NTSTATUS status;
135
136         if (!gpext_ctx) {
137                 return NT_STATUS_INTERNAL_DB_ERROR;
138         }
139
140         if ((version != SMB_GPEXT_INTERFACE_VERSION)) {
141                 DEBUG(0,("Failed to register gp extension.\n"
142                          "The module was compiled against "
143                          "SMB_GPEXT_INTERFACE_VERSION %d,\n"
144                          "current SMB_GPEXT_INTERFACE_VERSION is %d.\n"
145                          "Please recompile against the current "
146                          "version of samba!\n",
147                          version, SMB_GPEXT_INTERFACE_VERSION));
148                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
149         }
150
151         if (!guid || !name || !name[0] || !methods) {
152                 DEBUG(0,("Called with NULL pointer or empty name!\n"));
153                 return NT_STATUS_INVALID_PARAMETER;
154         }
155
156         test = get_methods_by_name(extensions, name);
157         if (test) {
158                 DEBUG(0,("GP extension module %s already registered!\n",
159                         name));
160                 return NT_STATUS_OBJECT_NAME_COLLISION;
161         }
162
163         entry = talloc_zero(gpext_ctx, struct gp_extension);
164         NT_STATUS_HAVE_NO_MEMORY(entry);
165
166         entry->name = talloc_strdup(gpext_ctx, name);
167         NT_STATUS_HAVE_NO_MEMORY(entry->name);
168
169         entry->guid = talloc_zero(gpext_ctx, struct GUID);
170         NT_STATUS_HAVE_NO_MEMORY(entry->guid);
171         status = GUID_from_string(guid, entry->guid);
172         NT_STATUS_NOT_OK_RETURN(status);
173
174         entry->methods = methods;
175         DLIST_ADD(extensions, entry);
176
177         DEBUG(2,("Successfully added GP extension '%s' %s\n",
178                 name, GUID_string2(gpext_ctx, entry->guid)));
179
180         return NT_STATUS_OK;
181 }
182
183 /****************************************************************
184 ****************************************************************/
185
186 static NTSTATUS gp_extension_init_module(TALLOC_CTX *mem_ctx,
187                                          const char *name,
188                                          struct gp_extension **gpext)
189 {
190         NTSTATUS status;
191         struct gp_extension *ext = NULL;
192
193         ext = talloc_zero(mem_ctx, struct gp_extension);
194         NT_STATUS_HAVE_NO_MEMORY(gpext);
195
196         ext->methods = get_methods_by_name(extensions, name);
197         if (!ext->methods) {
198
199                 status = smb_probe_module(SAMBA_SUBSYSTEM_GPEXT,
200                                           name);
201                 if (!NT_STATUS_IS_OK(status)) {
202                         return status;
203                 }
204
205                 ext->methods = get_methods_by_name(extensions, name);
206                 if (!ext->methods) {
207                         return NT_STATUS_DLL_INIT_FAILED;
208                 }
209         }
210
211         *gpext = ext;
212
213         return NT_STATUS_OK;
214 }
215
216 /****************************************************************
217 ****************************************************************/
218
219 static bool add_gp_extension_reg_entry_to_array(TALLOC_CTX *mem_ctx,
220                                                 struct gp_extension_reg_entry *entry,
221                                                 struct gp_extension_reg_entry **entries,
222                                                 size_t *num)
223 {
224         *entries = talloc_realloc(mem_ctx, *entries,
225                                         struct gp_extension_reg_entry,
226                                         (*num)+1);
227         if (*entries == NULL) {
228                 *num = 0;
229                 return false;
230         }
231
232         (*entries)[*num].value = entry->value;
233         (*entries)[*num].data = entry->data;
234
235         *num += 1;
236         return true;
237 }
238
239 /****************************************************************
240 ****************************************************************/
241
242 static bool add_gp_extension_reg_info_entry_to_array(TALLOC_CTX *mem_ctx,
243                                                      struct gp_extension_reg_info_entry *entry,
244                                                      struct gp_extension_reg_info_entry **entries,
245                                                      size_t *num)
246 {
247         *entries = talloc_realloc(mem_ctx, *entries,
248                                         struct gp_extension_reg_info_entry,
249                                         (*num)+1);
250         if (*entries == NULL) {
251                 *num = 0;
252                 return false;
253         }
254
255         (*entries)[*num].guid = entry->guid;
256         (*entries)[*num].num_entries = entry->num_entries;
257         (*entries)[*num].entries = entry->entries;
258
259         *num += 1;
260         return true;
261 }
262
263 /****************************************************************
264 ****************************************************************/
265
266 static NTSTATUS gp_ext_info_add_reg(TALLOC_CTX *mem_ctx,
267                                     struct gp_extension_reg_info_entry *entry,
268                                     const char *value,
269                                     enum winreg_Type type,
270                                     const char *data_s)
271 {
272         struct gp_extension_reg_entry *reg_entry = NULL;
273         struct registry_value *data = NULL;
274
275         reg_entry = talloc_zero(mem_ctx, struct gp_extension_reg_entry);
276         NT_STATUS_HAVE_NO_MEMORY(reg_entry);
277
278         data = talloc_zero(mem_ctx, struct registry_value);
279         NT_STATUS_HAVE_NO_MEMORY(data);
280
281         data->type = type;
282
283         switch (type) {
284                 case REG_SZ:
285                 case REG_EXPAND_SZ:
286                         if (!push_reg_sz(mem_ctx, &data->data, data_s)) {
287                                 return NT_STATUS_NO_MEMORY;
288                         }
289                         break;
290                 case REG_DWORD: {
291                         uint32_t v = atoi(data_s);
292                         data->data = data_blob_talloc(mem_ctx, NULL, 4);
293                         SIVAL(data->data.data, 0, v);
294                         break;
295                 }
296                 default:
297                         return NT_STATUS_NOT_SUPPORTED;
298         }
299
300         reg_entry->value = value;
301         reg_entry->data = data;
302
303         if (!add_gp_extension_reg_entry_to_array(mem_ctx, reg_entry,
304                                                  &entry->entries,
305                                                  &entry->num_entries)) {
306                 return NT_STATUS_NO_MEMORY;
307         }
308
309         return NT_STATUS_OK;
310 }
311
312 /****************************************************************
313 ****************************************************************/
314
315 static NTSTATUS gp_ext_info_add_reg_table(TALLOC_CTX *mem_ctx,
316                                           const char *module,
317                                           struct gp_extension_reg_info_entry *entry,
318                                           struct gp_extension_reg_table *table)
319 {
320         NTSTATUS status;
321         const char *module_name = NULL;
322         int i;
323
324         module_name = talloc_asprintf(mem_ctx, "%s.%s", module, shlib_ext());
325         NT_STATUS_HAVE_NO_MEMORY(module_name);
326
327         status = gp_ext_info_add_reg(mem_ctx, entry,
328                                      "DllName", REG_EXPAND_SZ, module_name);
329         NT_STATUS_NOT_OK_RETURN(status);
330
331         for (i=0; table[i].val; i++) {
332                 status = gp_ext_info_add_reg(mem_ctx, entry,
333                                              table[i].val,
334                                              table[i].type,
335                                              table[i].data);
336                 NT_STATUS_NOT_OK_RETURN(status);
337         }
338
339         return status;
340 }
341
342 /****************************************************************
343 ****************************************************************/
344
345 NTSTATUS gp_ext_info_add_entry(TALLOC_CTX *mem_ctx,
346                                const char *module,
347                                const char *ext_guid,
348                                struct gp_extension_reg_table *table,
349                                struct gp_extension_reg_info *info)
350 {
351         NTSTATUS status;
352         struct gp_extension_reg_info_entry *entry = NULL;
353
354         entry = TALLOC_ZERO_P(mem_ctx, struct gp_extension_reg_info_entry);
355         NT_STATUS_HAVE_NO_MEMORY(entry);
356
357         status = GUID_from_string(ext_guid, &entry->guid);
358         NT_STATUS_NOT_OK_RETURN(status);
359
360         status = gp_ext_info_add_reg_table(mem_ctx, module, entry, table);
361         NT_STATUS_NOT_OK_RETURN(status);
362
363         if (!add_gp_extension_reg_info_entry_to_array(mem_ctx, entry,
364                                                       &info->entries,
365                                                       &info->num_entries)) {
366                 return NT_STATUS_NO_MEMORY;
367         }
368
369         return NT_STATUS_OK;
370 }
371
372 /****************************************************************
373 ****************************************************************/
374
375 static bool gp_extension_reg_info_verify_entry(struct gp_extension_reg_entry *entry)
376 {
377         int i;
378
379         for (i=0; gpext_reg_vals[i].val; i++) {
380
381                 if ((strequal(entry->value, gpext_reg_vals[i].val)) &&
382                     (entry->data->type == gpext_reg_vals[i].type)) {
383                         return true;
384                 }
385         }
386
387         return false;
388 }
389
390 /****************************************************************
391 ****************************************************************/
392
393 static bool gp_extension_reg_info_verify(struct gp_extension_reg_info_entry *entry)
394 {
395         int i;
396
397         for (i=0; i < entry->num_entries; i++) {
398                 if (!gp_extension_reg_info_verify_entry(&entry->entries[i])) {
399                         return false;
400                 }
401         }
402
403         return true;
404 }
405
406 /****************************************************************
407 ****************************************************************/
408
409 static WERROR gp_extension_store_reg_vals(TALLOC_CTX *mem_ctx,
410                                           struct registry_key *key,
411                                           struct gp_extension_reg_info_entry *entry)
412 {
413         WERROR werr = WERR_OK;
414         size_t i;
415
416         for (i=0; i < entry->num_entries; i++) {
417
418                 werr = reg_setvalue(key,
419                                     entry->entries[i].value,
420                                     entry->entries[i].data);
421                 W_ERROR_NOT_OK_RETURN(werr);
422         }
423
424         return werr;
425 }
426
427 /****************************************************************
428 ****************************************************************/
429
430 static WERROR gp_extension_store_reg_entry(TALLOC_CTX *mem_ctx,
431                                            struct gp_registry_context *reg_ctx,
432                                            struct gp_extension_reg_info_entry *entry)
433 {
434         WERROR werr;
435         struct registry_key *key = NULL;
436         const char *subkeyname = NULL;
437
438         if (!gp_extension_reg_info_verify(entry)) {
439                 return WERR_INVALID_PARAM;
440         }
441
442         subkeyname = GUID_string2(mem_ctx, &entry->guid);
443         W_ERROR_HAVE_NO_MEMORY(subkeyname);
444
445         strupper_m(discard_const_p(char, subkeyname));
446
447         werr = gp_store_reg_subkey(mem_ctx,
448                                    subkeyname,
449                                    reg_ctx->curr_key,
450                                    &key);
451         W_ERROR_NOT_OK_RETURN(werr);
452
453         werr = gp_extension_store_reg_vals(mem_ctx,
454                                            key,
455                                            entry);
456         W_ERROR_NOT_OK_RETURN(werr);
457
458         return werr;
459 }
460
461 /****************************************************************
462 ****************************************************************/
463
464 static WERROR gp_extension_store_reg(TALLOC_CTX *mem_ctx,
465                                      struct gp_registry_context *reg_ctx,
466                                      struct gp_extension_reg_info *info)
467 {
468         WERROR werr = WERR_OK;
469         int i;
470
471         if (!info) {
472                 return WERR_OK;
473         }
474
475         for (i=0; i < info->num_entries; i++) {
476                 werr = gp_extension_store_reg_entry(mem_ctx,
477                                                     reg_ctx,
478                                                     &info->entries[i]);
479                 W_ERROR_NOT_OK_RETURN(werr);
480         }
481
482         return werr;
483 }
484
485 /****************************************************************
486 ****************************************************************/
487
488 static NTSTATUS gp_glob_ext_list(TALLOC_CTX *mem_ctx,
489                                  const char ***ext_list,
490                                  size_t *ext_list_len)
491 {
492         SMB_STRUCT_DIR *dir = NULL;
493         SMB_STRUCT_DIRENT *dirent = NULL;
494
495         dir = sys_opendir(modules_path(SAMBA_SUBSYSTEM_GPEXT));
496         if (!dir) {
497                 return map_nt_error_from_unix(errno);
498         }
499
500         while ((dirent = sys_readdir(dir))) {
501
502                 fstring name; /* forgive me... */
503                 char *p;
504
505                 if ((strequal(dirent->d_name, ".")) ||
506                     (strequal(dirent->d_name, ".."))) {
507                         continue;
508                 }
509
510                 p = strrchr(dirent->d_name, '.');
511                 if (!p) {
512                         sys_closedir(dir);
513                         return NT_STATUS_NO_MEMORY;
514                 }
515
516                 if (!strcsequal(p+1, shlib_ext())) {
517                         DEBUG(10,("gp_glob_ext_list: not a *.so file: %s\n",
518                                 dirent->d_name));
519                         continue;
520                 }
521
522                 fstrcpy(name, dirent->d_name);
523                 name[PTR_DIFF(p, dirent->d_name)] = 0;
524
525                 if (!add_string_to_array(mem_ctx, name, ext_list,
526                                          (int *)ext_list_len)) {
527                         sys_closedir(dir);
528                         return NT_STATUS_NO_MEMORY;
529                 }
530         }
531
532         sys_closedir(dir);
533
534         return NT_STATUS_OK;
535 }
536
537 /****************************************************************
538 ****************************************************************/
539
540 NTSTATUS shutdown_gp_extensions(void)
541 {
542         struct gp_extension *ext = NULL;
543
544         for (ext = extensions; ext; ext = ext->next) {
545                 if (ext->methods && ext->methods->shutdown) {
546                         ext->methods->shutdown();
547                 }
548         }
549
550         return NT_STATUS_OK;
551 }
552
553 /****************************************************************
554 ****************************************************************/
555
556 NTSTATUS init_gp_extensions(TALLOC_CTX *mem_ctx)
557 {
558         NTSTATUS status;
559         WERROR werr;
560         int i = 0;
561         const char **ext_array = NULL;
562         size_t ext_array_len = 0;
563         struct gp_extension *gpext = NULL;
564         struct gp_registry_context *reg_ctx = NULL;
565
566         if (get_gp_extension_list()) {
567                 return NT_STATUS_OK;
568         }
569
570         status = gp_glob_ext_list(mem_ctx, &ext_array, &ext_array_len);
571         NT_STATUS_NOT_OK_RETURN(status);
572
573         for (i=0; i<ext_array_len; i++) {
574
575                 struct gp_extension_reg_info *info = NULL;
576
577                 status = gp_extension_init_module(mem_ctx, ext_array[i],
578                                                   &gpext);
579                 if (!NT_STATUS_IS_OK(status)) {
580                         goto out;
581                 }
582
583                 if (gpext->methods->get_reg_config) {
584
585                         status = gpext->methods->initialize(mem_ctx);
586                         if (!NT_STATUS_IS_OK(status)) {
587                                 gpext->methods->shutdown();
588                                 goto out;
589                         }
590
591                         status = gpext->methods->get_reg_config(mem_ctx,
592                                                                 &info);
593                         if (!NT_STATUS_IS_OK(status)) {
594                                 gpext->methods->shutdown();
595                                 goto out;
596                         }
597
598                         if (!reg_ctx) {
599                                 struct security_token *token;
600
601                                 token = registry_create_system_token(mem_ctx);
602                                 NT_STATUS_HAVE_NO_MEMORY(token);
603
604                                 werr = gp_init_reg_ctx(mem_ctx,
605                                                        KEY_WINLOGON_GPEXT_PATH,
606                                                        REG_KEY_WRITE,
607                                                        token,
608                                                        &reg_ctx);
609                                 if (!W_ERROR_IS_OK(werr)) {
610                                         status = werror_to_ntstatus(werr);
611                                         gpext->methods->shutdown();
612                                         goto out;
613                                 }
614                         }
615
616                         werr = gp_extension_store_reg(mem_ctx, reg_ctx, info);
617                         if (!W_ERROR_IS_OK(werr)) {
618                                 DEBUG(1,("gp_extension_store_reg failed: %s\n",
619                                         win_errstr(werr)));
620                                 TALLOC_FREE(info);
621                                 gpext->methods->shutdown();
622                                 status = werror_to_ntstatus(werr);
623                                 goto out;
624                         }
625                         TALLOC_FREE(info);
626                 }
627
628         }
629
630  out:
631         TALLOC_FREE(reg_ctx);
632
633         return status;
634 }
635
636 /****************************************************************
637 ****************************************************************/
638
639 NTSTATUS free_gp_extensions(void)
640 {
641         struct gp_extension *ext, *ext_next = NULL;
642
643         for (ext = extensions; ext; ext = ext_next) {
644                 ext_next = ext->next;
645                 DLIST_REMOVE(extensions, ext);
646                 TALLOC_FREE(ext);
647         }
648
649         extensions = NULL;
650
651         return NT_STATUS_OK;
652 }
653
654 /****************************************************************
655 ****************************************************************/
656
657 void debug_gpext_header(int lvl,
658                         const char *name,
659                         uint32_t flags,
660                         struct GROUP_POLICY_OBJECT *gpo,
661                         const char *extension_guid,
662                         const char *snapin_guid)
663 {
664         char *flags_str = NULL;
665
666         DEBUG(lvl,("%s\n", name));
667         DEBUGADD(lvl,("\tgpo:           %s (%s)\n", gpo->name,
668                 gpo->display_name));
669         DEBUGADD(lvl,("\tcse extension: %s (%s)\n", extension_guid,
670                 cse_gpo_guid_string_to_name(extension_guid)));
671         DEBUGADD(lvl,("\tgplink:        %s\n", gpo->link));
672         DEBUGADD(lvl,("\tsnapin:        %s (%s)\n", snapin_guid,
673                 cse_snapin_gpo_guid_string_to_name(snapin_guid)));
674
675         flags_str = gpo_flag_str(NULL, flags);
676         DEBUGADD(lvl,("\tflags:         0x%08x %s\n", flags, flags_str));
677         TALLOC_FREE(flags_str);
678 }
679
680 NTSTATUS process_gpo_list_with_extension(ADS_STRUCT *ads,
681                            TALLOC_CTX *mem_ctx,
682                            uint32_t flags,
683                            const struct security_token *token,
684                            struct GROUP_POLICY_OBJECT *gpo_list,
685                            const char *extension_guid,
686                            const char *snapin_guid)
687 {
688         return NT_STATUS_OK;
689 }
690
691 /****************************************************************
692 ****************************************************************/
693
694 NTSTATUS gpext_process_extension(ADS_STRUCT *ads,
695                                  TALLOC_CTX *mem_ctx,
696                                  uint32_t flags,
697                                  const struct security_token *token,
698                                  struct registry_key *root_key,
699                                  struct GROUP_POLICY_OBJECT *gpo,
700                                  const char *extension_guid,
701                                  const char *snapin_guid)
702 {
703         NTSTATUS status;
704         struct gp_extension *ext = NULL;
705         struct GUID guid;
706         bool cse_found = false;
707
708         status = init_gp_extensions(mem_ctx);
709         if (!NT_STATUS_IS_OK(status)) {
710                 DEBUG(1,("init_gp_extensions failed: %s\n",
711                         nt_errstr(status)));
712                 return status;
713         }
714
715         status = GUID_from_string(extension_guid, &guid);
716         if (!NT_STATUS_IS_OK(status)) {
717                 return status;
718         }
719
720         for (ext = extensions; ext; ext = ext->next) {
721
722                 if (GUID_equal(ext->guid, &guid)) {
723                         cse_found = true;
724                         break;
725                 }
726         }
727
728         if (!cse_found) {
729                 goto no_ext;
730         }
731
732         status = ext->methods->initialize(mem_ctx);
733         NT_STATUS_NOT_OK_RETURN(status);
734
735         status = ext->methods->process_group_policy(ads,
736                                                     mem_ctx,
737                                                     flags,
738                                                     root_key,
739                                                     token,
740                                                     gpo,
741                                                     extension_guid,
742                                                     snapin_guid);
743         if (!NT_STATUS_IS_OK(status)) {
744                 ext->methods->shutdown();
745         }
746
747         return status;
748
749  no_ext:
750         if (flags & GPO_INFO_FLAG_VERBOSE) {
751                 DEBUG(0,("process_extension: no extension available for:\n"));
752                 DEBUGADD(0,("%s (%s) (snapin: %s)\n",
753                         extension_guid,
754                         cse_gpo_guid_string_to_name(extension_guid),
755                         snapin_guid));
756         }
757
758         return NT_STATUS_OK;
759 }