source: branches/samba-3.5.x/source3/libgpo/gpext/registry.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 16 years ago

Samba 3.5.0: Initial import
File size: 15.2 KB
Line 
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_ini.h"
22
23#define GP_EXT_NAME "registry"
24
25/* more info can be found at:
26 * http://msdn2.microsoft.com/en-us/library/aa374407.aspx */
27
28#define GP_REGPOL_FILE "Registry.pol"
29
30#define GP_REGPOL_FILE_SIGNATURE 0x67655250 /* 'PReg' */
31#define GP_REGPOL_FILE_VERSION 1
32
33static TALLOC_CTX *ctx = NULL;
34
35struct gp_registry_file_header {
36 uint32_t signature;
37 uint32_t version;
38};
39
40struct gp_registry_file_entry {
41 UNISTR key;
42 UNISTR value;
43 enum winreg_Type type;
44 size_t size;
45 uint8_t *data;
46};
47
48struct gp_registry_file {
49 struct gp_registry_file_header header;
50 size_t num_entries;
51 struct gp_registry_entry *entries;
52};
53
54/****************************************************************
55****************************************************************/
56
57static bool reg_parse_header(const char *desc,
58 struct gp_registry_file_header *header,
59 prs_struct *ps,
60 int depth)
61{
62 if (!header)
63 return false;
64
65 prs_debug(ps, depth, desc, "reg_parse_header");
66 depth++;
67
68 if (!prs_uint32("signature", ps, depth, &header->signature))
69 return false;
70
71 if (!prs_uint32("version", ps, depth, &header->version))
72 return false;
73
74 return true;
75}
76
77/****************************************************************
78****************************************************************/
79
80static bool reg_parse_and_verify_ucs2_char(const char *desc,
81 char character,
82 prs_struct *ps,
83 int depth)
84{
85 uint16_t tmp;
86
87 if (!prs_uint16(desc, ps, depth, &tmp))
88 return false;
89
90 if (tmp != UCS2_CHAR(character))
91 return false;
92
93 return true;
94}
95
96/****************************************************************
97****************************************************************/
98
99static bool reg_parse_init(prs_struct *ps, int depth)
100{
101 return reg_parse_and_verify_ucs2_char("initiator '['", '[',
102 ps, depth);
103}
104
105/****************************************************************
106****************************************************************/
107
108static bool reg_parse_sep(prs_struct *ps, int depth)
109{
110 return reg_parse_and_verify_ucs2_char("separator ';'", ';',
111 ps, depth);
112}
113
114/****************************************************************
115****************************************************************/
116
117static bool reg_parse_term(prs_struct *ps, int depth)
118{
119 return reg_parse_and_verify_ucs2_char("terminator ']'", ']',
120 ps, depth);
121}
122
123
124/****************************************************************
125* [key;value;type;size;data]
126****************************************************************/
127
128static bool reg_parse_entry(TALLOC_CTX *mem_ctx,
129 const char *desc,
130 struct gp_registry_file_entry *entry,
131 prs_struct *ps,
132 int depth)
133{
134 uint32_t size = 0;
135
136 if (!entry)
137 return false;
138
139 prs_debug(ps, depth, desc, "reg_parse_entry");
140 depth++;
141
142 ZERO_STRUCTP(entry);
143
144 if (!reg_parse_init(ps, depth))
145 return false;
146
147 if (!prs_unistr("key", ps, depth, &entry->key))
148 return false;
149
150 if (!reg_parse_sep(ps, depth))
151 return false;
152
153 if (!prs_unistr("value", ps, depth, &entry->value))
154 return false;
155
156 if (!reg_parse_sep(ps, depth))
157 return false;
158
159 if (!prs_uint32("type", ps, depth, &entry->type))
160 return false;
161
162 if (!reg_parse_sep(ps, depth))
163 return false;
164
165 if (!prs_uint32("size", ps, depth, &size))
166 return false;
167
168 entry->size = size;
169
170 if (!reg_parse_sep(ps, depth))
171 return false;
172
173 if (entry->size) {
174 entry->data = TALLOC_ZERO_ARRAY(mem_ctx, uint8, entry->size);
175 if (!entry->data)
176 return false;
177 }
178
179 if (!prs_uint8s(false, "data", ps, depth, entry->data, entry->size))
180 return false;
181
182 if (!reg_parse_term(ps, depth))
183 return false;
184
185 return true;
186}
187
188/****************************************************************
189****************************************************************/
190
191static bool reg_parse_value(TALLOC_CTX *mem_ctx,
192 char **value,
193 enum gp_reg_action *action)
194{
195 if (!*value) {
196 *action = GP_REG_ACTION_ADD_KEY;
197 return true;
198 }
199
200 if (strncmp(*value, "**", 2) != 0) {
201 *action = GP_REG_ACTION_ADD_VALUE;
202 return true;
203 }
204
205 if (strnequal(*value, "**DelVals.", 10)) {
206 *action = GP_REG_ACTION_DEL_ALL_VALUES;
207 return true;
208 }
209
210 if (strnequal(*value, "**Del.", 6)) {
211 *value = talloc_strdup(mem_ctx, *value + 6);
212 *action = GP_REG_ACTION_DEL_VALUE;
213 return true;
214 }
215
216 if (strnequal(*value, "**SecureKey", 11)) {
217 if (strnequal(*value, "**SecureKey=1", 13)) {
218 *action = GP_REG_ACTION_SEC_KEY_SET;
219 return true;
220 }
221
222 /*************** not tested from here on ***************/
223 if (strnequal(*value, "**SecureKey=0", 13)) {
224 smb_panic("not supported: **SecureKey=0");
225 *action = GP_REG_ACTION_SEC_KEY_RESET;
226 return true;
227 }
228 DEBUG(0,("unknown: SecureKey: %s\n", *value));
229 smb_panic("not supported SecureKey method");
230 return false;
231 }
232
233 if (strnequal(*value, "**DeleteValues", strlen("**DeleteValues"))) {
234 smb_panic("not supported: **DeleteValues");
235 *action = GP_REG_ACTION_DEL_VALUES;
236 return false;
237 }
238
239 if (strnequal(*value, "**DeleteKeys", strlen("**DeleteKeys"))) {
240 smb_panic("not supported: **DeleteKeys");
241 *action = GP_REG_ACTION_DEL_KEYS;
242 return false;
243 }
244
245 DEBUG(0,("unknown value: %s\n", *value));
246 smb_panic(*value);
247 return false;
248}
249
250/****************************************************************
251****************************************************************/
252
253static bool gp_reg_entry_from_file_entry(TALLOC_CTX *mem_ctx,
254 struct gp_registry_file_entry *file_entry,
255 struct gp_registry_entry **reg_entry)
256{
257 struct registry_value *data = NULL;
258 struct gp_registry_entry *entry = NULL;
259 char *key = NULL;
260 char *value = NULL;
261 enum gp_reg_action action = GP_REG_ACTION_NONE;
262 size_t converted_size;
263
264 ZERO_STRUCTP(*reg_entry);
265
266 data = TALLOC_ZERO_P(mem_ctx, struct registry_value);
267 if (!data)
268 return false;
269
270 if (strlen_w((const smb_ucs2_t *)file_entry->key.buffer) <= 0)
271 return false;
272
273 if (!pull_ucs2_talloc(mem_ctx, &key, file_entry->key.buffer,
274 &converted_size))
275 {
276 return false;
277 }
278
279 if (strlen_w((const smb_ucs2_t *)file_entry->value.buffer) > 0 &&
280 !pull_ucs2_talloc(mem_ctx, &value, file_entry->value.buffer,
281 &converted_size))
282 {
283 return false;
284 }
285
286 if (!reg_parse_value(mem_ctx, &value, &action))
287 return false;
288
289 data->type = file_entry->type;
290
291 switch (data->type) {
292 case REG_DWORD:
293 data->v.dword = atoi((char *)file_entry->data);
294 break;
295 case REG_BINARY:
296 data->v.binary = data_blob_talloc(mem_ctx,
297 file_entry->data,
298 file_entry->size);
299 break;
300 case REG_NONE:
301 break;
302 case REG_SZ:
303 if (!pull_ucs2_talloc(mem_ctx, &data->v.sz.str,
304 (const smb_ucs2_t *)
305 file_entry->data,
306 &data->v.sz.len)) {
307 data->v.sz.len = -1;
308 }
309
310 break;
311 case REG_DWORD_BIG_ENDIAN:
312 case REG_EXPAND_SZ:
313 case REG_LINK:
314 case REG_MULTI_SZ:
315 case REG_QWORD:
316/* case REG_DWORD_LITTLE_ENDIAN: */
317/* case REG_QWORD_LITTLE_ENDIAN: */
318 printf("not yet implemented: %d\n", data->type);
319 return false;
320 default:
321 printf("invalid reg type defined: %d\n", data->type);
322 return false;
323
324 }
325
326 entry = TALLOC_ZERO_P(mem_ctx, struct gp_registry_entry);
327 if (!entry)
328 return false;
329
330 entry->key = key;
331 entry->value = value;
332 entry->data = data;
333 entry->action = action;
334
335 *reg_entry = entry;
336
337 return true;
338}
339
340/****************************************************************
341* [key;value;type;size;data][key;value;type;size;data]...
342****************************************************************/
343
344static bool reg_parse_entries(TALLOC_CTX *mem_ctx,
345 const char *desc,
346 struct gp_registry_entry **entries,
347 size_t *num_entries,
348 prs_struct *ps,
349 int depth)
350{
351
352 if (!entries || !num_entries)
353 return false;
354
355 prs_debug(ps, depth, desc, "reg_parse_entries");
356 depth++;
357
358 *entries = NULL;
359 *num_entries = 0;
360
361 while (ps->buffer_size > ps->data_offset) {
362
363 struct gp_registry_file_entry f_entry;
364 struct gp_registry_entry *r_entry = NULL;
365
366 if (!reg_parse_entry(mem_ctx, desc, &f_entry,
367 ps, depth))
368 return false;
369
370 if (!gp_reg_entry_from_file_entry(mem_ctx,
371 &f_entry,
372 &r_entry))
373 return false;
374
375 if (!add_gp_registry_entry_to_array(mem_ctx,
376 r_entry,
377 entries,
378 num_entries))
379 return false;
380 }
381
382 return true;
383}
384
385/****************************************************************
386****************************************************************/
387
388static NTSTATUS reg_parse_registry(TALLOC_CTX *mem_ctx,
389 uint32_t flags,
390 const char *filename,
391 struct gp_registry_entry **entries,
392 size_t *num_entries)
393{
394 uint16_t *buf = NULL;
395 size_t n = 0;
396 NTSTATUS status;
397 prs_struct ps;
398 struct gp_registry_file *reg_file;
399 const char *real_filename = NULL;
400
401 reg_file = TALLOC_ZERO_P(mem_ctx, struct gp_registry_file);
402 NT_STATUS_HAVE_NO_MEMORY(reg_file);
403
404 status = gp_find_file(mem_ctx,
405 flags,
406 filename,
407 GP_REGPOL_FILE,
408 &real_filename);
409 if (!NT_STATUS_IS_OK(status)) {
410 TALLOC_FREE(reg_file);
411 return status;
412 }
413
414 buf = (uint16 *)file_load(real_filename, &n, 0, NULL);
415 if (!buf) {
416 TALLOC_FREE(reg_file);
417 return NT_STATUS_CANNOT_LOAD_REGISTRY_FILE;
418 }
419
420 if (!prs_init(&ps, n, mem_ctx, UNMARSHALL)) {
421 status = NT_STATUS_NO_MEMORY;
422 goto out;
423 }
424
425 if (!prs_copy_data_in(&ps, (char *)buf, n)) {
426 status = NT_STATUS_NO_MEMORY;
427 goto out;
428 }
429
430 prs_set_offset(&ps, 0);
431
432 if (!reg_parse_header("header", &reg_file->header, &ps, 0)) {
433 status = NT_STATUS_REGISTRY_IO_FAILED;
434 goto out;
435 }
436
437 if (reg_file->header.signature != GP_REGPOL_FILE_SIGNATURE) {
438 status = NT_STATUS_INVALID_PARAMETER;
439 goto out;
440 }
441
442 if (reg_file->header.version != GP_REGPOL_FILE_VERSION) {
443 status = NT_STATUS_INVALID_PARAMETER;
444 goto out;
445 }
446
447 if (!reg_parse_entries(mem_ctx, "entries", &reg_file->entries,
448 &reg_file->num_entries, &ps, 0)) {
449 status = NT_STATUS_REGISTRY_IO_FAILED;
450 goto out;
451 }
452
453 *entries = reg_file->entries;
454 *num_entries = reg_file->num_entries;
455
456 status = NT_STATUS_OK;
457
458 out:
459 TALLOC_FREE(buf);
460 prs_mem_free(&ps);
461
462 return status;
463}
464
465/****************************************************************
466****************************************************************/
467
468static WERROR reg_apply_registry(TALLOC_CTX *mem_ctx,
469 const struct nt_user_token *token,
470 struct registry_key *root_key,
471 uint32_t flags,
472 struct gp_registry_entry *entries,
473 size_t num_entries)
474{
475 struct gp_registry_context *reg_ctx = NULL;
476 WERROR werr;
477 size_t i;
478
479 if (num_entries == 0) {
480 return WERR_OK;
481 }
482
483#if 0
484 if (flags & GPO_LIST_FLAG_MACHINE) {
485 werr = gp_init_reg_ctx(mem_ctx, KEY_HKLM, REG_KEY_WRITE,
486 get_system_token(),
487 &reg_ctx);
488 } else {
489 werr = gp_init_reg_ctx(mem_ctx, KEY_HKCU, REG_KEY_WRITE,
490 token,
491 &reg_ctx);
492 }
493 W_ERROR_NOT_OK_RETURN(werr);
494#endif
495 for (i=0; i<num_entries; i++) {
496
497 /* FIXME: maybe we should check here if we attempt to go beyond
498 * the 4 allowed reg keys */
499
500 werr = reg_apply_registry_entry(mem_ctx, root_key,
501 reg_ctx,
502 &(entries)[i],
503 token, flags);
504 if (!W_ERROR_IS_OK(werr)) {
505 DEBUG(0,("failed to apply registry: %s\n",
506 win_errstr(werr)));
507 goto done;
508 }
509 }
510
511done:
512 gp_free_reg_ctx(reg_ctx);
513 return werr;
514}
515
516
517/****************************************************************
518****************************************************************/
519
520static NTSTATUS registry_process_group_policy(ADS_STRUCT *ads,
521 TALLOC_CTX *mem_ctx,
522 uint32_t flags,
523 struct registry_key *root_key,
524 const struct nt_user_token *token,
525 struct GROUP_POLICY_OBJECT *gpo,
526 const char *extension_guid,
527 const char *snapin_guid)
528{
529 NTSTATUS status;
530 WERROR werr;
531 struct gp_registry_entry *entries = NULL;
532 size_t num_entries = 0;
533 char *unix_path = NULL;
534
535 debug_gpext_header(0, "registry_process_group_policy", flags, gpo,
536 extension_guid, snapin_guid);
537
538 status = gpo_get_unix_path(mem_ctx, cache_path(GPO_CACHE_DIR), gpo, &unix_path);
539 NT_STATUS_NOT_OK_RETURN(status);
540
541 status = reg_parse_registry(mem_ctx,
542 flags,
543 unix_path,
544 &entries,
545 &num_entries);
546 if (!NT_STATUS_IS_OK(status)) {
547 DEBUG(0,("failed to parse registry: %s\n",
548 nt_errstr(status)));
549 return status;
550 }
551
552 dump_reg_entries(flags, "READ", entries, num_entries);
553
554 werr = reg_apply_registry(mem_ctx, token, root_key, flags,
555 entries, num_entries);
556 if (!W_ERROR_IS_OK(werr)) {
557 DEBUG(0,("failed to apply registry: %s\n",
558 win_errstr(werr)));
559 return werror_to_ntstatus(werr);
560 }
561
562 return NT_STATUS_OK;
563}
564
565/****************************************************************
566****************************************************************/
567
568static NTSTATUS registry_get_reg_config(TALLOC_CTX *mem_ctx,
569 struct gp_extension_reg_info **reg_info)
570{
571 NTSTATUS status;
572 struct gp_extension_reg_info *info = NULL;
573 struct gp_extension_reg_table table[] = {
574 { "ProcessGroupPolicy", REG_SZ, "registry_process_group_policy" },
575 { NULL, REG_NONE, NULL }
576 };
577
578 info = TALLOC_ZERO_P(mem_ctx, struct gp_extension_reg_info);
579 NT_STATUS_HAVE_NO_MEMORY(info);
580
581 status = gp_ext_info_add_entry(mem_ctx, GP_EXT_NAME,
582 GP_EXT_GUID_REGISTRY,
583 table, info);
584 NT_STATUS_NOT_OK_RETURN(status);
585
586 *reg_info = info;
587
588 return NT_STATUS_OK;
589}
590
591/****************************************************************
592****************************************************************/
593
594static NTSTATUS registry_initialize(TALLOC_CTX *mem_ctx)
595{
596 return NT_STATUS_OK;
597}
598
599/****************************************************************
600****************************************************************/
601
602static NTSTATUS registry_shutdown(void)
603{
604 NTSTATUS status;
605
606 status = unregister_gp_extension(GP_EXT_NAME);
607 if (NT_STATUS_IS_OK(status)) {
608 return status;
609 }
610
611 TALLOC_FREE(ctx);
612
613 return NT_STATUS_OK;
614}
615
616/****************************************************************
617****************************************************************/
618
619static struct gp_extension_methods registry_methods = {
620 .initialize = registry_initialize,
621 .process_group_policy = registry_process_group_policy,
622 .get_reg_config = registry_get_reg_config,
623 .shutdown = registry_shutdown
624};
625
626/****************************************************************
627****************************************************************/
628
629NTSTATUS gpext_registry_init(void)
630{
631 NTSTATUS status;
632
633 ctx = talloc_init("gpext_registry_init");
634 NT_STATUS_HAVE_NO_MEMORY(ctx);
635
636 status = register_gp_extension(ctx, SMB_GPEXT_INTERFACE_VERSION,
637 GP_EXT_NAME, GP_EXT_GUID_REGISTRY,
638 &registry_methods);
639 if (!NT_STATUS_IS_OK(status)) {
640 TALLOC_FREE(ctx);
641 }
642
643 return status;
644}
Note: See TracBrowser for help on using the repository browser.