?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4-lsaprc: Don't call lsa_OpenPolicy2 in lsa_LookupNames4.
[Samba/gebeck_regimport.git] / source3 / registry / reg_backend_db.c
blob8fe1b8e61c42d43187a84fe084c52ac418e17f2b
1 /*
2 * Unix SMB/CIFS implementation.
3 * Virtual Windows Registry Layer
4 * Copyright (C) Gerald Carter 2002-2005
5 * Copyright (C) Michael Adam 2007-2011
6 * Copyright (C) Gregor Beck 2011
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 */
21
22 /* Implementation of internal registry database functions. */
23
24 #include "includes.h"
25 #include "system/filesys.h"
26 #include "registry.h"
27 #include "reg_db.h"
28 #include "reg_util_internal.h"
29 #include "reg_parse_internal.h"
30 #include "reg_backend_db.h"
31 #include "reg_objects.h"
32 #include "nt_printing.h"
33 #include "util_tdb.h"
34 #include "dbwrap/dbwrap.h"
35 #include "dbwrap/dbwrap_open.h"
36 #include "../libcli/security/secdesc.h"
37
38 #undef DBGC_CLASS
39 #define DBGC_CLASS DBGC_REGISTRY
40
41 #define REGDB_VERSION_KEYNAME "INFO/version"
42
43 static struct db_context *regdb = NULL;
44 static int regdb_refcount;
45
46 static bool regdb_key_exists(struct db_context *db, const char *key);
47 static WERROR regdb_fetch_keys_internal(struct db_context *db, const char *key,
48 struct regsubkey_ctr *ctr);
49 static bool regdb_store_keys_internal(struct db_context *db, const char *key,
50 struct regsubkey_ctr *ctr);
51 static int regdb_fetch_values_internal(struct db_context *db, const char* key,
52 struct regval_ctr *values);
53 static NTSTATUS regdb_store_values_internal(struct db_context *db, const char *key,
54 struct regval_ctr *values);
55 static WERROR regdb_store_subkey_list(struct db_context *db, const char *parent,
56 const char *key);
57
58 static WERROR regdb_create_basekey(struct db_context *db, const char *key);
59 static WERROR regdb_create_subkey_internal(struct db_context *db,
60 const char *key,
61 const char *subkey);
62
63
64 struct regdb_trans_ctx {
65 NTSTATUS (*action)(struct db_context *, void *);
66 void *private_data;
67 };
68
69 static NTSTATUS regdb_trans_do_action(struct db_context *db, void *private_data)
70 {
71 NTSTATUS status;
72 int32_t version_id;
73 struct regdb_trans_ctx *ctx = (struct regdb_trans_ctx *)private_data;
74
75 status = dbwrap_fetch_int32_bystring(db, REGDB_VERSION_KEYNAME,
76 &version_id);
77
78 if (!NT_STATUS_IS_OK(status)) {
79 DEBUG(0, ("ERROR: could not fetch registry db version: %s. "
80 "Denying access.\n", nt_errstr(status)));
81 return NT_STATUS_ACCESS_DENIED;
82 }
83
84 if (version_id != REGDB_CODE_VERSION) {
85 DEBUG(0, ("ERROR: changed registry version %d found while "
86 "trying to write to the registry. Version %d "
87 "expected. Denying access.\n",
88 version_id, REGDB_CODE_VERSION));
89 return NT_STATUS_ACCESS_DENIED;
90 }
91
92 status = ctx->action(db, ctx->private_data);
93 return status;
94 }
95
96 static WERROR regdb_trans_do(struct db_context *db,
97 NTSTATUS (*action)(struct db_context *, void *),
98 void *private_data)
99 {
100 NTSTATUS status;
101 struct regdb_trans_ctx ctx;
102
103
104 ctx.action = action;
105 ctx.private_data = private_data;
106
107 status = dbwrap_trans_do(db, regdb_trans_do_action, &ctx);
108
109 return ntstatus_to_werror(status);
110 }
111
112 /* List the deepest path into the registry. All part components will be created.*/
113
114 /* If you want to have a part of the path controlled by the tdb and part by
115 a virtual registry db (e.g. printing), then you have to list the deepest path.
116 For example,"HKLM/SOFTWARE/Microsoft/Windows NT/CurrentVersion/Print"
117 allows the reg_db backend to handle everything up to
118 "HKLM/SOFTWARE/Microsoft/Windows NT/CurrentVersion" and then we'll hook
119 the reg_printing backend onto the last component of the path (see
120 KEY_PRINTING_2K in include/rpc_reg.h) --jerry */
121
122 static const char *builtin_registry_paths[] = {
123 KEY_PRINTING_2K,
124 KEY_PRINTING_PORTS,
125 KEY_PRINTING,
126 KEY_PRINTING "\\Forms",
127 KEY_PRINTING "\\Printers",
128 KEY_PRINTING "\\Environments\\Windows NT x86\\Print Processors\\winprint",
129 KEY_SHARES,
130 KEY_EVENTLOG,
131 KEY_SMBCONF,
132 KEY_PERFLIB,
133 KEY_PERFLIB_009,
134 KEY_GROUP_POLICY,
135 KEY_SAMBA_GROUP_POLICY,
136 KEY_GP_MACHINE_POLICY,
137 KEY_GP_MACHINE_WIN_POLICY,
138 KEY_HKCU,
139 KEY_GP_USER_POLICY,
140 KEY_GP_USER_WIN_POLICY,
141 "HKLM\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon\\GPExtensions",
142 "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Print\\Monitors",
143 KEY_PROD_OPTIONS,
144 "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Terminal Server\\DefaultUserConfiguration",
145 KEY_TCPIP_PARAMS,
146 KEY_NETLOGON_PARAMS,
147 KEY_HKU,
148 KEY_HKCR,
149 KEY_HKPD,
150 KEY_HKPT,
151 NULL };
152
153 struct builtin_regkey_value {
154 const char *path;
155 const char *valuename;
156 uint32 type;
157 union {
158 const char *string;
159 uint32 dw_value;
160 } data;
161 };
162
163 static struct builtin_regkey_value builtin_registry_values[] = {
164 { KEY_PRINTING_PORTS,
165 SAMBA_PRINTER_PORT_NAME, REG_SZ, { "" } },
166 { KEY_PRINTING_2K,
167 "DefaultSpoolDirectory", REG_SZ, { "C:\\Windows\\System32\\Spool\\Printers" } },
168 { KEY_EVENTLOG,
169 "DisplayName", REG_SZ, { "Event Log" } },
170 { KEY_EVENTLOG,
171 "ErrorControl", REG_DWORD, { (char*)0x00000001 } },
172 { NULL, NULL, 0, { NULL } }
173 };
174
175 static WERROR create_key_recursive(struct db_context *db,
176 char *path,
177 const char *subkey)
178 {
179 WERROR werr;
180 char *p;
181
182 if (subkey == NULL) {
183 return WERR_INVALID_PARAM;
184 }
185
186 if (path == NULL) {
187 return regdb_create_basekey(db, subkey);
188 }
189
190 p = strrchr_m(path, '\\');
191
192 if (p == NULL) {
193 werr = create_key_recursive(db, NULL, path);
194 } else {
195 *p = '\0';
196 werr = create_key_recursive(db, path, p+1);
197 *p = '\\';
198 }
199
200 if (!W_ERROR_IS_OK(werr)) {
201 goto done;
202 }
203
204 werr = regdb_create_subkey_internal(db, path, subkey);
205
206 done:
207 return werr;
208 }
209
210 /**
211 * Initialize a key in the registry:
212 * create each component key of the specified path.
213 */
214 static WERROR init_registry_key_internal(struct db_context *db,
215 const char *add_path)
216 {
217 char *subkey, *key;
218 WERROR werr;
219 TALLOC_CTX *frame = talloc_stackframe();
220
221 if (add_path == NULL) {
222 werr = WERR_INVALID_PARAM;
223 goto done;
224 }
225
226 key = talloc_strdup(frame, add_path);
227
228 subkey = strrchr_m(key, '\\');
229 if (subkey == NULL) {
230 subkey = key;
231 key = NULL;
232 } else {
233 *subkey = '\0';
234 subkey++;
235 }
236
237 werr = create_key_recursive(db, key, subkey);
238
239 done:
240 talloc_free(frame);
241 return werr;
242 }
243
244 struct init_registry_key_context {
245 const char *add_path;
246 };
247
248 static NTSTATUS init_registry_key_action(struct db_context *db,
249 void *private_data)
250 {
251 struct init_registry_key_context *init_ctx =
252 (struct init_registry_key_context *)private_data;
253
254 return werror_to_ntstatus(init_registry_key_internal(
255 db, init_ctx->add_path));
256 }
257
258 /**
259 * Initialize a key in the registry:
260 * create each component key of the specified path,
261 * wrapped in one db transaction.
262 */
263 WERROR init_registry_key(const char *add_path)
264 {
265 struct init_registry_key_context init_ctx;
266
267 if (regdb_key_exists(regdb, add_path)) {
268 return WERR_OK;
269 }
270
271 init_ctx.add_path = add_path;
272
273 return regdb_trans_do(regdb,
274 init_registry_key_action,
275 &init_ctx);
276 }
277
278 /***********************************************************************
279 Open the registry data in the tdb
280 ***********************************************************************/
281
282 static void regdb_ctr_add_value(struct regval_ctr *ctr,
283 struct builtin_regkey_value *value)
284 {
285 switch(value->type) {
286 case REG_DWORD:
287 regval_ctr_addvalue(ctr, value->valuename, REG_DWORD,
288 (uint8_t *)&value->data.dw_value,
289 sizeof(uint32));
290 break;
291
292 case REG_SZ:
293 regval_ctr_addvalue_sz(ctr, value->valuename,
294 value->data.string);
295 break;
296
297 default:
298 DEBUG(0, ("regdb_ctr_add_value: invalid value type in "
299 "registry values [%d]\n", value->type));
300 }
301 }
302
303 static NTSTATUS init_registry_data_action(struct db_context *db,
304 void *private_data)
305 {
306 NTSTATUS status;
307 TALLOC_CTX *frame = talloc_stackframe();
308 struct regval_ctr *values;
309 int i;
310
311 /* loop over all of the predefined paths and add each component */
312
313 for (i=0; builtin_registry_paths[i] != NULL; i++) {
314 if (regdb_key_exists(db, builtin_registry_paths[i])) {
315 continue;
316 }
317 status = werror_to_ntstatus(init_registry_key_internal(db,
318 builtin_registry_paths[i]));
319 if (!NT_STATUS_IS_OK(status)) {
320 goto done;
321 }
322 }
323
324 /* loop over all of the predefined values and add each component */
325
326 for (i=0; builtin_registry_values[i].path != NULL; i++) {
327 WERROR werr;
328
329 werr = regval_ctr_init(frame, &values);
330 if (!W_ERROR_IS_OK(werr)) {
331 status = werror_to_ntstatus(werr);
332 goto done;
333 }
334
335 regdb_fetch_values_internal(db,
336 builtin_registry_values[i].path,
337 values);
338
339 /* preserve existing values across restarts. Only add new ones */
340
341 if (!regval_ctr_value_exists(values,
342 builtin_registry_values[i].valuename))
343 {
344 regdb_ctr_add_value(values,
345 &builtin_registry_values[i]);
346 status = regdb_store_values_internal(db,
347 builtin_registry_values[i].path,
348 values);
349 if (!NT_STATUS_IS_OK(status)) {
350 goto done;
351 }
352 }
353 TALLOC_FREE(values);
354 }
355
356 status = NT_STATUS_OK;
357
358 done:
359
360 TALLOC_FREE(frame);
361 return status;
362 }
363
364 WERROR init_registry_data(void)
365 {
366 WERROR werr;
367 TALLOC_CTX *frame = talloc_stackframe();
368 struct regval_ctr *values;
369 int i;
370
371 /*
372 * First, check for the existence of the needed keys and values.
373 * If all do already exist, we can save the writes.
374 */
375 for (i=0; builtin_registry_paths[i] != NULL; i++) {
376 if (!regdb_key_exists(regdb, builtin_registry_paths[i])) {
377 goto do_init;
378 }
379 }
380
381 for (i=0; builtin_registry_values[i].path != NULL; i++) {
382 werr = regval_ctr_init(frame, &values);
383 W_ERROR_NOT_OK_GOTO_DONE(werr);
384
385 regdb_fetch_values_internal(regdb,
386 builtin_registry_values[i].path,
387 values);
388 if (!regval_ctr_value_exists(values,
389 builtin_registry_values[i].valuename))
390 {
391 TALLOC_FREE(values);
392 goto do_init;
393 }
394
395 TALLOC_FREE(values);
396 }
397
398 werr = WERR_OK;
399 goto done;
400
401 do_init:
402
403 /*
404 * There are potentially quite a few store operations which are all
405 * indiviually wrapped in tdb transactions. Wrapping them in a single
406 * transaction gives just a single transaction_commit() to actually do
407 * its fsync()s. See tdb/common/transaction.c for info about nested
408 * transaction behaviour.
409 */
410
411 werr = regdb_trans_do(regdb,
412 init_registry_data_action,
413 NULL);
414
415 done:
416 TALLOC_FREE(frame);
417 return werr;
418 }
419
420 static int regdb_normalize_keynames_fn(struct db_record *rec,
421 void *private_data)
422 {
423 TALLOC_CTX *mem_ctx = talloc_tos();
424 const char *keyname;
425 NTSTATUS status;
426 TDB_DATA key;
427 TDB_DATA value;
428 struct db_context *db = (struct db_context *)private_data;
429
430 key = dbwrap_record_get_key(rec);
431 if (key.dptr == NULL || key.dsize == 0) {
432 return 0;
433 }
434
435 value = dbwrap_record_get_value(rec);
436
437 if (db == NULL) {
438 DEBUG(0, ("regdb_normalize_keynames_fn: ERROR: "
439 "NULL db context handed in via private_data\n"));
440 return 1;
441 }
442
443 if (strncmp((const char *)key.dptr, REGDB_VERSION_KEYNAME,
444 strlen(REGDB_VERSION_KEYNAME)) == 0)
445 {
446 return 0;
447 }
448
449 keyname = strchr((const char *)key.dptr, '/');
450 if (keyname) {
451 keyname = talloc_string_sub(mem_ctx,
452 (const char *)key.dptr,
453 "/",
454 "\\");
455
456 DEBUG(2, ("regdb_normalize_keynames_fn: Convert %s to %s\n",
457 (const char *)key.dptr,
458 keyname));
459
460 /* Delete the original record and store the normalized key */
461 status = dbwrap_record_delete(rec);
462 if (!NT_STATUS_IS_OK(status)) {
463 DEBUG(0,("regdb_normalize_keynames_fn: "
464 "tdb_delete for [%s] failed!\n",
465 (const char *)key.dptr));
466 return 1;
467 }
468
469 status = dbwrap_store_bystring(db, keyname, value, TDB_REPLACE);
470 if (!NT_STATUS_IS_OK(status)) {
471 DEBUG(0,("regdb_normalize_keynames_fn: "
472 "failed to store new record for [%s]!\n",
473 keyname));
474 return 1;
475 }
476 }
477
478 return 0;
479 }
480
481 static WERROR regdb_store_regdb_version(struct db_context *db, uint32_t version)
482 {
483 NTSTATUS status;
484 if (db == NULL) {
485 return WERR_CAN_NOT_COMPLETE;
486 }
487
488 status = dbwrap_trans_store_int32_bystring(db, REGDB_VERSION_KEYNAME,
489 version);
490 if (!NT_STATUS_IS_OK(status)) {
491 DEBUG(1, ("regdb_store_regdb_version: error storing %s = %d: %s\n",
492 REGDB_VERSION_KEYNAME, version, nt_errstr(status)));
493 return ntstatus_to_werror(status);
494 } else {
495 DEBUG(10, ("regdb_store_regdb_version: stored %s = %d\n",
496 REGDB_VERSION_KEYNAME, version));
497 return WERR_OK;
498 }
499 }
500
501 static WERROR regdb_upgrade_v1_to_v2(struct db_context *db)
502 {
503 TALLOC_CTX *mem_ctx;
504 NTSTATUS status;
505 WERROR werr;
506
507 mem_ctx = talloc_stackframe();
508
509 status = dbwrap_traverse(db, regdb_normalize_keynames_fn, db, NULL);
510 if (!NT_STATUS_IS_OK(status)) {
511 werr = WERR_REG_IO_FAILURE;
512 goto done;
513 }
514
515 werr = regdb_store_regdb_version(db, REGDB_VERSION_V2);
516
517 done:
518 talloc_free(mem_ctx);
519 return werr;
520 }
521
522 static bool tdb_data_read_uint32(TDB_DATA *buf, uint32_t *result)
523 {
524 const size_t len = sizeof(uint32_t);
525 if (buf->dsize >= len) {
526 *result = IVAL(buf->dptr, 0);
527 buf->dptr += len;
528 buf->dsize -= len;
529 return true;
530 }
531 return false;
532 }
533
534 static bool tdb_data_read_cstr(TDB_DATA *buf, char **result)
535 {
536 const size_t len = strnlen((char*)buf->dptr, buf->dsize) + 1;
537 if (buf->dsize >= len) {
538 *result = (char*)buf->dptr;
539 buf->dptr += len;
540 buf->dsize -= len;
541 return true;
542 }
543 return false;
544 }
545
546 static bool tdb_data_is_cstr(TDB_DATA d) {
547 if (tdb_data_is_empty(d) || (d.dptr[d.dsize-1] != '\0')) {
548 return false;
549 }
550 return strchr((char *)d.dptr, '\0') == (char *)&d.dptr[d.dsize-1];
551 }
552
553 static bool upgrade_v2_to_v3_check_subkeylist(struct db_context *db,
554 const char *key,
555 const char *subkey)
556 {
557 static uint32_t zero = 0;
558 static TDB_DATA empty_subkey_list = {
559 .dptr = (unsigned char*)&zero,
560 .dsize = sizeof(uint32_t),
561 };
562 bool success = false;
563 char *path = talloc_asprintf(talloc_tos(), "%s\\%s", key, subkey);
564 strupper_m(path);
565
566 if (!dbwrap_exists(db, string_term_tdb_data(path))) {
567 NTSTATUS status;
568
569 DEBUG(10, ("regdb_upgrade_v2_to_v3: writing subkey list [%s]\n",
570 path));
571
572 status = dbwrap_store_bystring(db, path, empty_subkey_list,
573 TDB_INSERT);
574 if (!NT_STATUS_IS_OK(status)) {
575 DEBUG(0, ("regdb_upgrade_v2_to_v3: writing subkey list "
576 "[%s] failed\n", path));
577 goto done;
578 }
579 }
580 success = true;
581 done:
582 talloc_free(path);
583 return success;
584 }
585
586 static bool upgrade_v2_to_v3_check_parent(struct db_context *db,
587 const char *key)
588 {
589 const char *sep = strrchr_m(key, '\\');
590 if (sep != NULL) {
591 char *pkey = talloc_strndup(talloc_tos(), key, sep-key);
592 if (!dbwrap_exists(db, string_term_tdb_data(pkey))) {
593 DEBUG(0, ("regdb_upgrade_v2_to_v3: missing subkey list "
594 "[%s]\nrun \"net registry check\"\n", pkey));
595 }
596 talloc_free(pkey);
597 }
598 return true;
599 }
600
601
602 #define IS_EQUAL(d,s) (((d).dsize == strlen(s)+1) && \
603 (strcmp((char*)(d).dptr, (s)) == 0))
604 #define STARTS_WITH(d,s) (((d).dsize > strlen(s)) && \
605 (strncmp((char*)(d).dptr, (s), strlen(s)) == 0))
606 #define SSTR(d) (int)(d).dsize , (char*)(d).dptr
607
608
609 static int regdb_upgrade_v2_to_v3_fn(struct db_record *rec, void *private_data)
610 {
611 struct db_context *db = (struct db_context *)private_data;
612 TDB_DATA key = dbwrap_record_get_key(rec);
613 TDB_DATA val = dbwrap_record_get_value(rec);
614
615 if (tdb_data_is_empty(key)) {
616 return 0;
617 }
618
619 if (db == NULL) {
620 DEBUG(0, ("regdb_upgrade_v2_to_v3_fn: ERROR: "
621 "NULL db context handed in via private_data\n"));
622 return 1;
623 }
624
625 if (IS_EQUAL(key, REGDB_VERSION_KEYNAME) ||
626 STARTS_WITH(key, REG_VALUE_PREFIX) ||
627 STARTS_WITH(key, REG_SECDESC_PREFIX))
628 {
629 DEBUG(10, ("regdb_upgrade_v2_to_v3: skipping [%.*s]\n",
630 SSTR(key)));
631 return 0;
632 }
633
634 if (STARTS_WITH(key, REG_SORTED_SUBKEYS_PREFIX)) {
635 NTSTATUS status;
636 /* Delete the deprecated sorted subkeys cache. */
637
638 DEBUG(10, ("regdb_upgrade_v2_to_v3: deleting [%.*s]\n",
639 SSTR(key)));
640
641 status = dbwrap_record_delete(rec);
642 if (!NT_STATUS_IS_OK(status)) {
643 DEBUG(0, ("regdb_upgrade_v2_to_v3: deleting [%.*s] "
644 "failed!\n", SSTR(key)));
645 return 1;
646 }
647
648 return 0;
649 }
650
651 if ( tdb_data_is_cstr(key) &&
652 hive_info((char*)key.dptr) != NULL )
653 {
654 /*
655 * Found a regular subkey list record.
656 * Walk the list and create the list record for those
657 * subkeys that don't already have one.
658 */
659 TDB_DATA pos = val;
660 char *subkey, *path = (char*)key.dptr;
661 uint32_t num_items, found_items = 0;
662
663
664 DEBUG(10, ("regdb_upgrade_v2_to_v3: scanning subkeylist of "
665 "[%s]\n", path));
666
667 if (!tdb_data_read_uint32(&pos, &num_items)) {
668 /* invalid or empty - skip */
669 return 0;
670 }
671
672 while (tdb_data_read_cstr(&pos, &subkey)) {
673 found_items++;
674
675 if (!upgrade_v2_to_v3_check_subkeylist(db, path, subkey))
676 {
677 return 1;
678 }
679
680 if (!upgrade_v2_to_v3_check_parent(db, path)) {
681 return 1;
682 }
683 }
684 if (found_items != num_items) {
685 DEBUG(0, ("regdb_upgrade_v2_to_v3: inconsistent subkey "
686 "list [%s]\nrun \"net registry check\"\n",
687 path));
688 }
689 } else {
690 DEBUG(10, ("regdb_upgrade_v2_to_v3: skipping invalid [%.*s]\n"
691 "run \"net registry check\"\n", SSTR(key)));
692 }
693
694 return 0;
695 }
696
697 static WERROR regdb_upgrade_v2_to_v3(struct db_context *db)
698 {
699 NTSTATUS status;
700 WERROR werr;
701
702 status = dbwrap_traverse(db, regdb_upgrade_v2_to_v3_fn, db, NULL);
703 if (!NT_STATUS_IS_OK(status)) {
704 werr = WERR_REG_IO_FAILURE;
705 goto done;
706 }
707
708 werr = regdb_store_regdb_version(db, REGDB_VERSION_V3);
709
710 done:
711 return werr;
712 }
713
714 /***********************************************************************
715 Open the registry database
716 ***********************************************************************/
717
718 WERROR regdb_init(void)
719 {
720 int32_t vers_id;
721 WERROR werr;
722 NTSTATUS status;
723
724 if (regdb) {
725 DEBUG(10, ("regdb_init: incrementing refcount (%d->%d)\n",
726 regdb_refcount, regdb_refcount+1));
727 regdb_refcount++;
728 return WERR_OK;
729 }
730
731 regdb = db_open(NULL, state_path("registry.tdb"), 0,
732 REG_TDB_FLAGS, O_RDWR, 0600,
733 DBWRAP_LOCK_ORDER_1);
734 if (!regdb) {
735 regdb = db_open(NULL, state_path("registry.tdb"), 0,
736 REG_TDB_FLAGS, O_RDWR|O_CREAT, 0600,
737 DBWRAP_LOCK_ORDER_1);
738 if (!regdb) {
739 werr = ntstatus_to_werror(map_nt_error_from_unix(errno));
740 DEBUG(1,("regdb_init: Failed to open registry %s (%s)\n",
741 state_path("registry.tdb"), strerror(errno) ));
742 return werr;
743 }
744
745 werr = regdb_store_regdb_version(regdb, REGDB_CODE_VERSION);
746 if (!W_ERROR_IS_OK(werr)) {
747 DEBUG(1, ("regdb_init: Failed to store version: %s\n",
748 win_errstr(werr)));
749 return werr;
750 }
751
752 DEBUG(10,("regdb_init: Successfully created registry tdb\n"));
753 }
754
755 regdb_refcount = 1;
756 DEBUG(10, ("regdb_init: registry db openend. refcount reset (%d)\n",
757 regdb_refcount));
758
759 status = dbwrap_fetch_int32_bystring(regdb, REGDB_VERSION_KEYNAME,
760 &vers_id);
761 if (!NT_STATUS_IS_OK(status)) {
762 DEBUG(10, ("regdb_init: registry version uninitialized "
763 "(got %d), initializing to version %d\n",
764 vers_id, REGDB_VERSION_V1));
765
766 /*
767 * There was a regdb format version prior to version 1
768 * which did not store a INFO/version key. The format
769 * of this version was identical to version 1 except for
770 * the lack of the sorted subkey cache records.
771 * Since these are disposable, we can safely assume version
772 * 1 if no INFO/version key is found and run the db through
773 * the whole chain of upgrade. If the database was not
774 * initialized, this does not harm. If it was the unversioned
775 * version ("0"), then it do the right thing with the records.
776 */
777 werr = regdb_store_regdb_version(regdb, REGDB_VERSION_V1);
778 if (!W_ERROR_IS_OK(werr)) {
779 return werr;
780 }
781 vers_id = REGDB_VERSION_V1;
782 }
783
784 if (vers_id == REGDB_CODE_VERSION) {
785 return WERR_OK;
786 }
787
788 if (vers_id > REGDB_CODE_VERSION || vers_id == 0) {
789 DEBUG(0, ("regdb_init: unknown registry version %d "
790 "(code version = %d), refusing initialization\n",
791 vers_id, REGDB_CODE_VERSION));
792 return WERR_CAN_NOT_COMPLETE;
793 }
794
795 if (dbwrap_transaction_start(regdb) != 0) {
796 return WERR_REG_IO_FAILURE;
797 }
798
799 if (vers_id == REGDB_VERSION_V1) {
800 DEBUG(10, ("regdb_init: upgrading registry from version %d "
801 "to %d\n", REGDB_VERSION_V1, REGDB_VERSION_V2));
802
803 werr = regdb_upgrade_v1_to_v2(regdb);
804 if (!W_ERROR_IS_OK(werr)) {
805 dbwrap_transaction_cancel(regdb);
806 return werr;
807 }
808
809 vers_id = REGDB_VERSION_V2;
810 }
811
812 if (vers_id == REGDB_VERSION_V2) {
813 DEBUG(10, ("regdb_init: upgrading registry from version %d "
814 "to %d\n", REGDB_VERSION_V2, REGDB_VERSION_V3));
815
816 werr = regdb_upgrade_v2_to_v3(regdb);
817 if (!W_ERROR_IS_OK(werr)) {
818 dbwrap_transaction_cancel(regdb);
819 return werr;
820 }
821
822 vers_id = REGDB_VERSION_V3;
823 }
824
825 /* future upgrade code should go here */
826
827 if (dbwrap_transaction_commit(regdb) != 0) {
828 return WERR_REG_IO_FAILURE;
829 }
830
831 return WERR_OK;
832 }
833
834 /***********************************************************************
835 Open the registry. Must already have been initialized by regdb_init()
836 ***********************************************************************/
837
838 WERROR regdb_open( void )
839 {
840 WERROR result = WERR_OK;
841
842 if ( regdb ) {
843 DEBUG(10, ("regdb_open: incrementing refcount (%d->%d)\n",
844 regdb_refcount, regdb_refcount+1));
845 regdb_refcount++;
846 return WERR_OK;
847 }
848
849 become_root();
850
851 regdb = db_open(NULL, state_path("registry.tdb"), 0,
852 REG_TDB_FLAGS, O_RDWR, 0600,
853 DBWRAP_LOCK_ORDER_1);
854 if ( !regdb ) {
855 result = ntstatus_to_werror( map_nt_error_from_unix( errno ) );
856 DEBUG(0,("regdb_open: Failed to open %s! (%s)\n",
857 state_path("registry.tdb"), strerror(errno) ));
858 }
859
860 unbecome_root();
861
862 regdb_refcount = 1;
863 DEBUG(10, ("regdb_open: registry db opened. refcount reset (%d)\n",
864 regdb_refcount));
865
866 return result;
867 }
868
869 /***********************************************************************
870 ***********************************************************************/
871
872 int regdb_close( void )
873 {
874 if (regdb_refcount == 0) {
875 return 0;
876 }
877
878 regdb_refcount--;
879
880 DEBUG(10, ("regdb_close: decrementing refcount (%d->%d)\n",
881 regdb_refcount+1, regdb_refcount));
882
883 if ( regdb_refcount > 0 )
884 return 0;
885
886 SMB_ASSERT( regdb_refcount >= 0 );
887
888 TALLOC_FREE(regdb);
889 return 0;
890 }
891
892 WERROR regdb_transaction_start(void)
893 {
894 return (dbwrap_transaction_start(regdb) == 0) ?
895 WERR_OK : WERR_REG_IO_FAILURE;
896 }
897
898 WERROR regdb_transaction_commit(void)
899 {
900 return (dbwrap_transaction_commit(regdb) == 0) ?
901 WERR_OK : WERR_REG_IO_FAILURE;
902 }
903
904 WERROR regdb_transaction_cancel(void)
905 {
906 return (dbwrap_transaction_cancel(regdb) == 0) ?
907 WERR_OK : WERR_REG_IO_FAILURE;
908 }
909
910 /***********************************************************************
911 return the tdb sequence number of the registry tdb.
912 this is an indicator for the content of the registry
913 having changed. it will change upon regdb_init, too, though.
914 ***********************************************************************/
915 int regdb_get_seqnum(void)
916 {
917 return dbwrap_get_seqnum(regdb);
918 }
919
920
921 static WERROR regdb_delete_key_with_prefix(struct db_context *db,
922 const char *keyname,
923 const char *prefix)
924 {
925 char *path;
926 WERROR werr = WERR_NOMEM;
927 TALLOC_CTX *mem_ctx = talloc_stackframe();
928
929 if (keyname == NULL) {
930 werr = WERR_INVALID_PARAM;
931 goto done;
932 }
933
934 if (prefix == NULL) {
935 path = discard_const_p(char, keyname);
936 } else {
937 path = talloc_asprintf(mem_ctx, "%s\\%s", prefix, keyname);
938 if (path == NULL) {
939 goto done;
940 }
941 }
942
943 path = normalize_reg_path(mem_ctx, path);
944 if (path == NULL) {
945 goto done;
946 }
947
948 werr = ntstatus_to_werror(dbwrap_delete_bystring(db, path));
949
950 /* treat "not found" as ok */
951 if (W_ERROR_EQUAL(werr, WERR_NOT_FOUND)) {
952 werr = WERR_OK;
953 }
954
955 done:
956 talloc_free(mem_ctx);
957 return werr;
958 }
959
960
961 static WERROR regdb_delete_values(struct db_context *db, const char *keyname)
962 {
963 return regdb_delete_key_with_prefix(db, keyname, REG_VALUE_PREFIX);
964 }
965
966 static WERROR regdb_delete_secdesc(struct db_context *db, const char *keyname)
967 {
968 return regdb_delete_key_with_prefix(db, keyname, REG_SECDESC_PREFIX);
969 }
970
971 static WERROR regdb_delete_subkeylist(struct db_context *db, const char *keyname)
972 {
973 return regdb_delete_key_with_prefix(db, keyname, NULL);
974 }
975
976
977 static WERROR regdb_delete_key_lists(struct db_context *db, const char *keyname)
978 {
979 WERROR werr;
980
981 werr = regdb_delete_values(db, keyname);
982 if (!W_ERROR_IS_OK(werr)) {
983 DEBUG(1, (__location__ " Deleting %s\\%s failed: %s\n",
984 REG_VALUE_PREFIX, keyname, win_errstr(werr)));
985 goto done;
986 }
987
988 werr = regdb_delete_secdesc(db, keyname);
989 if (!W_ERROR_IS_OK(werr)) {
990 DEBUG(1, (__location__ " Deleting %s\\%s failed: %s\n",
991 REG_SECDESC_PREFIX, keyname, win_errstr(werr)));
992 goto done;
993 }
994
995 werr = regdb_delete_subkeylist(db, keyname);
996 if (!W_ERROR_IS_OK(werr)) {
997 DEBUG(1, (__location__ " Deleting %s failed: %s\n",
998 keyname, win_errstr(werr)));
999 goto done;
1000 }
1001
1002 done:
1003 return werr;
1004 }
1005
1006 /***********************************************************************
1007 Add subkey strings to the registry tdb under a defined key
1008 fmt is the same format as tdb_pack except this function only supports
1009 fstrings
1010 ***********************************************************************/
1011
1012 static WERROR regdb_store_keys_internal2(struct db_context *db,
1013 const char *key,
1014 struct regsubkey_ctr *ctr)
1015 {
1016 TDB_DATA dbuf;
1017 uint8 *buffer = NULL;
1018 int i = 0;
1019 uint32 len, buflen;
1020 uint32 num_subkeys = regsubkey_ctr_numkeys(ctr);
1021 char *keyname = NULL;
1022 TALLOC_CTX *ctx = talloc_stackframe();
1023 WERROR werr;
1024
1025 if (!key) {
1026 werr = WERR_INVALID_PARAM;
1027 goto done;
1028 }
1029
1030 keyname = talloc_strdup(ctx, key);
1031 if (!keyname) {
1032 werr = WERR_NOMEM;
1033 goto done;
1034 }
1035
1036 keyname = normalize_reg_path(ctx, keyname);
1037 if (!keyname) {
1038 werr = WERR_NOMEM;
1039 goto done;
1040 }
1041
1042 /* allocate some initial memory */
1043
1044 buffer = (uint8 *)SMB_MALLOC(1024);
1045 if (buffer == NULL) {
1046 werr = WERR_NOMEM;
1047 goto done;
1048 }
1049 buflen = 1024;
1050 len = 0;
1051
1052 /* store the number of subkeys */
1053
1054 len += tdb_pack(buffer+len, buflen-len, "d", num_subkeys);
1055
1056 /* pack all the strings */
1057
1058 for (i=0; i<num_subkeys; i++) {
1059 size_t thistime;
1060
1061 thistime = tdb_pack(buffer+len, buflen-len, "f",
1062 regsubkey_ctr_specific_key(ctr, i));
1063 if (len+thistime > buflen) {
1064 size_t thistime2;
1065 /*
1066 * tdb_pack hasn't done anything because of the short
1067 * buffer, allocate extra space.
1068 */
1069 buffer = SMB_REALLOC_ARRAY(buffer, uint8_t,
1070 (len+thistime)*2);
1071 if(buffer == NULL) {
1072 DEBUG(0, ("regdb_store_keys: Failed to realloc "
1073 "memory of size [%u]\n",
1074 (unsigned int)(len+thistime)*2));
1075 werr = WERR_NOMEM;
1076 goto done;
1077 }
1078 buflen = (len+thistime)*2;
1079 thistime2 = tdb_pack(
1080 buffer+len, buflen-len, "f",
1081 regsubkey_ctr_specific_key(ctr, i));
1082 if (thistime2 != thistime) {
1083 DEBUG(0, ("tdb_pack failed\n"));
1084 werr = WERR_CAN_NOT_COMPLETE;
1085 goto done;
1086 }
1087 }
1088 len += thistime;
1089 }
1090
1091 /* finally write out the data */
1092
1093 dbuf.dptr = buffer;
1094 dbuf.dsize = len;
1095 werr = ntstatus_to_werror(dbwrap_store_bystring(db, keyname, dbuf,
1096 TDB_REPLACE));
1097
1098 done:
1099 TALLOC_FREE(ctx);
1100 SAFE_FREE(buffer);
1101 return werr;
1102 }
1103
1104 /**
1105 * Utility function to store a new empty list of
1106 * subkeys of given key specified as parent and subkey name
1107 * (thereby creating the key).
1108 * If the parent keyname is NULL, then the "subkey" is
1109 * interpreted as a base key.
1110 * If the subkey list does already exist, it is not modified.
1111 *
1112 * Must be called from within a transaction.
1113 */
1114 static WERROR regdb_store_subkey_list(struct db_context *db, const char *parent,
1115 const char *key)
1116 {
1117 WERROR werr;
1118 char *path = NULL;
1119 struct regsubkey_ctr *subkeys = NULL;
1120 TALLOC_CTX *frame = talloc_stackframe();
1121
1122 if (parent == NULL) {
1123 path = talloc_strdup(frame, key);
1124 } else {
1125 path = talloc_asprintf(frame, "%s\\%s", parent, key);
1126 }
1127 if (!path) {
1128 werr = WERR_NOMEM;
1129 goto done;
1130 }
1131
1132 werr = regsubkey_ctr_init(frame, &subkeys);
1133 W_ERROR_NOT_OK_GOTO_DONE(werr);
1134
1135 werr = regdb_fetch_keys_internal(db, path, subkeys);
1136 if (W_ERROR_IS_OK(werr)) {
1137 /* subkey list exists already - don't modify */
1138 goto done;
1139 }
1140
1141 werr = regsubkey_ctr_reinit(subkeys);
1142 W_ERROR_NOT_OK_GOTO_DONE(werr);
1143
1144 /* create a record with 0 subkeys */
1145 werr = regdb_store_keys_internal2(db, path, subkeys);
1146 if (!W_ERROR_IS_OK(werr)) {
1147 DEBUG(0, ("regdb_store_keys: Failed to store new record for "
1148 "key [%s]: %s\n", path, win_errstr(werr)));
1149 goto done;
1150 }
1151
1152 done:
1153 talloc_free(frame);
1154 return werr;
1155 }
1156
1157 /***********************************************************************
1158 Store the new subkey record and create any child key records that
1159 do not currently exist
1160 ***********************************************************************/
1161
1162 struct regdb_store_keys_context {
1163 const char *key;
1164 struct regsubkey_ctr *ctr;
1165 };
1166
1167 static NTSTATUS regdb_store_keys_action(struct db_context *db,
1168 void *private_data)
1169 {
1170 struct regdb_store_keys_context *store_ctx;
1171 WERROR werr;
1172 int num_subkeys, i;
1173 char *path = NULL;
1174 struct regsubkey_ctr *old_subkeys = NULL;
1175 char *oldkeyname = NULL;
1176 TALLOC_CTX *mem_ctx = talloc_stackframe();
1177
1178 store_ctx = (struct regdb_store_keys_context *)private_data;
1179
1180 /*
1181 * Re-fetch the old keys inside the transaction
1182 */
1183
1184 werr = regsubkey_ctr_init(mem_ctx, &old_subkeys);
1185 W_ERROR_NOT_OK_GOTO_DONE(werr);
1186
1187 werr = regdb_fetch_keys_internal(db, store_ctx->key, old_subkeys);
1188 if (!W_ERROR_IS_OK(werr) &&
1189 !W_ERROR_EQUAL(werr, WERR_NOT_FOUND))
1190 {
1191 goto done;
1192 }
1193
1194 /*
1195 * Make the store operation as safe as possible without transactions:
1196 *
1197 * (1) For each subkey removed from ctr compared with old_subkeys:
1198 *
1199 * (a) First delete the value db entry.
1200 *
1201 * (b) Next delete the secdesc db record.
1202 *
1203 * (c) Then delete the subkey list entry.
1204 *
1205 * (2) Now write the list of subkeys of the parent key,
1206 * deleting removed entries and adding new ones.
1207 *
1208 * (3) Finally create the subkey list entries for the added keys.
1209 *
1210 * This way if we crash half-way in between deleting the subkeys
1211 * and storing the parent's list of subkeys, no old data can pop up
1212 * out of the blue when re-adding keys later on.
1213 */
1214
1215 /* (1) delete removed keys' lists (values/secdesc/subkeys) */
1216
1217 num_subkeys = regsubkey_ctr_numkeys(old_subkeys);
1218 for (i=0; i<num_subkeys; i++) {
1219 oldkeyname = regsubkey_ctr_specific_key(old_subkeys, i);
1220
1221 if (regsubkey_ctr_key_exists(store_ctx->ctr, oldkeyname)) {
1222 /*
1223 * It's still around, don't delete
1224 */
1225 continue;
1226 }
1227
1228 path = talloc_asprintf(mem_ctx, "%s\\%s", store_ctx->key,
1229 oldkeyname);
1230 if (!path) {
1231 werr = WERR_NOMEM;
1232 goto done;
1233 }
1234
1235 werr = regdb_delete_key_lists(db, path);
1236 W_ERROR_NOT_OK_GOTO_DONE(werr);
1237
1238 TALLOC_FREE(path);
1239 }
1240
1241 TALLOC_FREE(old_subkeys);
1242
1243 /* (2) store the subkey list for the parent */
1244
1245 werr = regdb_store_keys_internal2(db, store_ctx->key, store_ctx->ctr);
1246 if (!W_ERROR_IS_OK(werr)) {
1247 DEBUG(0,("regdb_store_keys: Failed to store new subkey list "
1248 "for parent [%s]: %s\n", store_ctx->key,
1249 win_errstr(werr)));
1250 goto done;
1251 }
1252
1253 /* (3) now create records for any subkeys that don't already exist */
1254
1255 num_subkeys = regsubkey_ctr_numkeys(store_ctx->ctr);
1256
1257 for (i=0; i<num_subkeys; i++) {
1258 const char *subkey;
1259
1260 subkey = regsubkey_ctr_specific_key(store_ctx->ctr, i);
1261
1262 werr = regdb_store_subkey_list(db, store_ctx->key, subkey);
1263 W_ERROR_NOT_OK_GOTO_DONE(werr);
1264 }
1265
1266 /*
1267 * Update the seqnum in the container to possibly
1268 * prevent next read from going to disk
1269 */
1270 werr = regsubkey_ctr_set_seqnum(store_ctx->ctr, dbwrap_get_seqnum(db));
1271
1272 done:
1273 talloc_free(mem_ctx);
1274 return werror_to_ntstatus(werr);
1275 }
1276
1277 static bool regdb_store_keys_internal(struct db_context *db, const char *key,
1278 struct regsubkey_ctr *ctr)
1279 {
1280 int num_subkeys, old_num_subkeys, i;
1281 struct regsubkey_ctr *old_subkeys = NULL;
1282 TALLOC_CTX *ctx = talloc_stackframe();
1283 WERROR werr;
1284 bool ret = false;
1285 struct regdb_store_keys_context store_ctx;
1286
1287 if (!regdb_key_exists(db, key)) {
1288 goto done;
1289 }
1290
1291 /*
1292 * fetch a list of the old subkeys so we can determine if anything has
1293 * changed
1294 */
1295
1296 werr = regsubkey_ctr_init(ctx, &old_subkeys);
1297 if (!W_ERROR_IS_OK(werr)) {
1298 DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
1299 goto done;
1300 }
1301
1302 werr = regdb_fetch_keys_internal(db, key, old_subkeys);
1303 if (!W_ERROR_IS_OK(werr) &&
1304 !W_ERROR_EQUAL(werr, WERR_NOT_FOUND))
1305 {
1306 goto done;
1307 }
1308
1309 num_subkeys = regsubkey_ctr_numkeys(ctr);
1310 old_num_subkeys = regsubkey_ctr_numkeys(old_subkeys);
1311 if ((num_subkeys && old_num_subkeys) &&
1312 (num_subkeys == old_num_subkeys)) {
1313
1314 for (i = 0; i < num_subkeys; i++) {
1315 if (strcmp(regsubkey_ctr_specific_key(ctr, i),
1316 regsubkey_ctr_specific_key(old_subkeys, i))
1317 != 0)
1318 {
1319 break;
1320 }
1321 }
1322 if (i == num_subkeys) {
1323 /*
1324 * Nothing changed, no point to even start a tdb
1325 * transaction
1326 */
1327
1328 ret = true;
1329 goto done;
1330 }
1331 }
1332
1333 TALLOC_FREE(old_subkeys);
1334
1335 store_ctx.key = key;
1336 store_ctx.ctr = ctr;
1337
1338 werr = regdb_trans_do(db,
1339 regdb_store_keys_action,
1340 &store_ctx);
1341
1342 ret = W_ERROR_IS_OK(werr);
1343
1344 done:
1345 TALLOC_FREE(ctx);
1346
1347 return ret;
1348 }
1349
1350 static bool regdb_store_keys(const char *key, struct regsubkey_ctr *ctr)
1351 {
1352 return regdb_store_keys_internal(regdb, key, ctr);
1353 }
1354
1355 /**
1356 * create a subkey of a given key
1357 */
1358
1359 struct regdb_create_subkey_context {
1360 const char *key;
1361 const char *subkey;
1362 };
1363
1364 static NTSTATUS regdb_create_subkey_action(struct db_context *db,
1365 void *private_data)
1366 {
1367 WERROR werr;
1368 struct regdb_create_subkey_context *create_ctx;
1369 struct regsubkey_ctr *subkeys;
1370 TALLOC_CTX *mem_ctx = talloc_stackframe();
1371
1372 create_ctx = (struct regdb_create_subkey_context *)private_data;
1373
1374 werr = regsubkey_ctr_init(mem_ctx, &subkeys);
1375 W_ERROR_NOT_OK_GOTO_DONE(werr);
1376
1377 werr = regdb_fetch_keys_internal(db, create_ctx->key, subkeys);
1378 W_ERROR_NOT_OK_GOTO_DONE(werr);
1379
1380 werr = regsubkey_ctr_addkey(subkeys, create_ctx->subkey);
1381 W_ERROR_NOT_OK_GOTO_DONE(werr);
1382
1383 werr = regdb_store_keys_internal2(db, create_ctx->key, subkeys);
1384 if (!W_ERROR_IS_OK(werr)) {
1385 DEBUG(0, (__location__ " failed to store new subkey list for "
1386 "parent key %s: %s\n", create_ctx->key,
1387 win_errstr(werr)));
1388 }
1389
1390 werr = regdb_store_subkey_list(db, create_ctx->key, create_ctx->subkey);
1391
1392 done:
1393 talloc_free(mem_ctx);
1394 return werror_to_ntstatus(werr);
1395 }
1396
1397 static WERROR regdb_create_subkey_internal(struct db_context *db,
1398 const char *key,
1399 const char *subkey)
1400 {
1401 WERROR werr;
1402 struct regsubkey_ctr *subkeys;
1403 TALLOC_CTX *mem_ctx = talloc_stackframe();
1404 struct regdb_create_subkey_context create_ctx;
1405
1406 if (!regdb_key_exists(db, key)) {
1407 werr = WERR_NOT_FOUND;
1408 goto done;
1409 }
1410
1411 werr = regsubkey_ctr_init(mem_ctx, &subkeys);
1412 W_ERROR_NOT_OK_GOTO_DONE(werr);
1413
1414 werr = regdb_fetch_keys_internal(db, key, subkeys);
1415 W_ERROR_NOT_OK_GOTO_DONE(werr);
1416
1417 if (regsubkey_ctr_key_exists(subkeys, subkey)) {
1418 char *newkey;
1419
1420 newkey = talloc_asprintf(mem_ctx, "%s\\%s", key, subkey);
1421 if (newkey == NULL) {
1422 werr = WERR_NOMEM;
1423 goto done;
1424 }
1425
1426 if (regdb_key_exists(db, newkey)) {
1427 werr = WERR_OK;
1428 goto done;
1429 }
1430 }
1431
1432 talloc_free(subkeys);
1433
1434 create_ctx.key = key;
1435 create_ctx.subkey = subkey;
1436
1437 werr = regdb_trans_do(db,
1438 regdb_create_subkey_action,
1439 &create_ctx);
1440
1441 done:
1442 talloc_free(mem_ctx);
1443 return werr;
1444 }
1445
1446 static WERROR regdb_create_subkey(const char *key, const char *subkey)
1447 {
1448 return regdb_create_subkey_internal(regdb, key, subkey);
1449 }
1450
1451 /**
1452 * create a base key
1453 */
1454
1455 struct regdb_create_basekey_context {
1456 const char *key;
1457 };
1458
1459 static NTSTATUS regdb_create_basekey_action(struct db_context *db,
1460 void *private_data)
1461 {
1462 WERROR werr;
1463 struct regdb_create_basekey_context *create_ctx;
1464
1465 create_ctx = (struct regdb_create_basekey_context *)private_data;
1466
1467 werr = regdb_store_subkey_list(db, NULL, create_ctx->key);
1468
1469 return werror_to_ntstatus(werr);
1470 }
1471
1472 static WERROR regdb_create_basekey(struct db_context *db, const char *key)
1473 {
1474 WERROR werr;
1475 struct regdb_create_subkey_context create_ctx;
1476
1477 create_ctx.key = key;
1478
1479 werr = regdb_trans_do(db,
1480 regdb_create_basekey_action,
1481 &create_ctx);
1482
1483 return werr;
1484 }
1485
1486 /**
1487 * create a subkey of a given key
1488 */
1489
1490 struct regdb_delete_subkey_context {
1491 const char *key;
1492 const char *subkey;
1493 const char *path;
1494 bool lazy;
1495 };
1496
1497 static NTSTATUS regdb_delete_subkey_action(struct db_context *db,
1498 void *private_data)
1499 {
1500 WERROR werr;
1501 struct regdb_delete_subkey_context *delete_ctx;
1502 struct regsubkey_ctr *subkeys;
1503 TALLOC_CTX *mem_ctx = talloc_stackframe();
1504
1505 delete_ctx = (struct regdb_delete_subkey_context *)private_data;
1506
1507 werr = regdb_delete_key_lists(db, delete_ctx->path);
1508 W_ERROR_NOT_OK_GOTO_DONE(werr);
1509
1510 if (delete_ctx->lazy) {
1511 goto done;
1512 }
1513
1514 werr = regsubkey_ctr_init(mem_ctx, &subkeys);
1515 W_ERROR_NOT_OK_GOTO_DONE(werr);
1516
1517 werr = regdb_fetch_keys_internal(db, delete_ctx->key, subkeys);
1518 W_ERROR_NOT_OK_GOTO_DONE(werr);
1519
1520 werr = regsubkey_ctr_delkey(subkeys, delete_ctx->subkey);
1521 W_ERROR_NOT_OK_GOTO_DONE(werr);
1522
1523 werr = regdb_store_keys_internal2(db, delete_ctx->key, subkeys);
1524 if (!W_ERROR_IS_OK(werr)) {
1525 DEBUG(0, (__location__ " failed to store new subkey_list for "
1526 "parent key %s: %s\n", delete_ctx->key,
1527 win_errstr(werr)));
1528 }
1529
1530 done:
1531 talloc_free(mem_ctx);
1532 return werror_to_ntstatus(werr);
1533 }
1534
1535 static WERROR regdb_delete_subkey(const char *key, const char *subkey, bool lazy)
1536 {
1537 WERROR werr;
1538 char *path;
1539 struct regdb_delete_subkey_context delete_ctx;
1540 TALLOC_CTX *mem_ctx = talloc_stackframe();
1541
1542 if (!regdb_key_exists(regdb, key)) {
1543 werr = WERR_NOT_FOUND;
1544 goto done;
1545 }
1546
1547 path = talloc_asprintf(mem_ctx, "%s\\%s", key, subkey);
1548 if (path == NULL) {
1549 werr = WERR_NOMEM;
1550 goto done;
1551 }
1552
1553 if (!regdb_key_exists(regdb, path)) {
1554 werr = WERR_OK;
1555 goto done;
1556 }
1557
1558 delete_ctx.key = key;
1559 delete_ctx.subkey = subkey;
1560 delete_ctx.path = path;
1561 delete_ctx.lazy = lazy;
1562
1563 werr = regdb_trans_do(regdb,
1564 regdb_delete_subkey_action,
1565 &delete_ctx);
1566
1567 done:
1568 talloc_free(mem_ctx);
1569 return werr;
1570 }
1571
1572 static TDB_DATA regdb_fetch_key_internal(struct db_context *db,
1573 TALLOC_CTX *mem_ctx, const char *key)
1574 {
1575 char *path = NULL;
1576 TDB_DATA data;
1577 NTSTATUS status;
1578
1579 path = normalize_reg_path(mem_ctx, key);
1580 if (!path) {
1581 return make_tdb_data(NULL, 0);
1582 }
1583
1584 status = dbwrap_fetch_bystring(db, mem_ctx, path, &data);
1585 if (!NT_STATUS_IS_OK(status)) {
1586 data = tdb_null;
1587 }
1588
1589 TALLOC_FREE(path);
1590 return data;
1591 }
1592
1593
1594 /**
1595 * Check for the existence of a key.
1596 *
1597 * Existence of a key is authoritatively defined by
1598 * the existence of the record that contains the list
1599 * of its subkeys.
1600 *
1601 * Return false, if the record does not match the correct
1602 * structure of an initial 4-byte counter and then a
1603 * list of the corresponding number of zero-terminated
1604 * strings.
1605 */
1606 static bool regdb_key_exists(struct db_context *db, const char *key)
1607 {
1608 TALLOC_CTX *mem_ctx = talloc_stackframe();
1609 TDB_DATA value;
1610 bool ret = false;
1611 char *path;
1612 uint32_t buflen;
1613 const char *buf;
1614 uint32_t num_items, i;
1615 int32_t len;
1616
1617 if (key == NULL) {
1618 goto done;
1619 }
1620
1621 path = normalize_reg_path(mem_ctx, key);
1622 if (path == NULL) {
1623 DEBUG(0, ("out of memory! (talloc failed)\n"));
1624 goto done;
1625 }
1626
1627 if (*path == '\0') {
1628 goto done;
1629 }
1630
1631 value = regdb_fetch_key_internal(db, mem_ctx, path);
1632 if (value.dptr == NULL) {
1633 goto done;
1634 }
1635
1636 if (value.dsize == 0) {
1637 DEBUG(10, ("regdb_key_exists: subkeylist-record for key "
1638 "[%s] is empty: Could be a deleted record in a "
1639 "clustered (ctdb) environment?\n",
1640 path));
1641 goto done;
1642 }
1643
1644 len = tdb_unpack(value.dptr, value.dsize, "d", &num_items);
1645 if (len == (int32_t)-1) {
1646 DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record for key "
1647 "[%s] is invalid: Could not parse initial 4-byte "
1648 "counter. record data length is %u.\n",
1649 path, (unsigned int)value.dsize));
1650 goto done;
1651 }
1652
1653 /*
1654 * Note: the tdb_unpack check above implies that len <= value.dsize
1655 */
1656 buflen = value.dsize - len;
1657 buf = (const char *)value.dptr + len;
1658
1659 len = 0;
1660
1661 for (i = 0; i < num_items; i++) {
1662 if (buflen == 0) {
1663 break;
1664 }
1665 len = strnlen(buf, buflen) + 1;
1666 if (buflen < len) {
1667 DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record "
1668 "for key [%s] is corrupt: %u items expected, "
1669 "item number %u is not zero terminated.\n",
1670 path, num_items, i+1));
1671 goto done;
1672 }
1673
1674 buf += len;
1675 buflen -= len;
1676 }
1677
1678 if (buflen > 0) {
1679 DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record for key "
1680 "[%s] is corrupt: %u items expected and found, but "
1681 "the record contains additional %u bytes\n",
1682 path, num_items, buflen));
1683 goto done;
1684 }
1685
1686 if (i < num_items) {
1687 DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record for key "
1688 "[%s] is corrupt: %u items expected, but only %u "
1689 "items found.\n",
1690 path, num_items, i+1));
1691 goto done;
1692 }
1693
1694 ret = true;
1695
1696 done:
1697 TALLOC_FREE(mem_ctx);
1698 return ret;
1699 }
1700
1701
1702 /***********************************************************************
1703 Retrieve an array of strings containing subkeys. Memory should be
1704 released by the caller.
1705 ***********************************************************************/
1706
1707 static WERROR regdb_fetch_keys_internal(struct db_context *db, const char *key,
1708 struct regsubkey_ctr *ctr)
1709 {
1710 WERROR werr;
1711 uint32_t num_items;
1712 uint8 *buf;
1713 uint32 buflen, len;
1714 int i;
1715 fstring subkeyname;
1716 TALLOC_CTX *frame = talloc_stackframe();
1717 TDB_DATA value;
1718 int seqnum[2], count;
1719
1720 DEBUG(11,("regdb_fetch_keys: Enter key => [%s]\n", key ? key : "NULL"));
1721
1722 if (!regdb_key_exists(db, key)) {
1723 DEBUG(10, ("key [%s] not found\n", key));
1724 werr = WERR_NOT_FOUND;
1725 goto done;
1726 }
1727
1728 werr = regsubkey_ctr_reinit(ctr);
1729 W_ERROR_NOT_OK_GOTO_DONE(werr);
1730
1731 count = 0;
1732 ZERO_STRUCT(value);
1733 seqnum[0] = dbwrap_get_seqnum(db);
1734
1735 do {
1736 count++;
1737 TALLOC_FREE(value.dptr);
1738 value = regdb_fetch_key_internal(db, frame, key);
1739 seqnum[count % 2] = dbwrap_get_seqnum(db);
1740
1741 } while (seqnum[0] != seqnum[1]);
1742
1743 if (count > 1) {
1744 DEBUG(5, ("regdb_fetch_keys_internal: it took %d attempts to "
1745 "fetch key '%s' with constant seqnum\n",
1746 count, key));
1747 }
1748
1749 werr = regsubkey_ctr_set_seqnum(ctr, seqnum[0]);
1750 if (!W_ERROR_IS_OK(werr)) {
1751 goto done;
1752 }
1753
1754 if (value.dsize == 0 || value.dptr == NULL) {
1755 DEBUG(10, ("regdb_fetch_keys: no subkeys found for key [%s]\n",
1756 key));
1757 goto done;
1758 }
1759
1760 buf = value.dptr;
1761 buflen = value.dsize;
1762 len = tdb_unpack( buf, buflen, "d", &num_items);
1763 if (len == (uint32_t)-1) {
1764 werr = WERR_NOT_FOUND;
1765 goto done;
1766 }
1767
1768 for (i=0; i<num_items; i++) {
1769 len += tdb_unpack(buf+len, buflen-len, "f", subkeyname);
1770 werr = regsubkey_ctr_addkey(ctr, subkeyname);
1771 if (!W_ERROR_IS_OK(werr)) {
1772 DEBUG(5, ("regdb_fetch_keys: regsubkey_ctr_addkey "
1773 "failed: %s\n", win_errstr(werr)));
1774 num_items = 0;
1775 goto done;
1776 }
1777 }
1778
1779 DEBUG(11,("regdb_fetch_keys: Exit [%d] items\n", num_items));
1780
1781 done:
1782 TALLOC_FREE(frame);
1783 return werr;
1784 }
1785
1786 static int regdb_fetch_keys(const char *key, struct regsubkey_ctr *ctr)
1787 {
1788 WERROR werr;
1789
1790 werr = regdb_fetch_keys_internal(regdb, key, ctr);
1791 if (!W_ERROR_IS_OK(werr)) {
1792 return -1;
1793 }
1794
1795 return regsubkey_ctr_numkeys(ctr);
1796 }
1797
1798 /****************************************************************************
1799 Unpack a list of registry values frem the TDB
1800 ***************************************************************************/
1801
1802 static int regdb_unpack_values(struct regval_ctr *values, uint8 *buf, int buflen)
1803 {
1804 int len = 0;
1805 uint32 type;
1806 fstring valuename;
1807 uint32 size;
1808 uint8 *data_p;
1809 uint32 num_values = 0;
1810 int i;
1811
1812 /* loop and unpack the rest of the registry values */
1813
1814 len += tdb_unpack(buf+len, buflen-len, "d", &num_values);
1815
1816 for ( i=0; i<num_values; i++ ) {
1817 /* unpack the next regval */
1818
1819 type = REG_NONE;
1820 size = 0;
1821 data_p = NULL;
1822 valuename[0] = '\0';
1823 len += tdb_unpack(buf+len, buflen-len, "fdB",
1824 valuename,
1825 &type,
1826 &size,
1827 &data_p);
1828
1829 regval_ctr_addvalue(values, valuename, type,
1830 (uint8_t *)data_p, size);
1831 SAFE_FREE(data_p); /* 'B' option to tdb_unpack does a malloc() */
1832
1833 DEBUG(10, ("regdb_unpack_values: value[%d]: name[%s] len[%d]\n",
1834 i, valuename, size));
1835 }
1836
1837 return len;
1838 }
1839
1840 /****************************************************************************
1841 Pack all values in all printer keys
1842 ***************************************************************************/
1843
1844 static int regdb_pack_values(struct regval_ctr *values, uint8 *buf, int buflen)
1845 {
1846 int len = 0;
1847 int i;
1848 struct regval_blob *val;
1849 int num_values;
1850
1851 if ( !values )
1852 return 0;
1853
1854 num_values = regval_ctr_numvals( values );
1855
1856 /* pack the number of values first */
1857
1858 len += tdb_pack( buf+len, buflen-len, "d", num_values );
1859
1860 /* loop over all values */
1861
1862 for ( i=0; i<num_values; i++ ) {
1863 val = regval_ctr_specific_value( values, i );
1864 len += tdb_pack(buf+len, buflen-len, "fdB",
1865 regval_name(val),
1866 regval_type(val),
1867 regval_size(val),
1868 regval_data_p(val) );
1869 }
1870
1871 return len;
1872 }
1873
1874 /***********************************************************************
1875 Retrieve an array of strings containing subkeys. Memory should be
1876 released by the caller.
1877 ***********************************************************************/
1878
1879 static int regdb_fetch_values_internal(struct db_context *db, const char* key,
1880 struct regval_ctr *values)
1881 {
1882 char *keystr = NULL;
1883 TALLOC_CTX *ctx = talloc_stackframe();
1884 int ret = 0;
1885 TDB_DATA value;
1886 WERROR werr;
1887 int seqnum[2], count;
1888
1889 DEBUG(10,("regdb_fetch_values: Looking for values of key [%s]\n", key));
1890
1891 if (!regdb_key_exists(db, key)) {
1892 DEBUG(10, ("regb_fetch_values: key [%s] does not exist\n",
1893 key));
1894 ret = -1;
1895 goto done;
1896 }
1897
1898 keystr = talloc_asprintf(ctx, "%s\\%s", REG_VALUE_PREFIX, key);
1899 if (!keystr) {
1900 goto done;
1901 }
1902
1903 ZERO_STRUCT(value);
1904 count = 0;
1905 seqnum[0] = dbwrap_get_seqnum(db);
1906
1907 do {
1908 count++;
1909 TALLOC_FREE(value.dptr);
1910 value = regdb_fetch_key_internal(db, ctx, keystr);
1911 seqnum[count % 2] = dbwrap_get_seqnum(db);
1912 } while (seqnum[0] != seqnum[1]);
1913
1914 if (count > 1) {
1915 DEBUG(5, ("regdb_fetch_values_internal: it took %d attempts "
1916 "to fetch key '%s' with constant seqnum\n",
1917 count, key));
1918 }
1919
1920 werr = regval_ctr_set_seqnum(values, seqnum[0]);
1921 if (!W_ERROR_IS_OK(werr)) {
1922 goto done;
1923 }
1924
1925 if (!value.dptr) {
1926 /* all keys have zero values by default */
1927 goto done;
1928 }
1929
1930 regdb_unpack_values(values, value.dptr, value.dsize);
1931 ret = regval_ctr_numvals(values);
1932
1933 done:
1934 TALLOC_FREE(ctx);
1935 return ret;
1936 }
1937
1938 static int regdb_fetch_values(const char* key, struct regval_ctr *values)
1939 {
1940 return regdb_fetch_values_internal(regdb, key, values);
1941 }
1942
1943 static NTSTATUS regdb_store_values_internal(struct db_context *db,
1944 const char *key,
1945 struct regval_ctr *values)
1946 {
1947 TDB_DATA old_data, data;
1948 char *keystr = NULL;
1949 TALLOC_CTX *ctx = talloc_stackframe();
1950 int len;
1951 NTSTATUS status;
1952 WERROR werr;
1953
1954 DEBUG(10,("regdb_store_values: Looking for values of key [%s]\n", key));
1955
1956 if (!regdb_key_exists(db, key)) {
1957 status = NT_STATUS_NOT_FOUND;
1958 goto done;
1959 }
1960
1961 if (regval_ctr_numvals(values) == 0) {
1962 werr = regdb_delete_values(db, key);
1963 if (!W_ERROR_IS_OK(werr)) {
1964 return werror_to_ntstatus(werr);
1965 }
1966
1967 /*
1968 * update the seqnum in the cache to prevent the next read
1969 * from going to disk
1970 */
1971 werr = regval_ctr_set_seqnum(values, dbwrap_get_seqnum(db));
1972 return werror_to_ntstatus(werr);
1973 }
1974
1975 ZERO_STRUCT(data);
1976
1977 len = regdb_pack_values(values, data.dptr, data.dsize);
1978 if (len <= 0) {
1979 DEBUG(0,("regdb_store_values: unable to pack values. len <= 0\n"));
1980 status = NT_STATUS_UNSUCCESSFUL;
1981 goto done;
1982 }
1983
1984 data.dptr = talloc_array(ctx, uint8, len);
1985 data.dsize = len;
1986
1987 len = regdb_pack_values(values, data.dptr, data.dsize);
1988
1989 SMB_ASSERT( len == data.dsize );
1990
1991 keystr = talloc_asprintf(ctx, "%s\\%s", REG_VALUE_PREFIX, key );
1992 if (!keystr) {
1993 status = NT_STATUS_NO_MEMORY;
1994 goto done;
1995 }
1996 keystr = normalize_reg_path(ctx, keystr);
1997 if (!keystr) {
1998 status = NT_STATUS_NO_MEMORY;
1999 goto done;
2000 }
2001
2002 status = dbwrap_fetch_bystring(db, ctx, keystr, &old_data);
2003
2004 if (NT_STATUS_IS_OK(status)
2005 && (old_data.dptr != NULL)
2006 && (old_data.dsize == data.dsize)
2007 && (memcmp(old_data.dptr, data.dptr, data.dsize) == 0))
2008 {
2009 status = NT_STATUS_OK;
2010 goto done;
2011 }
2012
2013 status = dbwrap_trans_store_bystring(db, keystr, data, TDB_REPLACE);
2014 if (!NT_STATUS_IS_OK(status)) {
2015 DEBUG(0, ("regdb_store_values_internal: error storing: %s\n", nt_errstr(status)));
2016 goto done;
2017 }
2018
2019 /*
2020 * update the seqnum in the cache to prevent the next read
2021 * from going to disk
2022 */
2023 werr = regval_ctr_set_seqnum(values, dbwrap_get_seqnum(db));
2024 status = werror_to_ntstatus(werr);
2025
2026 done:
2027 TALLOC_FREE(ctx);
2028 return status;
2029 }
2030
2031 struct regdb_store_values_ctx {
2032 const char *key;
2033 struct regval_ctr *values;
2034 };
2035
2036 static NTSTATUS regdb_store_values_action(struct db_context *db,
2037 void *private_data)
2038 {
2039 NTSTATUS status;
2040 struct regdb_store_values_ctx *ctx =
2041 (struct regdb_store_values_ctx *)private_data;
2042
2043 status = regdb_store_values_internal(db, ctx->key, ctx->values);
2044
2045 return status;
2046 }
2047
2048 static bool regdb_store_values(const char *key, struct regval_ctr *values)
2049 {
2050 WERROR werr;
2051 struct regdb_store_values_ctx ctx;
2052
2053 ctx.key = key;
2054 ctx.values = values;
2055
2056 werr = regdb_trans_do(regdb, regdb_store_values_action, &ctx);
2057
2058 return W_ERROR_IS_OK(werr);
2059 }
2060
2061 static WERROR regdb_get_secdesc(TALLOC_CTX *mem_ctx, const char *key,
2062 struct security_descriptor **psecdesc)
2063 {
2064 char *tdbkey;
2065 TDB_DATA data;
2066 NTSTATUS status;
2067 TALLOC_CTX *tmp_ctx = talloc_stackframe();
2068 WERROR err = WERR_OK;
2069
2070 DEBUG(10, ("regdb_get_secdesc: Getting secdesc of key [%s]\n", key));
2071
2072 if (!regdb_key_exists(regdb, key)) {
2073 err = WERR_BADFILE;
2074 goto done;
2075 }
2076
2077 tdbkey = talloc_asprintf(tmp_ctx, "%s\\%s", REG_SECDESC_PREFIX, key);
2078 if (tdbkey == NULL) {
2079 err = WERR_NOMEM;
2080 goto done;
2081 }
2082
2083 tdbkey = normalize_reg_path(tmp_ctx, tdbkey);
2084 if (tdbkey == NULL) {
2085 err = WERR_NOMEM;
2086 goto done;
2087 }
2088
2089 status = dbwrap_fetch_bystring(regdb, tmp_ctx, tdbkey, &data);
2090 if (!NT_STATUS_IS_OK(status)) {
2091 err = WERR_BADFILE;
2092 goto done;
2093 }
2094
2095 status = unmarshall_sec_desc(mem_ctx, (uint8 *)data.dptr, data.dsize,
2096 psecdesc);
2097
2098 if (NT_STATUS_EQUAL(status, NT_STATUS_NO_MEMORY)) {
2099 err = WERR_NOMEM;
2100 } else if (!NT_STATUS_IS_OK(status)) {
2101 err = WERR_REG_CORRUPT;
2102 }
2103
2104 done:
2105 TALLOC_FREE(tmp_ctx);
2106 return err;
2107 }
2108
2109 struct regdb_set_secdesc_ctx {
2110 const char *key;
2111 struct security_descriptor *secdesc;
2112 };
2113
2114 static NTSTATUS regdb_set_secdesc_action(struct db_context *db,
2115 void *private_data)
2116 {
2117 char *tdbkey;
2118 NTSTATUS status;
2119 TDB_DATA tdbdata;
2120 struct regdb_set_secdesc_ctx *ctx =
2121 (struct regdb_set_secdesc_ctx *)private_data;
2122 TALLOC_CTX *frame = talloc_stackframe();
2123
2124 tdbkey = talloc_asprintf(frame, "%s\\%s", REG_SECDESC_PREFIX, ctx->key);
2125 if (tdbkey == NULL) {
2126 status = NT_STATUS_NO_MEMORY;
2127 goto done;
2128 }
2129
2130 tdbkey = normalize_reg_path(frame, tdbkey);
2131 if (tdbkey == NULL) {
2132 status = NT_STATUS_NO_MEMORY;
2133 goto done;
2134 }
2135
2136 if (ctx->secdesc == NULL) {
2137 /* assuming a delete */
2138 status = dbwrap_delete_bystring(db, tdbkey);
2139 goto done;
2140 }
2141
2142 status = marshall_sec_desc(frame, ctx->secdesc, &tdbdata.dptr,
2143 &tdbdata.dsize);
2144 if (!NT_STATUS_IS_OK(status)) {
2145 goto done;
2146 }
2147
2148 status = dbwrap_store_bystring(db, tdbkey, tdbdata, 0);
2149
2150 done:
2151 TALLOC_FREE(frame);
2152 return status;
2153 }
2154
2155 static WERROR regdb_set_secdesc(const char *key,
2156 struct security_descriptor *secdesc)
2157 {
2158 WERROR err;
2159 struct regdb_set_secdesc_ctx ctx;
2160
2161 if (!regdb_key_exists(regdb, key)) {
2162 err = WERR_BADFILE;
2163 goto done;
2164 }
2165
2166 ctx.key = key;
2167 ctx.secdesc = secdesc;
2168
2169 err = regdb_trans_do(regdb, regdb_set_secdesc_action, &ctx);
2170
2171 done:
2172 return err;
2173 }
2174
2175 static bool regdb_subkeys_need_update(struct regsubkey_ctr *subkeys)
2176 {
2177 return (regdb_get_seqnum() != regsubkey_ctr_get_seqnum(subkeys));
2178 }
2179
2180 static bool regdb_values_need_update(struct regval_ctr *values)
2181 {
2182 return (regdb_get_seqnum() != regval_ctr_get_seqnum(values));
2183 }
2184
2185 /*
2186 * Table of function pointers for default access
2187 */
2188
2189 struct registry_ops regdb_ops = {
2190 .fetch_subkeys = regdb_fetch_keys,
2191 .fetch_values = regdb_fetch_values,
2192 .store_subkeys = regdb_store_keys,
2193 .store_values = regdb_store_values,
2194 .create_subkey = regdb_create_subkey,
2195 .delete_subkey = regdb_delete_subkey,
2196 .get_secdesc = regdb_get_secdesc,
2197 .set_secdesc = regdb_set_secdesc,
2198 .subkeys_need_update = regdb_subkeys_need_update,
2199 .values_need_update = regdb_values_need_update
2200 };
reg import