2 * Unix SMB/CIFS implementation.
4 * Copyright (C) Guenther Deschner 2007-2008
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.
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.
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/>.
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 #if _SAMBA_BUILD_ == 3
26 #include "libgpo/gpo_proto.h"
30 static struct gp_extension *extensions = NULL;
32 /****************************************************************
33 ****************************************************************/
35 struct gp_extension *get_gp_extension_list(void)
40 /****************************************************************
41 ****************************************************************/
43 /* see http://support.microsoft.com/kb/216358/en-us/ for more info */
45 struct gp_extension_reg_table gpext_reg_vals[] = {
46 { "DllName", REG_EXPAND_SZ },
47 { "ProcessGroupPolicy", REG_SZ },
48 { "NoMachinePolicy", REG_DWORD },
49 { "NoUserPolicy", REG_DWORD },
50 { "NoSlowLink", REG_DWORD },
51 { "NoBackgroundPolicy", REG_DWORD },
52 { "NoGPOListChanges", REG_DWORD },
53 { "PerUserLocalSettings", REG_DWORD },
54 { "RequiresSuccessfulRegistry", REG_DWORD },
55 { "EnableAsynchronousProcessing", REG_DWORD },
56 { "ExtensionDebugLevel", REG_DWORD },
58 { "GenerateGroupPolicy", REG_SZ }, /* not supported on w2k */
59 { "NotifyLinkTransition", REG_DWORD },
60 { "ProcessGroupPolicyEx", REG_SZ }, /* not supported on w2k */
61 { "ExtensionEventSource", REG_MULTI_SZ }, /* not supported on w2k */
62 { "GenerateGroupPolicy", REG_SZ },
63 { "MaxNoGPOListChangesInterval", REG_DWORD },
67 /****************************************************************
68 ****************************************************************/
70 static struct gp_extension *get_extension_by_name(struct gp_extension *be,
73 struct gp_extension *b;
75 for (b = be; b; b = b->next) {
76 if (strequal(b->name, name)) {
84 /****************************************************************
85 ****************************************************************/
87 static struct gp_extension_methods *get_methods_by_name(struct gp_extension *be,
90 struct gp_extension *b;
92 for (b = be; b; b = b->next) {
93 if (strequal(b->name, name)) {
101 /****************************************************************
102 ****************************************************************/
104 NTSTATUS unregister_gp_extension(const char *name)
106 struct gp_extension *ext;
108 ext = get_extension_by_name(extensions, name);
113 DLIST_REMOVE(extensions, ext);
116 DEBUG(2,("Successfully removed GP extension '%s'\n", name));
121 /****************************************************************
122 ****************************************************************/
124 NTSTATUS register_gp_extension(TALLOC_CTX *gpext_ctx,
128 struct gp_extension_methods *methods)
130 struct gp_extension_methods *test;
131 struct gp_extension *entry;
135 return NT_STATUS_INTERNAL_DB_ERROR;
138 if ((version != SMB_GPEXT_INTERFACE_VERSION)) {
139 DEBUG(0,("Failed to register gp extension.\n"
140 "The module was compiled against "
141 "SMB_GPEXT_INTERFACE_VERSION %d,\n"
142 "current SMB_GPEXT_INTERFACE_VERSION is %d.\n"
143 "Please recompile against the current "
144 "version of samba!\n",
145 version, SMB_GPEXT_INTERFACE_VERSION));
146 return NT_STATUS_OBJECT_TYPE_MISMATCH;
149 if (!guid || !name || !name[0] || !methods) {
150 DEBUG(0,("Called with NULL pointer or empty name!\n"));
151 return NT_STATUS_INVALID_PARAMETER;
154 test = get_methods_by_name(extensions, name);
156 DEBUG(0,("GP extension module %s already registered!\n",
158 return NT_STATUS_OBJECT_NAME_COLLISION;
161 entry = talloc_zero(gpext_ctx, struct gp_extension);
162 NT_STATUS_HAVE_NO_MEMORY(entry);
164 entry->name = talloc_strdup(gpext_ctx, name);
165 NT_STATUS_HAVE_NO_MEMORY(entry->name);
167 entry->guid = talloc_zero(gpext_ctx, struct GUID);
168 NT_STATUS_HAVE_NO_MEMORY(entry->guid);
169 status = GUID_from_string(guid, entry->guid);
170 NT_STATUS_NOT_OK_RETURN(status);
172 entry->methods = methods;
173 DLIST_ADD(extensions, entry);
175 DEBUG(2,("Successfully added GP extension '%s' %s\n",
176 name, GUID_string2(gpext_ctx, entry->guid)));
181 /****************************************************************
182 ****************************************************************/
184 static NTSTATUS gp_extension_init_module(TALLOC_CTX *mem_ctx,
186 struct gp_extension **gpext)
189 struct gp_extension *ext = NULL;
191 ext = talloc_zero(mem_ctx, struct gp_extension);
192 NT_STATUS_HAVE_NO_MEMORY(gpext);
194 ext->methods = get_methods_by_name(extensions, name);
197 status = smb_probe_module(SAMBA_SUBSYSTEM_GPEXT,
199 if (!NT_STATUS_IS_OK(status)) {
203 ext->methods = get_methods_by_name(extensions, name);
205 return NT_STATUS_DLL_INIT_FAILED;
214 /****************************************************************
215 ****************************************************************/
217 static bool add_gp_extension_reg_entry_to_array(TALLOC_CTX *mem_ctx,
218 struct gp_extension_reg_entry *entry,
219 struct gp_extension_reg_entry **entries,
222 *entries = talloc_realloc(mem_ctx, *entries,
223 struct gp_extension_reg_entry,
225 if (*entries == NULL) {
230 (*entries)[*num].value = entry->value;
231 (*entries)[*num].data = entry->data;
237 /****************************************************************
238 ****************************************************************/
240 static bool add_gp_extension_reg_info_entry_to_array(TALLOC_CTX *mem_ctx,
241 struct gp_extension_reg_info_entry *entry,
242 struct gp_extension_reg_info_entry **entries,
245 *entries = talloc_realloc(mem_ctx, *entries,
246 struct gp_extension_reg_info_entry,
248 if (*entries == NULL) {
253 (*entries)[*num].guid = entry->guid;
254 (*entries)[*num].num_entries = entry->num_entries;
255 (*entries)[*num].entries = entry->entries;
261 /****************************************************************
262 ****************************************************************/
264 static NTSTATUS gp_ext_info_add_reg(TALLOC_CTX *mem_ctx,
265 struct gp_extension_reg_info_entry *entry,
267 enum winreg_Type type,
270 struct gp_extension_reg_entry *reg_entry = NULL;
271 struct registry_value *data = NULL;
273 reg_entry = talloc_zero(mem_ctx, struct gp_extension_reg_entry);
274 NT_STATUS_HAVE_NO_MEMORY(reg_entry);
276 data = talloc_zero(mem_ctx, struct registry_value);
277 NT_STATUS_HAVE_NO_MEMORY(data);
284 data->v.sz.str = talloc_strdup(mem_ctx, data_s);
285 NT_STATUS_HAVE_NO_MEMORY(data->v.sz.str);
286 data->v.sz.len = strlen(data_s);
289 data->v.dword = atoi(data_s);
292 return NT_STATUS_NOT_SUPPORTED;
295 reg_entry->value = value;
296 reg_entry->data = data;
298 if (!add_gp_extension_reg_entry_to_array(mem_ctx, reg_entry,
300 &entry->num_entries)) {
301 return NT_STATUS_NO_MEMORY;
307 /****************************************************************
308 ****************************************************************/
310 static NTSTATUS gp_ext_info_add_reg_table(TALLOC_CTX *mem_ctx,
312 struct gp_extension_reg_info_entry *entry,
313 struct gp_extension_reg_table *table)
316 const char *module_name = NULL;
319 module_name = talloc_asprintf(mem_ctx, "%s.%s", module, shlib_ext());
320 NT_STATUS_HAVE_NO_MEMORY(module_name);
322 status = gp_ext_info_add_reg(mem_ctx, entry,
323 "DllName", REG_EXPAND_SZ, module_name);
324 NT_STATUS_NOT_OK_RETURN(status);
326 for (i=0; table[i].val; i++) {
327 status = gp_ext_info_add_reg(mem_ctx, entry,
331 NT_STATUS_NOT_OK_RETURN(status);
337 /****************************************************************
338 ****************************************************************/
340 NTSTATUS gp_ext_info_add_entry(TALLOC_CTX *mem_ctx,
342 const char *ext_guid,
343 struct gp_extension_reg_table *table,
344 struct gp_extension_reg_info *info)
347 struct gp_extension_reg_info_entry *entry = NULL;
349 entry = TALLOC_ZERO_P(mem_ctx, struct gp_extension_reg_info_entry);
350 NT_STATUS_HAVE_NO_MEMORY(entry);
352 status = GUID_from_string(ext_guid, &entry->guid);
353 NT_STATUS_NOT_OK_RETURN(status);
355 status = gp_ext_info_add_reg_table(mem_ctx, module, entry, table);
356 NT_STATUS_NOT_OK_RETURN(status);
358 if (!add_gp_extension_reg_info_entry_to_array(mem_ctx, entry,
360 &info->num_entries)) {
361 return NT_STATUS_NO_MEMORY;
367 /****************************************************************
368 ****************************************************************/
370 static bool gp_extension_reg_info_verify_entry(struct gp_extension_reg_entry *entry)
374 for (i=0; gpext_reg_vals[i].val; i++) {
376 if ((strequal(entry->value, gpext_reg_vals[i].val)) &&
377 (entry->data->type == gpext_reg_vals[i].type)) {
385 /****************************************************************
386 ****************************************************************/
388 static bool gp_extension_reg_info_verify(struct gp_extension_reg_info_entry *entry)
392 for (i=0; i < entry->num_entries; i++) {
393 if (!gp_extension_reg_info_verify_entry(&entry->entries[i])) {
401 /****************************************************************
402 ****************************************************************/
404 static WERROR gp_extension_store_reg_vals(TALLOC_CTX *mem_ctx,
405 struct registry_key *key,
406 struct gp_extension_reg_info_entry *entry)
408 WERROR werr = WERR_OK;
411 for (i=0; i < entry->num_entries; i++) {
413 werr = reg_setvalue(key,
414 entry->entries[i].value,
415 entry->entries[i].data);
416 W_ERROR_NOT_OK_RETURN(werr);
422 /****************************************************************
423 ****************************************************************/
425 static WERROR gp_extension_store_reg_entry(TALLOC_CTX *mem_ctx,
426 struct gp_registry_context *reg_ctx,
427 struct gp_extension_reg_info_entry *entry)
430 struct registry_key *key = NULL;
431 const char *subkeyname = NULL;
433 if (!gp_extension_reg_info_verify(entry)) {
434 return WERR_INVALID_PARAM;
437 subkeyname = GUID_string2(mem_ctx, &entry->guid);
438 W_ERROR_HAVE_NO_MEMORY(subkeyname);
440 strupper_m(CONST_DISCARD(char *,subkeyname));
442 werr = gp_store_reg_subkey(mem_ctx,
446 W_ERROR_NOT_OK_RETURN(werr);
448 werr = gp_extension_store_reg_vals(mem_ctx,
451 W_ERROR_NOT_OK_RETURN(werr);
456 /****************************************************************
457 ****************************************************************/
459 static WERROR gp_extension_store_reg(TALLOC_CTX *mem_ctx,
460 struct gp_registry_context *reg_ctx,
461 struct gp_extension_reg_info *info)
463 WERROR werr = WERR_OK;
470 for (i=0; i < info->num_entries; i++) {
471 werr = gp_extension_store_reg_entry(mem_ctx,
474 W_ERROR_NOT_OK_RETURN(werr);
480 /****************************************************************
481 ****************************************************************/
483 static NTSTATUS gp_glob_ext_list(TALLOC_CTX *mem_ctx,
484 const char ***ext_list,
485 size_t *ext_list_len)
487 SMB_STRUCT_DIR *dir = NULL;
488 SMB_STRUCT_DIRENT *dirent = NULL;
490 dir = sys_opendir(modules_path(SAMBA_SUBSYSTEM_GPEXT));
492 return map_nt_error_from_unix(errno);
495 while ((dirent = sys_readdir(dir))) {
497 fstring name; /* forgive me... */
500 if ((strequal(dirent->d_name, ".")) ||
501 (strequal(dirent->d_name, ".."))) {
505 p = strrchr(dirent->d_name, '.');
508 return NT_STATUS_NO_MEMORY;
511 if (!strcsequal(p+1, shlib_ext())) {
512 DEBUG(10,("gp_glob_ext_list: not a *.so file: %s\n",
517 fstrcpy(name, dirent->d_name);
518 name[PTR_DIFF(p, dirent->d_name)] = 0;
520 if (!add_string_to_array(mem_ctx, name, ext_list,
521 (int *)ext_list_len)) {
523 return NT_STATUS_NO_MEMORY;
532 /****************************************************************
533 ****************************************************************/
535 NTSTATUS shutdown_gp_extensions(void)
537 struct gp_extension *ext = NULL;
539 for (ext = extensions; ext; ext = ext->next) {
540 if (ext->methods && ext->methods->shutdown) {
541 ext->methods->shutdown();
548 /****************************************************************
549 ****************************************************************/
551 NTSTATUS init_gp_extensions(TALLOC_CTX *mem_ctx)
556 const char **ext_array = NULL;
557 size_t ext_array_len = 0;
558 struct gp_extension *gpext = NULL;
559 struct gp_registry_context *reg_ctx = NULL;
561 if (get_gp_extension_list()) {
565 status = gp_glob_ext_list(mem_ctx, &ext_array, &ext_array_len);
566 NT_STATUS_NOT_OK_RETURN(status);
568 for (i=0; i<ext_array_len; i++) {
570 struct gp_extension_reg_info *info = NULL;
572 status = gp_extension_init_module(mem_ctx, ext_array[i],
574 if (!NT_STATUS_IS_OK(status)) {
578 if (gpext->methods->get_reg_config) {
580 status = gpext->methods->initialize(mem_ctx);
581 if (!NT_STATUS_IS_OK(status)) {
582 gpext->methods->shutdown();
586 status = gpext->methods->get_reg_config(mem_ctx,
588 if (!NT_STATUS_IS_OK(status)) {
589 gpext->methods->shutdown();
594 NT_USER_TOKEN *token;
596 token = registry_create_system_token(mem_ctx);
597 NT_STATUS_HAVE_NO_MEMORY(token);
599 werr = gp_init_reg_ctx(mem_ctx,
600 KEY_WINLOGON_GPEXT_PATH,
604 if (!W_ERROR_IS_OK(werr)) {
605 status = werror_to_ntstatus(werr);
606 gpext->methods->shutdown();
611 werr = gp_extension_store_reg(mem_ctx, reg_ctx, info);
612 if (!W_ERROR_IS_OK(werr)) {
613 DEBUG(1,("gp_extension_store_reg failed: %s\n",
616 gpext->methods->shutdown();
617 status = werror_to_ntstatus(werr);
626 TALLOC_FREE(reg_ctx);
631 /****************************************************************
632 ****************************************************************/
634 NTSTATUS free_gp_extensions(void)
636 struct gp_extension *ext, *ext_next = NULL;
638 for (ext = extensions; ext; ext = ext_next) {
639 ext_next = ext->next;
640 DLIST_REMOVE(extensions, ext);
649 /****************************************************************
650 ****************************************************************/
652 void debug_gpext_header(int lvl,
655 struct GROUP_POLICY_OBJECT *gpo,
656 const char *extension_guid,
657 const char *snapin_guid)
659 char *flags_str = NULL;
661 DEBUG(lvl,("%s\n", name));
662 DEBUGADD(lvl,("\tgpo: %s (%s)\n", gpo->name,
664 DEBUGADD(lvl,("\tcse extension: %s (%s)\n", extension_guid,
665 cse_gpo_guid_string_to_name(extension_guid)));
666 DEBUGADD(lvl,("\tgplink: %s\n", gpo->link));
667 DEBUGADD(lvl,("\tsnapin: %s (%s)\n", snapin_guid,
668 cse_snapin_gpo_guid_string_to_name(snapin_guid)));
670 flags_str = gpo_flag_str(NULL, flags);
671 DEBUGADD(lvl,("\tflags: 0x%08x %s\n", flags, flags_str));
672 TALLOC_FREE(flags_str);
675 NTSTATUS process_gpo_list_with_extension(ADS_STRUCT *ads,
678 const NT_USER_TOKEN *token,
679 struct GROUP_POLICY_OBJECT *gpo_list,
680 const char *extension_guid,
681 const char *snapin_guid)
686 /****************************************************************
687 ****************************************************************/
689 NTSTATUS gpext_process_extension(ADS_STRUCT *ads,
692 const NT_USER_TOKEN *token,
693 struct registry_key *root_key,
694 struct GROUP_POLICY_OBJECT *gpo,
695 const char *extension_guid,
696 const char *snapin_guid)
699 struct gp_extension *ext = NULL;
701 bool cse_found = false;
703 status = init_gp_extensions(mem_ctx);
704 if (!NT_STATUS_IS_OK(status)) {
705 DEBUG(1,("init_gp_extensions failed: %s\n",
710 status = GUID_from_string(extension_guid, &guid);
711 if (!NT_STATUS_IS_OK(status)) {
715 for (ext = extensions; ext; ext = ext->next) {
717 if (GUID_equal(ext->guid, &guid)) {
727 status = ext->methods->initialize(mem_ctx);
728 NT_STATUS_NOT_OK_RETURN(status);
730 status = ext->methods->process_group_policy(ads,
738 if (!NT_STATUS_IS_OK(status)) {
739 ext->methods->shutdown();
745 if (flags & GPO_INFO_FLAG_VERBOSE) {
746 DEBUG(0,("process_extension: no extension available for:\n"));
747 DEBUGADD(0,("%s (%s) (snapin: %s)\n",
749 cse_gpo_guid_string_to_name(extension_guid),