2 * Unix SMB/CIFS implementation.
4 * Copyright (C) Guenther Deschner 2007-2008,2010
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_ini.h"
22 #include "../libgpo/gpo.h"
23 #include "libgpo/gpo_proto.h"
25 #include "../librpc/gen_ndr/ndr_preg.h"
26 #include "libgpo/gpext/gpext.h"
28 #define GP_EXT_NAME "registry"
30 /* more info can be found at:
31 * http://msdn2.microsoft.com/en-us/library/aa374407.aspx */
33 #define GP_REGPOL_FILE "Registry.pol"
35 #define GP_REGPOL_FILE_SIGNATURE 0x67655250 /* 'PReg' */
36 #define GP_REGPOL_FILE_VERSION 1
38 static TALLOC_CTX *ctx = NULL;
40 NTSTATUS gpext_registry_init(TALLOC_CTX *mem_ctx);
42 /****************************************************************
43 ****************************************************************/
45 static bool reg_parse_value(TALLOC_CTX *mem_ctx,
47 enum gp_reg_action *action)
50 *action = GP_REG_ACTION_ADD_KEY;
54 if (strncmp(*value, "**", 2) != 0) {
55 *action = GP_REG_ACTION_ADD_VALUE;
59 if (strnequal(*value, "**DelVals.", 10)) {
60 *action = GP_REG_ACTION_DEL_ALL_VALUES;
64 if (strnequal(*value, "**Del.", 6)) {
65 *value = talloc_strdup(mem_ctx, *value + 6);
66 *action = GP_REG_ACTION_DEL_VALUE;
70 if (strnequal(*value, "**SecureKey", 11)) {
71 if (strnequal(*value, "**SecureKey=1", 13)) {
72 *action = GP_REG_ACTION_SEC_KEY_SET;
76 /*************** not tested from here on ***************/
77 if (strnequal(*value, "**SecureKey=0", 13)) {
78 smb_panic("not supported: **SecureKey=0");
79 *action = GP_REG_ACTION_SEC_KEY_RESET;
82 DEBUG(0,("unknown: SecureKey: %s\n", *value));
83 smb_panic("not supported SecureKey method");
87 if (strnequal(*value, "**DeleteValues", strlen("**DeleteValues"))) {
88 smb_panic("not supported: **DeleteValues");
89 *action = GP_REG_ACTION_DEL_VALUES;
93 if (strnequal(*value, "**DeleteKeys", strlen("**DeleteKeys"))) {
94 smb_panic("not supported: **DeleteKeys");
95 *action = GP_REG_ACTION_DEL_KEYS;
99 DEBUG(0,("unknown value: %s\n", *value));
104 /****************************************************************
105 ****************************************************************/
107 static bool gp_reg_entry_from_file_entry(TALLOC_CTX *mem_ctx,
108 struct preg_entry *r,
109 struct gp_registry_entry **reg_entry)
111 struct registry_value *data = NULL;
112 struct gp_registry_entry *entry = NULL;
113 enum gp_reg_action action = GP_REG_ACTION_NONE;
114 enum ndr_err_code ndr_err;
116 ZERO_STRUCTP(*reg_entry);
118 data = talloc_zero(mem_ctx, struct registry_value);
122 data->type = r->type;
124 ndr_err = ndr_push_union_blob(
129 (ndr_push_flags_fn_t)ndr_push_winreg_Data);
130 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
131 DBG_WARNING("ndr_push_winreg_Data failed: %s\n",
132 ndr_errstr(ndr_err));
136 entry = talloc_zero(mem_ctx, struct gp_registry_entry);
140 if (!reg_parse_value(mem_ctx, &r->valuename, &action))
143 entry->key = talloc_strdup(entry, r->keyname);
144 entry->value = talloc_strdup(entry, r->valuename);
146 entry->action = action;
153 /****************************************************************
154 ****************************************************************/
156 static NTSTATUS reg_parse_registry(TALLOC_CTX *mem_ctx,
158 const char *filename,
159 struct gp_registry_entry **entries_p,
160 size_t *num_entries_p)
164 enum ndr_err_code ndr_err;
165 const char *real_filename = NULL;
167 struct gp_registry_entry *entries = NULL;
168 size_t num_entries = 0;
171 status = gp_find_file(mem_ctx,
176 if (!NT_STATUS_IS_OK(status)) {
180 blob.data = (uint8_t *)file_load(real_filename, &blob.length, 0, NULL);
182 return NT_STATUS_CANNOT_LOAD_REGISTRY_FILE;
185 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
186 (ndr_pull_flags_fn_t)ndr_pull_preg_file);
187 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
188 status = ndr_map_error2ntstatus(ndr_err);
192 if (flags & GPO_INFO_FLAG_VERBOSE) {
193 NDR_PRINT_DEBUG(preg_file, &r);
196 if (!strequal(r.header.signature, "PReg")) {
197 status = NT_STATUS_INVALID_PARAMETER;
201 if (r.header.version != GP_REGPOL_FILE_VERSION) {
202 status = NT_STATUS_INVALID_PARAMETER;
206 for (i=0; i < r.num_entries; i++) {
208 struct gp_registry_entry *r_entry = NULL;
210 if (!gp_reg_entry_from_file_entry(mem_ctx,
213 status = NT_STATUS_NO_MEMORY;
217 if (!add_gp_registry_entry_to_array(mem_ctx,
221 status = NT_STATUS_NO_MEMORY;
226 *entries_p = entries;
227 *num_entries_p = num_entries;
229 status = NT_STATUS_OK;
232 data_blob_free(&blob);
236 /****************************************************************
237 ****************************************************************/
239 static WERROR reg_apply_registry(TALLOC_CTX *mem_ctx,
240 const struct security_token *token,
241 struct registry_key *root_key,
243 struct gp_registry_entry *entries,
246 struct gp_registry_context *reg_ctx = NULL;
250 if (num_entries == 0) {
255 if (flags & GPO_LIST_FLAG_MACHINE) {
256 werr = gp_init_reg_ctx(mem_ctx, KEY_HKLM, REG_KEY_WRITE,
260 werr = gp_init_reg_ctx(mem_ctx, KEY_HKCU, REG_KEY_WRITE,
264 W_ERROR_NOT_OK_RETURN(werr);
266 for (i=0; i<num_entries; i++) {
268 /* FIXME: maybe we should check here if we attempt to go beyond
269 * the 4 allowed reg keys */
271 werr = reg_apply_registry_entry(mem_ctx, root_key,
275 if (!W_ERROR_IS_OK(werr)) {
276 DEBUG(0,("failed to apply registry: %s\n",
283 gp_free_reg_ctx(reg_ctx);
288 /****************************************************************
289 ****************************************************************/
291 static NTSTATUS registry_process_group_policy(TALLOC_CTX *mem_ctx,
293 struct registry_key *root_key,
294 const struct security_token *token,
295 const struct GROUP_POLICY_OBJECT *deleted_gpo_list,
296 const struct GROUP_POLICY_OBJECT *changed_gpo_list)
300 struct gp_registry_entry *entries = NULL;
301 size_t num_entries = 0;
302 char *unix_path = NULL;
303 const struct GROUP_POLICY_OBJECT *gpo;
304 char *gpo_cache_path = cache_path(talloc_tos(), GPO_CACHE_DIR);
305 if (gpo_cache_path == NULL) {
306 return NT_STATUS_NO_MEMORY;
309 /* implementation of the policy callback function, see
310 * http://msdn.microsoft.com/en-us/library/aa373494%28v=vs.85%29.aspx
311 * for details - gd */
313 /* for now do not process the list of deleted group policies
315 for (gpo = deleted_gpo_list; gpo; gpo = gpo->next) {
320 for (gpo = changed_gpo_list; gpo; gpo = gpo->next) {
322 gpext_debug_header(0, "registry_process_group_policy", flags,
323 gpo, GP_EXT_GUID_REGISTRY, NULL);
325 status = gpo_get_unix_path(mem_ctx, gpo_cache_path,
327 if (!NT_STATUS_IS_OK(status)) {
328 goto err_cache_path_free;
331 status = reg_parse_registry(mem_ctx,
336 if (!NT_STATUS_IS_OK(status)) {
337 DEBUG(0,("failed to parse registry: %s\n",
339 goto err_cache_path_free;
342 dump_reg_entries(flags, "READ", entries, num_entries);
344 werr = reg_apply_registry(mem_ctx, token, root_key, flags,
345 entries, num_entries);
346 if (!W_ERROR_IS_OK(werr)) {
347 DEBUG(0,("failed to apply registry: %s\n",
349 status = werror_to_ntstatus(werr);
350 goto err_cache_path_free;
353 status = NT_STATUS_OK;
356 talloc_free(gpo_cache_path);
357 talloc_free(entries);
361 /****************************************************************
362 ****************************************************************/
364 static NTSTATUS registry_get_reg_config(TALLOC_CTX *mem_ctx,
365 struct gp_extension_reg_info **reg_info)
368 struct gp_extension_reg_info *info = NULL;
369 struct gp_extension_reg_table table[] = {
370 { "ProcessGroupPolicy", REG_SZ, "registry_process_group_policy" },
371 { NULL, REG_NONE, NULL }
374 info = talloc_zero(mem_ctx, struct gp_extension_reg_info);
375 NT_STATUS_HAVE_NO_MEMORY(info);
377 status = gpext_info_add_entry(mem_ctx, GP_EXT_NAME,
378 GP_EXT_GUID_REGISTRY,
380 NT_STATUS_NOT_OK_RETURN(status);
387 /****************************************************************
388 ****************************************************************/
390 static NTSTATUS registry_initialize(TALLOC_CTX *mem_ctx)
395 /****************************************************************
396 ****************************************************************/
398 static NTSTATUS registry_shutdown(void)
402 status = gpext_unregister_gp_extension(GP_EXT_NAME);
403 if (NT_STATUS_IS_OK(status)) {
412 /****************************************************************
413 ****************************************************************/
415 static struct gp_extension_methods registry_methods = {
416 .initialize = registry_initialize,
417 .process_group_policy = registry_process_group_policy,
418 .get_reg_config = registry_get_reg_config,
419 .shutdown = registry_shutdown
422 /****************************************************************
423 ****************************************************************/
425 NTSTATUS gpext_registry_init(TALLOC_CTX *mem_ctx)
429 ctx = talloc_init("gpext_registry_init");
430 NT_STATUS_HAVE_NO_MEMORY(ctx);
432 status = gpext_register_gp_extension(ctx, SMB_GPEXT_INTERFACE_VERSION,
433 GP_EXT_NAME, GP_EXT_GUID_REGISTRY,
435 if (!NT_STATUS_IS_OK(status)) {