source: trunk/server/source3/libgpo/gpext/registry.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 10.3 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 * Group Policy Support
4 * Copyright (C) Guenther Deschner 2007-2008,2010
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_ini.h"
22#include "../libgpo/gpo.h"
23#include "libgpo/gpo_proto.h"
24#include "registry.h"
25#include "../librpc/gen_ndr/ndr_preg.h"
26
27#define GP_EXT_NAME "registry"
28
29/* more info can be found at:
30 * http://msdn2.microsoft.com/en-us/library/aa374407.aspx */
31
32#define GP_REGPOL_FILE "Registry.pol"
33
34#define GP_REGPOL_FILE_SIGNATURE 0x67655250 /* 'PReg' */
35#define GP_REGPOL_FILE_VERSION 1
36
37static TALLOC_CTX *ctx = NULL;
38
39/****************************************************************
40****************************************************************/
41
42static bool reg_parse_value(TALLOC_CTX *mem_ctx,
43 const char **value,
44 enum gp_reg_action *action)
45{
46 if (!*value) {
47 *action = GP_REG_ACTION_ADD_KEY;
48 return true;
49 }
50
51 if (strncmp(*value, "**", 2) != 0) {
52 *action = GP_REG_ACTION_ADD_VALUE;
53 return true;
54 }
55
56 if (strnequal(*value, "**DelVals.", 10)) {
57 *action = GP_REG_ACTION_DEL_ALL_VALUES;
58 return true;
59 }
60
61 if (strnequal(*value, "**Del.", 6)) {
62 *value = talloc_strdup(mem_ctx, *value + 6);
63 *action = GP_REG_ACTION_DEL_VALUE;
64 return true;
65 }
66
67 if (strnequal(*value, "**SecureKey", 11)) {
68 if (strnequal(*value, "**SecureKey=1", 13)) {
69 *action = GP_REG_ACTION_SEC_KEY_SET;
70 return true;
71 }
72
73 /*************** not tested from here on ***************/
74 if (strnequal(*value, "**SecureKey=0", 13)) {
75 smb_panic("not supported: **SecureKey=0");
76 *action = GP_REG_ACTION_SEC_KEY_RESET;
77 return true;
78 }
79 DEBUG(0,("unknown: SecureKey: %s\n", *value));
80 smb_panic("not supported SecureKey method");
81 return false;
82 }
83
84 if (strnequal(*value, "**DeleteValues", strlen("**DeleteValues"))) {
85 smb_panic("not supported: **DeleteValues");
86 *action = GP_REG_ACTION_DEL_VALUES;
87 return false;
88 }
89
90 if (strnequal(*value, "**DeleteKeys", strlen("**DeleteKeys"))) {
91 smb_panic("not supported: **DeleteKeys");
92 *action = GP_REG_ACTION_DEL_KEYS;
93 return false;
94 }
95
96 DEBUG(0,("unknown value: %s\n", *value));
97 smb_panic(*value);
98 return false;
99}
100
101/****************************************************************
102****************************************************************/
103
104static bool gp_reg_entry_from_file_entry(TALLOC_CTX *mem_ctx,
105 struct preg_entry *r,
106 struct gp_registry_entry **reg_entry)
107{
108 struct registry_value *data = NULL;
109 struct gp_registry_entry *entry = NULL;
110 enum gp_reg_action action = GP_REG_ACTION_NONE;
111
112 ZERO_STRUCTP(*reg_entry);
113
114 data = TALLOC_ZERO_P(mem_ctx, struct registry_value);
115 if (!data)
116 return false;
117
118 data->type = r->type;
119 data->data = data_blob_talloc(data, r->data, r->size);
120
121 entry = TALLOC_ZERO_P(mem_ctx, struct gp_registry_entry);
122 if (!entry)
123 return false;
124
125 if (!reg_parse_value(mem_ctx, &r->valuename, &action))
126 return false;
127
128 entry->key = talloc_strdup(entry, r->keyname);
129 entry->value = talloc_strdup(entry, r->valuename);
130 entry->data = data;
131 entry->action = action;
132
133 *reg_entry = entry;
134
135 return true;
136}
137
138/****************************************************************
139****************************************************************/
140
141static NTSTATUS reg_parse_registry(TALLOC_CTX *mem_ctx,
142 uint32_t flags,
143 const char *filename,
144 struct gp_registry_entry **entries_p,
145 size_t *num_entries_p)
146{
147 DATA_BLOB blob;
148 NTSTATUS status;
149 enum ndr_err_code ndr_err;
150 const char *real_filename = NULL;
151 struct preg_file r;
152 struct gp_registry_entry *entries = NULL;
153 size_t num_entries = 0;
154 int i;
155
156 status = gp_find_file(mem_ctx,
157 flags,
158 filename,
159 GP_REGPOL_FILE,
160 &real_filename);
161 if (!NT_STATUS_IS_OK(status)) {
162 return status;
163 }
164
165 blob.data = (uint8_t *)file_load(real_filename, &blob.length, 0, NULL);
166 if (!blob.data) {
167 return NT_STATUS_CANNOT_LOAD_REGISTRY_FILE;
168 }
169
170 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
171 (ndr_pull_flags_fn_t)ndr_pull_preg_file);
172 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
173 status = ndr_map_error2ntstatus(ndr_err);
174 goto out;
175 }
176
177 if (!strequal(r.header.signature, "PReg")) {
178 status = NT_STATUS_INVALID_PARAMETER;
179 goto out;
180 }
181
182 if (r.header.version != GP_REGPOL_FILE_VERSION) {
183 status = NT_STATUS_INVALID_PARAMETER;
184 goto out;
185 }
186
187 for (i=0; i < r.num_entries; i++) {
188
189 struct gp_registry_entry *r_entry = NULL;
190
191 if (!gp_reg_entry_from_file_entry(mem_ctx,
192 &r.entries[i],
193 &r_entry)) {
194 status = NT_STATUS_NO_MEMORY;
195 goto out;
196 }
197
198 if (!add_gp_registry_entry_to_array(mem_ctx,
199 r_entry,
200 &entries,
201 &num_entries)) {
202 status = NT_STATUS_NO_MEMORY;
203 goto out;
204 }
205 }
206
207 *entries_p = entries;
208 *num_entries_p = num_entries;
209
210 status = NT_STATUS_OK;
211
212 out:
213 data_blob_free(&blob);
214 return status;
215}
216
217/****************************************************************
218****************************************************************/
219
220static WERROR reg_apply_registry(TALLOC_CTX *mem_ctx,
221 const struct security_token *token,
222 struct registry_key *root_key,
223 uint32_t flags,
224 struct gp_registry_entry *entries,
225 size_t num_entries)
226{
227 struct gp_registry_context *reg_ctx = NULL;
228 WERROR werr;
229 size_t i;
230
231 if (num_entries == 0) {
232 return WERR_OK;
233 }
234
235#if 0
236 if (flags & GPO_LIST_FLAG_MACHINE) {
237 werr = gp_init_reg_ctx(mem_ctx, KEY_HKLM, REG_KEY_WRITE,
238 get_system_token(),
239 &reg_ctx);
240 } else {
241 werr = gp_init_reg_ctx(mem_ctx, KEY_HKCU, REG_KEY_WRITE,
242 token,
243 &reg_ctx);
244 }
245 W_ERROR_NOT_OK_RETURN(werr);
246#endif
247 for (i=0; i<num_entries; i++) {
248
249 /* FIXME: maybe we should check here if we attempt to go beyond
250 * the 4 allowed reg keys */
251
252 werr = reg_apply_registry_entry(mem_ctx, root_key,
253 reg_ctx,
254 &(entries)[i],
255 token, flags);
256 if (!W_ERROR_IS_OK(werr)) {
257 DEBUG(0,("failed to apply registry: %s\n",
258 win_errstr(werr)));
259 goto done;
260 }
261 }
262
263done:
264 gp_free_reg_ctx(reg_ctx);
265 return werr;
266}
267
268
269/****************************************************************
270****************************************************************/
271
272static NTSTATUS registry_process_group_policy(ADS_STRUCT *ads,
273 TALLOC_CTX *mem_ctx,
274 uint32_t flags,
275 struct registry_key *root_key,
276 const struct security_token *token,
277 struct GROUP_POLICY_OBJECT *gpo,
278 const char *extension_guid,
279 const char *snapin_guid)
280{
281 NTSTATUS status;
282 WERROR werr;
283 struct gp_registry_entry *entries = NULL;
284 size_t num_entries = 0;
285 char *unix_path = NULL;
286
287 debug_gpext_header(0, "registry_process_group_policy", flags, gpo,
288 extension_guid, snapin_guid);
289
290 status = gpo_get_unix_path(mem_ctx, cache_path(GPO_CACHE_DIR), gpo, &unix_path);
291 NT_STATUS_NOT_OK_RETURN(status);
292
293 status = reg_parse_registry(mem_ctx,
294 flags,
295 unix_path,
296 &entries,
297 &num_entries);
298 if (!NT_STATUS_IS_OK(status)) {
299 DEBUG(0,("failed to parse registry: %s\n",
300 nt_errstr(status)));
301 return status;
302 }
303
304 dump_reg_entries(flags, "READ", entries, num_entries);
305
306 werr = reg_apply_registry(mem_ctx, token, root_key, flags,
307 entries, num_entries);
308 if (!W_ERROR_IS_OK(werr)) {
309 DEBUG(0,("failed to apply registry: %s\n",
310 win_errstr(werr)));
311 return werror_to_ntstatus(werr);
312 }
313
314 return NT_STATUS_OK;
315}
316
317/****************************************************************
318****************************************************************/
319
320static NTSTATUS registry_get_reg_config(TALLOC_CTX *mem_ctx,
321 struct gp_extension_reg_info **reg_info)
322{
323 NTSTATUS status;
324 struct gp_extension_reg_info *info = NULL;
325 struct gp_extension_reg_table table[] = {
326 { "ProcessGroupPolicy", REG_SZ, "registry_process_group_policy" },
327 { NULL, REG_NONE, NULL }
328 };
329
330 info = TALLOC_ZERO_P(mem_ctx, struct gp_extension_reg_info);
331 NT_STATUS_HAVE_NO_MEMORY(info);
332
333 status = gp_ext_info_add_entry(mem_ctx, GP_EXT_NAME,
334 GP_EXT_GUID_REGISTRY,
335 table, info);
336 NT_STATUS_NOT_OK_RETURN(status);
337
338 *reg_info = info;
339
340 return NT_STATUS_OK;
341}
342
343/****************************************************************
344****************************************************************/
345
346static NTSTATUS registry_initialize(TALLOC_CTX *mem_ctx)
347{
348 return NT_STATUS_OK;
349}
350
351/****************************************************************
352****************************************************************/
353
354static NTSTATUS registry_shutdown(void)
355{
356 NTSTATUS status;
357
358 status = unregister_gp_extension(GP_EXT_NAME);
359 if (NT_STATUS_IS_OK(status)) {
360 return status;
361 }
362
363 TALLOC_FREE(ctx);
364
365 return NT_STATUS_OK;
366}
367
368/****************************************************************
369****************************************************************/
370
371static struct gp_extension_methods registry_methods = {
372 .initialize = registry_initialize,
373 .process_group_policy = registry_process_group_policy,
374 .get_reg_config = registry_get_reg_config,
375 .shutdown = registry_shutdown
376};
377
378/****************************************************************
379****************************************************************/
380
381NTSTATUS gpext_registry_init(void)
382{
383 NTSTATUS status;
384
385 ctx = talloc_init("gpext_registry_init");
386 NT_STATUS_HAVE_NO_MEMORY(ctx);
387
388 status = register_gp_extension(ctx, SMB_GPEXT_INTERFACE_VERSION,
389 GP_EXT_NAME, GP_EXT_GUID_REGISTRY,
390 &registry_methods);
391 if (!NT_STATUS_IS_OK(status)) {
392 TALLOC_FREE(ctx);
393 }
394
395 return status;
396}
Note: See TracBrowser for help on using the repository browser.