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
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.
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.
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/>.
22 /* Implementation of internal registry database functions. */
25 #include "system/filesys.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"
34 #include "dbwrap/dbwrap.h"
35 #include "dbwrap/dbwrap_open.h"
36 #include "../libcli/security/secdesc.h"
39 #define DBGC_CLASS DBGC_REGISTRY
41 #define REGDB_VERSION_KEYNAME "INFO/version"
43 static struct db_context
*regdb
= NULL
;
44 static int regdb_refcount
;
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
,
58 static WERROR
regdb_create_basekey(struct db_context
*db
, const char *key
);
59 static WERROR
regdb_create_subkey_internal(struct db_context
*db
,
64 struct regdb_trans_ctx
{
65 NTSTATUS (*action
)(struct db_context
*, void *);
69 static NTSTATUS
regdb_trans_do_action(struct db_context
*db
, void *private_data
)
73 struct regdb_trans_ctx
*ctx
= (struct regdb_trans_ctx
*)private_data
;
75 status
= dbwrap_fetch_int32_bystring(db
, REGDB_VERSION_KEYNAME
,
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
;
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
;
92 status
= ctx
->action(db
, ctx
->private_data
);
96 static WERROR
regdb_trans_do(struct db_context
*db
,
97 NTSTATUS (*action
)(struct db_context
*, void *),
101 struct regdb_trans_ctx ctx
;
105 ctx
.private_data
= private_data
;
107 status
= dbwrap_trans_do(db
, regdb_trans_do_action
, &ctx
);
109 return ntstatus_to_werror(status
);
112 /* List the deepest path into the registry. All part components will be created.*/
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 */
122 static const char *builtin_registry_paths
[] = {
127 KEY_PRINTING
"\\Forms",
128 KEY_PRINTING
"\\Printers",
129 KEY_PRINTING
"\\Environments\\Windows NT x86\\Print Processors\\winprint",
130 KEY_PRINTING
"\\Environments\\Windows x64\\Print Processors\\winprint",
137 KEY_SAMBA_GROUP_POLICY
,
138 KEY_GP_MACHINE_POLICY
,
139 KEY_GP_MACHINE_WIN_POLICY
,
142 KEY_GP_USER_WIN_POLICY
,
143 "HKLM\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon\\GPExtensions",
144 "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Print\\Monitors",
146 "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Terminal Server\\DefaultUserConfiguration",
155 struct builtin_regkey_value
{
157 const char *valuename
;
165 static struct builtin_regkey_value builtin_registry_values
[] = {
166 { KEY_PRINTING_PORTS
,
167 SAMBA_PRINTER_PORT_NAME
, REG_SZ
, { "" } },
169 "DefaultSpoolDirectory", REG_SZ
, { "C:\\Windows\\System32\\Spool\\Printers" } },
171 "DisplayName", REG_SZ
, { "Event Log" } },
173 "ErrorControl", REG_DWORD
, { (char*)0x00000001 } },
174 { NULL
, NULL
, 0, { NULL
} }
177 static WERROR
create_key_recursive(struct db_context
*db
,
184 if (subkey
== NULL
) {
185 return WERR_INVALID_PARAMETER
;
189 return regdb_create_basekey(db
, subkey
);
192 p
= strrchr_m(path
, '\\');
195 werr
= create_key_recursive(db
, NULL
, path
);
198 werr
= create_key_recursive(db
, path
, p
+1);
202 if (!W_ERROR_IS_OK(werr
)) {
206 werr
= regdb_create_subkey_internal(db
, path
, subkey
);
213 * Initialize a key in the registry:
214 * create each component key of the specified path.
216 static WERROR
init_registry_key_internal(struct db_context
*db
,
217 const char *add_path
)
221 TALLOC_CTX
*frame
= talloc_stackframe();
223 if (add_path
== NULL
) {
224 werr
= WERR_INVALID_PARAMETER
;
228 key
= talloc_strdup(frame
, add_path
);
230 subkey
= strrchr_m(key
, '\\');
231 if (subkey
== NULL
) {
239 werr
= create_key_recursive(db
, key
, subkey
);
246 struct init_registry_key_context
{
247 const char *add_path
;
250 static NTSTATUS
init_registry_key_action(struct db_context
*db
,
253 struct init_registry_key_context
*init_ctx
=
254 (struct init_registry_key_context
*)private_data
;
256 return werror_to_ntstatus(init_registry_key_internal(
257 db
, init_ctx
->add_path
));
261 * Initialize a key in the registry:
262 * create each component key of the specified path,
263 * wrapped in one db transaction.
265 WERROR
init_registry_key(const char *add_path
)
267 struct init_registry_key_context init_ctx
;
269 if (regdb_key_exists(regdb
, add_path
)) {
273 init_ctx
.add_path
= add_path
;
275 return regdb_trans_do(regdb
,
276 init_registry_key_action
,
280 /***********************************************************************
281 Open the registry data in the tdb
282 ***********************************************************************/
284 static void regdb_ctr_add_value(struct regval_ctr
*ctr
,
285 struct builtin_regkey_value
*value
)
287 switch(value
->type
) {
289 regval_ctr_addvalue(ctr
, value
->valuename
, REG_DWORD
,
290 (uint8_t *)&value
->data
.dw_value
,
295 regval_ctr_addvalue_sz(ctr
, value
->valuename
,
300 DEBUG(0, ("regdb_ctr_add_value: invalid value type in "
301 "registry values [%d]\n", value
->type
));
305 static NTSTATUS
init_registry_data_action(struct db_context
*db
,
309 TALLOC_CTX
*frame
= talloc_stackframe();
310 struct regval_ctr
*values
;
313 /* loop over all of the predefined paths and add each component */
315 for (i
=0; builtin_registry_paths
[i
] != NULL
; i
++) {
316 if (regdb_key_exists(db
, builtin_registry_paths
[i
])) {
319 status
= werror_to_ntstatus(init_registry_key_internal(db
,
320 builtin_registry_paths
[i
]));
321 if (!NT_STATUS_IS_OK(status
)) {
326 /* loop over all of the predefined values and add each component */
328 for (i
=0; builtin_registry_values
[i
].path
!= NULL
; i
++) {
331 werr
= regval_ctr_init(frame
, &values
);
332 if (!W_ERROR_IS_OK(werr
)) {
333 status
= werror_to_ntstatus(werr
);
337 regdb_fetch_values_internal(db
,
338 builtin_registry_values
[i
].path
,
341 /* preserve existing values across restarts. Only add new ones */
343 if (!regval_ctr_value_exists(values
,
344 builtin_registry_values
[i
].valuename
))
346 regdb_ctr_add_value(values
,
347 &builtin_registry_values
[i
]);
348 status
= regdb_store_values_internal(db
,
349 builtin_registry_values
[i
].path
,
351 if (!NT_STATUS_IS_OK(status
)) {
358 status
= NT_STATUS_OK
;
366 WERROR
init_registry_data(void)
369 TALLOC_CTX
*frame
= talloc_stackframe();
370 struct regval_ctr
*values
;
374 * First, check for the existence of the needed keys and values.
375 * If all do already exist, we can save the writes.
377 for (i
=0; builtin_registry_paths
[i
] != NULL
; i
++) {
378 if (!regdb_key_exists(regdb
, builtin_registry_paths
[i
])) {
383 for (i
=0; builtin_registry_values
[i
].path
!= NULL
; i
++) {
384 werr
= regval_ctr_init(frame
, &values
);
385 W_ERROR_NOT_OK_GOTO_DONE(werr
);
387 regdb_fetch_values_internal(regdb
,
388 builtin_registry_values
[i
].path
,
390 if (!regval_ctr_value_exists(values
,
391 builtin_registry_values
[i
].valuename
))
406 * There are potentially quite a few store operations which are all
407 * indiviually wrapped in tdb transactions. Wrapping them in a single
408 * transaction gives just a single transaction_commit() to actually do
409 * its fsync()s. See tdb/common/transaction.c for info about nested
410 * transaction behaviour.
413 werr
= regdb_trans_do(regdb
,
414 init_registry_data_action
,
422 static int regdb_normalize_keynames_fn(struct db_record
*rec
,
425 TALLOC_CTX
*mem_ctx
= talloc_tos();
430 struct db_context
*db
= (struct db_context
*)private_data
;
432 key
= dbwrap_record_get_key(rec
);
433 if (key
.dptr
== NULL
|| key
.dsize
== 0) {
437 value
= dbwrap_record_get_value(rec
);
440 DEBUG(0, ("regdb_normalize_keynames_fn: ERROR: "
441 "NULL db context handed in via private_data\n"));
445 if (strncmp((const char *)key
.dptr
, REGDB_VERSION_KEYNAME
,
446 strlen(REGDB_VERSION_KEYNAME
)) == 0)
451 keyname
= strchr((const char *)key
.dptr
, '/');
453 keyname
= talloc_string_sub(mem_ctx
,
454 (const char *)key
.dptr
,
458 DEBUG(2, ("regdb_normalize_keynames_fn: Convert %s to %s\n",
459 (const char *)key
.dptr
,
462 /* Delete the original record and store the normalized key */
463 status
= dbwrap_record_delete(rec
);
464 if (!NT_STATUS_IS_OK(status
)) {
465 DEBUG(0,("regdb_normalize_keynames_fn: "
466 "tdb_delete for [%s] failed!\n",
467 (const char *)key
.dptr
));
471 status
= dbwrap_store_bystring(db
, keyname
, value
, TDB_REPLACE
);
472 if (!NT_STATUS_IS_OK(status
)) {
473 DEBUG(0,("regdb_normalize_keynames_fn: "
474 "failed to store new record for [%s]!\n",
483 static WERROR
regdb_store_regdb_version(struct db_context
*db
, uint32_t version
)
487 return WERR_CAN_NOT_COMPLETE
;
490 status
= dbwrap_trans_store_int32_bystring(db
, REGDB_VERSION_KEYNAME
,
492 if (!NT_STATUS_IS_OK(status
)) {
493 DEBUG(1, ("regdb_store_regdb_version: error storing %s = %d: %s\n",
494 REGDB_VERSION_KEYNAME
, version
, nt_errstr(status
)));
495 return ntstatus_to_werror(status
);
497 DEBUG(10, ("regdb_store_regdb_version: stored %s = %d\n",
498 REGDB_VERSION_KEYNAME
, version
));
503 static WERROR
regdb_upgrade_v1_to_v2(struct db_context
*db
)
509 mem_ctx
= talloc_stackframe();
511 status
= dbwrap_traverse(db
, regdb_normalize_keynames_fn
, db
, NULL
);
512 if (!NT_STATUS_IS_OK(status
)) {
513 werr
= WERR_REGISTRY_IO_FAILED
;
517 werr
= regdb_store_regdb_version(db
, REGDB_VERSION_V2
);
520 talloc_free(mem_ctx
);
524 static bool tdb_data_read_uint32(TDB_DATA
*buf
, uint32_t *result
)
526 const size_t len
= sizeof(uint32_t);
527 if (buf
->dsize
>= len
) {
528 *result
= IVAL(buf
->dptr
, 0);
536 static bool tdb_data_read_cstr(TDB_DATA
*buf
, char **result
)
538 const size_t len
= strnlen((char*)buf
->dptr
, buf
->dsize
) + 1;
539 if (buf
->dsize
>= len
) {
540 *result
= (char*)buf
->dptr
;
548 static bool tdb_data_is_cstr(TDB_DATA d
) {
549 if (tdb_data_is_empty(d
) || (d
.dptr
[d
.dsize
-1] != '\0')) {
552 return strlen((char *)d
.dptr
) == (d
.dsize
-1);
555 static bool upgrade_v2_to_v3_check_subkeylist(struct db_context
*db
,
559 static uint32_t zero
= 0;
560 static TDB_DATA empty_subkey_list
= {
561 .dptr
= (unsigned char*)&zero
,
562 .dsize
= sizeof(uint32_t),
564 bool success
= false;
565 char *path
= talloc_asprintf(talloc_tos(), "%s\\%s", key
, subkey
);
566 if (!strupper_m(path
)) {
570 if (!dbwrap_exists(db
, string_term_tdb_data(path
))) {
573 DEBUG(10, ("regdb_upgrade_v2_to_v3: writing subkey list [%s]\n",
576 status
= dbwrap_store_bystring(db
, path
, empty_subkey_list
,
578 if (!NT_STATUS_IS_OK(status
)) {
579 DEBUG(0, ("regdb_upgrade_v2_to_v3: writing subkey list "
580 "[%s] failed\n", path
));
590 static bool upgrade_v2_to_v3_check_parent(struct db_context
*db
,
593 const char *sep
= strrchr_m(key
, '\\');
595 char *pkey
= talloc_strndup(talloc_tos(), key
, sep
-key
);
596 if (!dbwrap_exists(db
, string_term_tdb_data(pkey
))) {
597 DEBUG(0, ("regdb_upgrade_v2_to_v3: missing subkey list "
598 "[%s]\nrun \"net registry check\"\n", pkey
));
606 #define IS_EQUAL(d,s) (((d).dsize == strlen(s)+1) && \
607 (strcmp((char*)(d).dptr, (s)) == 0))
608 #define STARTS_WITH(d,s) (((d).dsize > strlen(s)) && \
609 (strncmp((char*)(d).dptr, (s), strlen(s)) == 0))
610 #define SSTR(d) (int)(d).dsize , (char*)(d).dptr
613 static int regdb_upgrade_v2_to_v3_fn(struct db_record
*rec
, void *private_data
)
615 struct db_context
*db
= (struct db_context
*)private_data
;
616 TDB_DATA key
= dbwrap_record_get_key(rec
);
617 TDB_DATA val
= dbwrap_record_get_value(rec
);
619 if (tdb_data_is_empty(key
)) {
624 DEBUG(0, ("regdb_upgrade_v2_to_v3_fn: ERROR: "
625 "NULL db context handed in via private_data\n"));
629 if (IS_EQUAL(key
, REGDB_VERSION_KEYNAME
) ||
630 STARTS_WITH(key
, REG_VALUE_PREFIX
) ||
631 STARTS_WITH(key
, REG_SECDESC_PREFIX
))
633 DEBUG(10, ("regdb_upgrade_v2_to_v3: skipping [%.*s]\n",
638 if (STARTS_WITH(key
, REG_SORTED_SUBKEYS_PREFIX
)) {
640 /* Delete the deprecated sorted subkeys cache. */
642 DEBUG(10, ("regdb_upgrade_v2_to_v3: deleting [%.*s]\n",
645 status
= dbwrap_record_delete(rec
);
646 if (!NT_STATUS_IS_OK(status
)) {
647 DEBUG(0, ("regdb_upgrade_v2_to_v3: deleting [%.*s] "
648 "failed!\n", SSTR(key
)));
655 if ( tdb_data_is_cstr(key
) &&
656 hive_info((char*)key
.dptr
) != NULL
)
659 * Found a regular subkey list record.
660 * Walk the list and create the list record for those
661 * subkeys that don't already have one.
664 char *subkey
, *path
= (char*)key
.dptr
;
665 uint32_t num_items
, found_items
= 0;
668 DEBUG(10, ("regdb_upgrade_v2_to_v3: scanning subkeylist of "
671 if (!tdb_data_read_uint32(&pos
, &num_items
)) {
672 /* invalid or empty - skip */
676 while (tdb_data_read_cstr(&pos
, &subkey
)) {
679 if (!upgrade_v2_to_v3_check_subkeylist(db
, path
, subkey
))
684 if (!upgrade_v2_to_v3_check_parent(db
, path
)) {
688 if (found_items
!= num_items
) {
689 DEBUG(0, ("regdb_upgrade_v2_to_v3: inconsistent subkey "
690 "list [%s]\nrun \"net registry check\"\n",
694 DEBUG(10, ("regdb_upgrade_v2_to_v3: skipping invalid [%.*s]\n"
695 "run \"net registry check\"\n", SSTR(key
)));
701 static WERROR
regdb_upgrade_v2_to_v3(struct db_context
*db
)
706 status
= dbwrap_traverse(db
, regdb_upgrade_v2_to_v3_fn
, db
, NULL
);
707 if (!NT_STATUS_IS_OK(status
)) {
708 werr
= WERR_REGISTRY_IO_FAILED
;
712 werr
= regdb_store_regdb_version(db
, REGDB_VERSION_V3
);
718 /***********************************************************************
719 Open the registry database
720 ***********************************************************************/
722 WERROR
regdb_init(void)
730 DEBUG(10, ("regdb_init: incrementing refcount (%d->%d)\n",
731 regdb_refcount
, regdb_refcount
+1));
736 db_path
= state_path("registry.tdb");
737 if (db_path
== NULL
) {
738 return WERR_NOT_ENOUGH_MEMORY
;
741 regdb
= db_open(NULL
, db_path
, 0,
742 REG_TDB_FLAGS
, O_RDWR
, 0600,
743 DBWRAP_LOCK_ORDER_1
, REG_DBWRAP_FLAGS
);
745 regdb
= db_open(NULL
, db_path
, 0,
746 REG_TDB_FLAGS
, O_RDWR
|O_CREAT
, 0600,
747 DBWRAP_LOCK_ORDER_1
, REG_DBWRAP_FLAGS
);
749 werr
= ntstatus_to_werror(map_nt_error_from_unix(errno
));
750 DEBUG(1,("regdb_init: Failed to open registry %s (%s)\n",
751 db_path
, strerror(errno
) ));
752 TALLOC_FREE(db_path
);
756 werr
= regdb_store_regdb_version(regdb
, REGDB_CODE_VERSION
);
757 if (!W_ERROR_IS_OK(werr
)) {
758 DEBUG(1, ("regdb_init: Failed to store version: %s\n",
760 TALLOC_FREE(db_path
);
764 DEBUG(10,("regdb_init: Successfully created registry tdb\n"));
766 TALLOC_FREE(db_path
);
769 DEBUG(10, ("regdb_init: registry db openend. refcount reset (%d)\n",
772 status
= dbwrap_fetch_int32_bystring(regdb
, REGDB_VERSION_KEYNAME
,
774 if (!NT_STATUS_IS_OK(status
)) {
775 DEBUG(10, ("regdb_init: registry version uninitialized "
776 "(got %d), initializing to version %d\n",
777 vers_id
, REGDB_VERSION_V1
));
780 * There was a regdb format version prior to version 1
781 * which did not store a INFO/version key. The format
782 * of this version was identical to version 1 except for
783 * the lack of the sorted subkey cache records.
784 * Since these are disposable, we can safely assume version
785 * 1 if no INFO/version key is found and run the db through
786 * the whole chain of upgrade. If the database was not
787 * initialized, this does not harm. If it was the unversioned
788 * version ("0"), then it do the right thing with the records.
790 werr
= regdb_store_regdb_version(regdb
, REGDB_VERSION_V1
);
791 if (!W_ERROR_IS_OK(werr
)) {
794 vers_id
= REGDB_VERSION_V1
;
797 if (vers_id
== REGDB_CODE_VERSION
) {
801 if (vers_id
> REGDB_CODE_VERSION
|| vers_id
== 0) {
802 DEBUG(0, ("regdb_init: unknown registry version %d "
803 "(code version = %d), refusing initialization\n",
804 vers_id
, REGDB_CODE_VERSION
));
805 return WERR_CAN_NOT_COMPLETE
;
808 if (dbwrap_transaction_start(regdb
) != 0) {
809 return WERR_REGISTRY_IO_FAILED
;
812 if (vers_id
== REGDB_VERSION_V1
) {
813 DEBUG(10, ("regdb_init: upgrading registry from version %d "
814 "to %d\n", REGDB_VERSION_V1
, REGDB_VERSION_V2
));
816 werr
= regdb_upgrade_v1_to_v2(regdb
);
817 if (!W_ERROR_IS_OK(werr
)) {
818 dbwrap_transaction_cancel(regdb
);
822 vers_id
= REGDB_VERSION_V2
;
825 if (vers_id
== REGDB_VERSION_V2
) {
826 DEBUG(10, ("regdb_init: upgrading registry from version %d "
827 "to %d\n", REGDB_VERSION_V2
, REGDB_VERSION_V3
));
829 werr
= regdb_upgrade_v2_to_v3(regdb
);
830 if (!W_ERROR_IS_OK(werr
)) {
831 dbwrap_transaction_cancel(regdb
);
835 vers_id
= REGDB_VERSION_V3
;
838 /* future upgrade code should go here */
840 if (dbwrap_transaction_commit(regdb
) != 0) {
841 return WERR_REGISTRY_IO_FAILED
;
847 /***********************************************************************
848 Open the registry. Must already have been initialized by regdb_init()
849 ***********************************************************************/
851 WERROR
regdb_open( void )
853 WERROR result
= WERR_OK
;
858 DEBUG(10, ("regdb_open: incrementing refcount (%d->%d)\n",
859 regdb_refcount
, regdb_refcount
+1));
864 db_path
= state_path("registry.tdb");
865 if (db_path
== NULL
) {
866 return WERR_NOT_ENOUGH_MEMORY
;
871 regdb
= db_open(NULL
, db_path
, 0,
872 REG_TDB_FLAGS
, O_RDWR
, 0600,
873 DBWRAP_LOCK_ORDER_1
, REG_DBWRAP_FLAGS
);
877 result
= ntstatus_to_werror(map_nt_error_from_unix(saved_errno
));
878 DEBUG(0,("regdb_open: Failed to open %s! (%s)\n",
879 db_path
, strerror(saved_errno
)));
880 TALLOC_FREE(db_path
);
883 TALLOC_FREE(db_path
);
886 DEBUG(10, ("regdb_open: registry db opened. refcount reset (%d)\n",
892 /***********************************************************************
893 ***********************************************************************/
895 int regdb_close( void )
897 if (regdb_refcount
== 0) {
903 DEBUG(10, ("regdb_close: decrementing refcount (%d->%d)\n",
904 regdb_refcount
+1, regdb_refcount
));
906 if ( regdb_refcount
> 0 )
909 SMB_ASSERT( regdb_refcount
>= 0 );
915 WERROR
regdb_transaction_start(void)
917 return (dbwrap_transaction_start(regdb
) == 0) ?
918 WERR_OK
: WERR_REGISTRY_IO_FAILED
;
921 WERROR
regdb_transaction_commit(void)
923 return (dbwrap_transaction_commit(regdb
) == 0) ?
924 WERR_OK
: WERR_REGISTRY_IO_FAILED
;
927 WERROR
regdb_transaction_cancel(void)
929 return (dbwrap_transaction_cancel(regdb
) == 0) ?
930 WERR_OK
: WERR_REGISTRY_IO_FAILED
;
933 /***********************************************************************
934 return the tdb sequence number of the registry tdb.
935 this is an indicator for the content of the registry
936 having changed. it will change upon regdb_init, too, though.
937 ***********************************************************************/
938 int regdb_get_seqnum(void)
940 return dbwrap_get_seqnum(regdb
);
944 static WERROR
regdb_delete_key_with_prefix(struct db_context
*db
,
949 WERROR werr
= WERR_NOT_ENOUGH_MEMORY
;
950 TALLOC_CTX
*mem_ctx
= talloc_stackframe();
952 if (keyname
== NULL
) {
953 werr
= WERR_INVALID_PARAMETER
;
957 if (prefix
== NULL
) {
958 path
= discard_const_p(char, keyname
);
960 path
= talloc_asprintf(mem_ctx
, "%s\\%s", prefix
, keyname
);
966 path
= normalize_reg_path(mem_ctx
, path
);
971 werr
= ntstatus_to_werror(dbwrap_purge_bystring(db
, path
));
974 talloc_free(mem_ctx
);
979 static WERROR
regdb_delete_values(struct db_context
*db
, const char *keyname
)
981 return regdb_delete_key_with_prefix(db
, keyname
, REG_VALUE_PREFIX
);
984 static WERROR
regdb_delete_secdesc(struct db_context
*db
, const char *keyname
)
986 return regdb_delete_key_with_prefix(db
, keyname
, REG_SECDESC_PREFIX
);
989 static WERROR
regdb_delete_subkeylist(struct db_context
*db
, const char *keyname
)
991 return regdb_delete_key_with_prefix(db
, keyname
, NULL
);
995 static WERROR
regdb_delete_key_lists(struct db_context
*db
, const char *keyname
)
999 werr
= regdb_delete_values(db
, keyname
);
1000 if (!W_ERROR_IS_OK(werr
)) {
1001 DEBUG(1, (__location__
" Deleting %s\\%s failed: %s\n",
1002 REG_VALUE_PREFIX
, keyname
, win_errstr(werr
)));
1006 werr
= regdb_delete_secdesc(db
, keyname
);
1007 if (!W_ERROR_IS_OK(werr
)) {
1008 DEBUG(1, (__location__
" Deleting %s\\%s failed: %s\n",
1009 REG_SECDESC_PREFIX
, keyname
, win_errstr(werr
)));
1013 werr
= regdb_delete_subkeylist(db
, keyname
);
1014 if (!W_ERROR_IS_OK(werr
)) {
1015 DEBUG(1, (__location__
" Deleting %s failed: %s\n",
1016 keyname
, win_errstr(werr
)));
1024 /***********************************************************************
1025 Add subkey strings to the registry tdb under a defined key
1026 fmt is the same format as tdb_pack except this function only supports
1028 ***********************************************************************/
1030 static WERROR
regdb_store_keys_internal2(struct db_context
*db
,
1032 struct regsubkey_ctr
*ctr
)
1035 uint8_t *buffer
= NULL
;
1037 uint32_t len
, buflen
;
1038 uint32_t num_subkeys
= regsubkey_ctr_numkeys(ctr
);
1039 char *keyname
= NULL
;
1040 TALLOC_CTX
*ctx
= talloc_stackframe();
1044 werr
= WERR_INVALID_PARAMETER
;
1048 keyname
= talloc_strdup(ctx
, key
);
1050 werr
= WERR_NOT_ENOUGH_MEMORY
;
1054 keyname
= normalize_reg_path(ctx
, keyname
);
1056 werr
= WERR_NOT_ENOUGH_MEMORY
;
1060 /* allocate some initial memory */
1062 buffer
= (uint8_t *)SMB_MALLOC(1024);
1063 if (buffer
== NULL
) {
1064 werr
= WERR_NOT_ENOUGH_MEMORY
;
1070 /* store the number of subkeys */
1072 len
+= tdb_pack(buffer
+len
, buflen
-len
, "d", num_subkeys
);
1074 /* pack all the strings */
1076 for (i
=0; i
<num_subkeys
; i
++) {
1079 thistime
= tdb_pack(buffer
+len
, buflen
-len
, "f",
1080 regsubkey_ctr_specific_key(ctr
, i
));
1081 if (len
+thistime
> buflen
) {
1084 * tdb_pack hasn't done anything because of the short
1085 * buffer, allocate extra space.
1087 buffer
= SMB_REALLOC_ARRAY(buffer
, uint8_t,
1089 if(buffer
== NULL
) {
1090 DEBUG(0, ("regdb_store_keys: Failed to realloc "
1091 "memory of size [%u]\n",
1092 (unsigned int)(len
+thistime
)*2));
1093 werr
= WERR_NOT_ENOUGH_MEMORY
;
1096 buflen
= (len
+thistime
)*2;
1097 thistime2
= tdb_pack(
1098 buffer
+len
, buflen
-len
, "f",
1099 regsubkey_ctr_specific_key(ctr
, i
));
1100 if (thistime2
!= thistime
) {
1101 DEBUG(0, ("tdb_pack failed\n"));
1102 werr
= WERR_CAN_NOT_COMPLETE
;
1109 /* finally write out the data */
1113 werr
= ntstatus_to_werror(dbwrap_store_bystring(db
, keyname
, dbuf
,
1123 * Utility function to store a new empty list of
1124 * subkeys of given key specified as parent and subkey name
1125 * (thereby creating the key).
1126 * If the parent keyname is NULL, then the "subkey" is
1127 * interpreted as a base key.
1128 * If the subkey list does already exist, it is not modified.
1130 * Must be called from within a transaction.
1132 static WERROR
regdb_store_subkey_list(struct db_context
*db
, const char *parent
,
1137 struct regsubkey_ctr
*subkeys
= NULL
;
1138 TALLOC_CTX
*frame
= talloc_stackframe();
1140 if (parent
== NULL
) {
1141 path
= talloc_strdup(frame
, key
);
1143 path
= talloc_asprintf(frame
, "%s\\%s", parent
, key
);
1146 werr
= WERR_NOT_ENOUGH_MEMORY
;
1150 werr
= regsubkey_ctr_init(frame
, &subkeys
);
1151 W_ERROR_NOT_OK_GOTO_DONE(werr
);
1153 werr
= regdb_fetch_keys_internal(db
, path
, subkeys
);
1154 if (W_ERROR_IS_OK(werr
)) {
1155 /* subkey list exists already - don't modify */
1159 werr
= regsubkey_ctr_reinit(subkeys
);
1160 W_ERROR_NOT_OK_GOTO_DONE(werr
);
1162 /* create a record with 0 subkeys */
1163 werr
= regdb_store_keys_internal2(db
, path
, subkeys
);
1164 if (!W_ERROR_IS_OK(werr
)) {
1165 DEBUG(0, ("regdb_store_keys: Failed to store new record for "
1166 "key [%s]: %s\n", path
, win_errstr(werr
)));
1175 /***********************************************************************
1176 Store the new subkey record and create any child key records that
1177 do not currently exist
1178 ***********************************************************************/
1180 struct regdb_store_keys_context
{
1182 struct regsubkey_ctr
*ctr
;
1185 static NTSTATUS
regdb_store_keys_action(struct db_context
*db
,
1188 struct regdb_store_keys_context
*store_ctx
;
1192 struct regsubkey_ctr
*old_subkeys
= NULL
;
1193 char *oldkeyname
= NULL
;
1194 TALLOC_CTX
*mem_ctx
= talloc_stackframe();
1196 store_ctx
= (struct regdb_store_keys_context
*)private_data
;
1199 * Re-fetch the old keys inside the transaction
1202 werr
= regsubkey_ctr_init(mem_ctx
, &old_subkeys
);
1203 W_ERROR_NOT_OK_GOTO_DONE(werr
);
1205 werr
= regdb_fetch_keys_internal(db
, store_ctx
->key
, old_subkeys
);
1206 if (!W_ERROR_IS_OK(werr
) &&
1207 !W_ERROR_EQUAL(werr
, WERR_NOT_FOUND
))
1213 * Make the store operation as safe as possible without transactions:
1215 * (1) For each subkey removed from ctr compared with old_subkeys:
1217 * (a) First delete the value db entry.
1219 * (b) Next delete the secdesc db record.
1221 * (c) Then delete the subkey list entry.
1223 * (2) Now write the list of subkeys of the parent key,
1224 * deleting removed entries and adding new ones.
1226 * (3) Finally create the subkey list entries for the added keys.
1228 * This way if we crash half-way in between deleting the subkeys
1229 * and storing the parent's list of subkeys, no old data can pop up
1230 * out of the blue when re-adding keys later on.
1233 /* (1) delete removed keys' lists (values/secdesc/subkeys) */
1235 num_subkeys
= regsubkey_ctr_numkeys(old_subkeys
);
1236 for (i
=0; i
<num_subkeys
; i
++) {
1237 oldkeyname
= regsubkey_ctr_specific_key(old_subkeys
, i
);
1239 if (regsubkey_ctr_key_exists(store_ctx
->ctr
, oldkeyname
)) {
1241 * It's still around, don't delete
1246 path
= talloc_asprintf(mem_ctx
, "%s\\%s", store_ctx
->key
,
1249 werr
= WERR_NOT_ENOUGH_MEMORY
;
1253 werr
= regdb_delete_key_lists(db
, path
);
1254 W_ERROR_NOT_OK_GOTO_DONE(werr
);
1259 TALLOC_FREE(old_subkeys
);
1261 /* (2) store the subkey list for the parent */
1263 werr
= regdb_store_keys_internal2(db
, store_ctx
->key
, store_ctx
->ctr
);
1264 if (!W_ERROR_IS_OK(werr
)) {
1265 DEBUG(0,("regdb_store_keys: Failed to store new subkey list "
1266 "for parent [%s]: %s\n", store_ctx
->key
,
1271 /* (3) now create records for any subkeys that don't already exist */
1273 num_subkeys
= regsubkey_ctr_numkeys(store_ctx
->ctr
);
1275 for (i
=0; i
<num_subkeys
; i
++) {
1278 subkey
= regsubkey_ctr_specific_key(store_ctx
->ctr
, i
);
1280 werr
= regdb_store_subkey_list(db
, store_ctx
->key
, subkey
);
1281 W_ERROR_NOT_OK_GOTO_DONE(werr
);
1285 * Update the seqnum in the container to possibly
1286 * prevent next read from going to disk
1288 werr
= regsubkey_ctr_set_seqnum(store_ctx
->ctr
, dbwrap_get_seqnum(db
));
1291 talloc_free(mem_ctx
);
1292 return werror_to_ntstatus(werr
);
1295 static bool regdb_store_keys_internal(struct db_context
*db
, const char *key
,
1296 struct regsubkey_ctr
*ctr
)
1298 int num_subkeys
, old_num_subkeys
, i
;
1299 struct regsubkey_ctr
*old_subkeys
= NULL
;
1300 TALLOC_CTX
*ctx
= talloc_stackframe();
1303 struct regdb_store_keys_context store_ctx
;
1305 if (!regdb_key_exists(db
, key
)) {
1310 * fetch a list of the old subkeys so we can determine if anything has
1314 werr
= regsubkey_ctr_init(ctx
, &old_subkeys
);
1315 if (!W_ERROR_IS_OK(werr
)) {
1316 DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
1320 werr
= regdb_fetch_keys_internal(db
, key
, old_subkeys
);
1321 if (!W_ERROR_IS_OK(werr
) &&
1322 !W_ERROR_EQUAL(werr
, WERR_NOT_FOUND
))
1327 num_subkeys
= regsubkey_ctr_numkeys(ctr
);
1328 old_num_subkeys
= regsubkey_ctr_numkeys(old_subkeys
);
1329 if ((num_subkeys
&& old_num_subkeys
) &&
1330 (num_subkeys
== old_num_subkeys
)) {
1332 for (i
= 0; i
< num_subkeys
; i
++) {
1333 if (strcmp(regsubkey_ctr_specific_key(ctr
, i
),
1334 regsubkey_ctr_specific_key(old_subkeys
, i
))
1340 if (i
== num_subkeys
) {
1342 * Nothing changed, no point to even start a tdb
1351 TALLOC_FREE(old_subkeys
);
1353 store_ctx
.key
= key
;
1354 store_ctx
.ctr
= ctr
;
1356 werr
= regdb_trans_do(db
,
1357 regdb_store_keys_action
,
1360 ret
= W_ERROR_IS_OK(werr
);
1368 static bool regdb_store_keys(const char *key
, struct regsubkey_ctr
*ctr
)
1370 return regdb_store_keys_internal(regdb
, key
, ctr
);
1374 * create a subkey of a given key
1377 struct regdb_create_subkey_context
{
1382 static NTSTATUS
regdb_create_subkey_action(struct db_context
*db
,
1386 struct regdb_create_subkey_context
*create_ctx
;
1387 struct regsubkey_ctr
*subkeys
;
1388 TALLOC_CTX
*mem_ctx
= talloc_stackframe();
1390 create_ctx
= (struct regdb_create_subkey_context
*)private_data
;
1392 werr
= regsubkey_ctr_init(mem_ctx
, &subkeys
);
1393 W_ERROR_NOT_OK_GOTO_DONE(werr
);
1395 werr
= regdb_fetch_keys_internal(db
, create_ctx
->key
, subkeys
);
1396 W_ERROR_NOT_OK_GOTO_DONE(werr
);
1398 werr
= regsubkey_ctr_addkey(subkeys
, create_ctx
->subkey
);
1399 W_ERROR_NOT_OK_GOTO_DONE(werr
);
1401 werr
= regdb_store_keys_internal2(db
, create_ctx
->key
, subkeys
);
1402 if (!W_ERROR_IS_OK(werr
)) {
1403 DEBUG(0, (__location__
" failed to store new subkey list for "
1404 "parent key %s: %s\n", create_ctx
->key
,
1408 werr
= regdb_store_subkey_list(db
, create_ctx
->key
, create_ctx
->subkey
);
1411 talloc_free(mem_ctx
);
1412 return werror_to_ntstatus(werr
);
1415 static WERROR
regdb_create_subkey_internal(struct db_context
*db
,
1420 struct regsubkey_ctr
*subkeys
;
1421 TALLOC_CTX
*mem_ctx
= talloc_stackframe();
1422 struct regdb_create_subkey_context create_ctx
;
1424 if (!regdb_key_exists(db
, key
)) {
1425 werr
= WERR_NOT_FOUND
;
1429 werr
= regsubkey_ctr_init(mem_ctx
, &subkeys
);
1430 W_ERROR_NOT_OK_GOTO_DONE(werr
);
1432 werr
= regdb_fetch_keys_internal(db
, key
, subkeys
);
1433 W_ERROR_NOT_OK_GOTO_DONE(werr
);
1435 if (regsubkey_ctr_key_exists(subkeys
, subkey
)) {
1438 newkey
= talloc_asprintf(mem_ctx
, "%s\\%s", key
, subkey
);
1439 if (newkey
== NULL
) {
1440 werr
= WERR_NOT_ENOUGH_MEMORY
;
1444 if (regdb_key_exists(db
, newkey
)) {
1450 talloc_free(subkeys
);
1452 create_ctx
.key
= key
;
1453 create_ctx
.subkey
= subkey
;
1455 werr
= regdb_trans_do(db
,
1456 regdb_create_subkey_action
,
1460 talloc_free(mem_ctx
);
1464 static WERROR
regdb_create_subkey(const char *key
, const char *subkey
)
1466 return regdb_create_subkey_internal(regdb
, key
, subkey
);
1473 struct regdb_create_basekey_context
{
1477 static NTSTATUS
regdb_create_basekey_action(struct db_context
*db
,
1481 struct regdb_create_basekey_context
*create_ctx
;
1483 create_ctx
= (struct regdb_create_basekey_context
*)private_data
;
1485 werr
= regdb_store_subkey_list(db
, NULL
, create_ctx
->key
);
1487 return werror_to_ntstatus(werr
);
1490 static WERROR
regdb_create_basekey(struct db_context
*db
, const char *key
)
1493 struct regdb_create_subkey_context create_ctx
;
1495 create_ctx
.key
= key
;
1497 werr
= regdb_trans_do(db
,
1498 regdb_create_basekey_action
,
1505 * create a subkey of a given key
1508 struct regdb_delete_subkey_context
{
1515 static NTSTATUS
regdb_delete_subkey_action(struct db_context
*db
,
1519 struct regdb_delete_subkey_context
*delete_ctx
;
1520 struct regsubkey_ctr
*subkeys
;
1521 TALLOC_CTX
*mem_ctx
= talloc_stackframe();
1523 delete_ctx
= (struct regdb_delete_subkey_context
*)private_data
;
1525 werr
= regdb_delete_key_lists(db
, delete_ctx
->path
);
1526 W_ERROR_NOT_OK_GOTO_DONE(werr
);
1528 if (delete_ctx
->lazy
) {
1532 werr
= regsubkey_ctr_init(mem_ctx
, &subkeys
);
1533 W_ERROR_NOT_OK_GOTO_DONE(werr
);
1535 werr
= regdb_fetch_keys_internal(db
, delete_ctx
->key
, subkeys
);
1536 W_ERROR_NOT_OK_GOTO_DONE(werr
);
1538 werr
= regsubkey_ctr_delkey(subkeys
, delete_ctx
->subkey
);
1539 W_ERROR_NOT_OK_GOTO_DONE(werr
);
1541 werr
= regdb_store_keys_internal2(db
, delete_ctx
->key
, subkeys
);
1542 if (!W_ERROR_IS_OK(werr
)) {
1543 DEBUG(0, (__location__
" failed to store new subkey_list for "
1544 "parent key %s: %s\n", delete_ctx
->key
,
1549 talloc_free(mem_ctx
);
1550 return werror_to_ntstatus(werr
);
1553 static WERROR
regdb_delete_subkey(const char *key
, const char *subkey
, bool lazy
)
1557 struct regdb_delete_subkey_context delete_ctx
;
1558 TALLOC_CTX
*mem_ctx
= talloc_stackframe();
1560 if (!regdb_key_exists(regdb
, key
)) {
1561 werr
= WERR_NOT_FOUND
;
1565 path
= talloc_asprintf(mem_ctx
, "%s\\%s", key
, subkey
);
1567 werr
= WERR_NOT_ENOUGH_MEMORY
;
1571 if (!regdb_key_exists(regdb
, path
)) {
1576 delete_ctx
.key
= key
;
1577 delete_ctx
.subkey
= subkey
;
1578 delete_ctx
.path
= path
;
1579 delete_ctx
.lazy
= lazy
;
1581 werr
= regdb_trans_do(regdb
,
1582 regdb_delete_subkey_action
,
1586 talloc_free(mem_ctx
);
1590 static TDB_DATA
regdb_fetch_key_internal(struct db_context
*db
,
1591 TALLOC_CTX
*mem_ctx
, const char *key
)
1597 path
= normalize_reg_path(mem_ctx
, key
);
1599 return make_tdb_data(NULL
, 0);
1602 status
= dbwrap_fetch_bystring(db
, mem_ctx
, path
, &data
);
1603 if (!NT_STATUS_IS_OK(status
)) {
1613 * Check for the existence of a key.
1615 * Existence of a key is authoritatively defined by
1616 * the existence of the record that contains the list
1619 * Return false, if the record does not match the correct
1620 * structure of an initial 4-byte counter and then a
1621 * list of the corresponding number of zero-terminated
1624 static bool regdb_key_exists(struct db_context
*db
, const char *key
)
1626 TALLOC_CTX
*mem_ctx
= talloc_stackframe();
1632 uint32_t num_items
, i
;
1639 path
= normalize_reg_path(mem_ctx
, key
);
1641 DEBUG(0, ("out of memory! (talloc failed)\n"));
1645 if (*path
== '\0') {
1649 value
= regdb_fetch_key_internal(db
, mem_ctx
, path
);
1650 if (value
.dptr
== NULL
) {
1654 if (value
.dsize
== 0) {
1655 DEBUG(10, ("regdb_key_exists: subkeylist-record for key "
1656 "[%s] is empty: Could be a deleted record in a "
1657 "clustered (ctdb) environment?\n",
1662 len
= tdb_unpack(value
.dptr
, value
.dsize
, "d", &num_items
);
1663 if (len
== (int32_t)-1) {
1664 DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record for key "
1665 "[%s] is invalid: Could not parse initial 4-byte "
1666 "counter. record data length is %u.\n",
1667 path
, (unsigned int)value
.dsize
));
1672 * Note: the tdb_unpack check above implies that len <= value.dsize
1674 buflen
= value
.dsize
- len
;
1675 buf
= (const char *)value
.dptr
+ len
;
1679 for (i
= 0; i
< num_items
; i
++) {
1683 len
= strnlen(buf
, buflen
) + 1;
1685 DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record "
1686 "for key [%s] is corrupt: %u items expected, "
1687 "item number %u is not zero terminated.\n",
1688 path
, num_items
, i
+1));
1697 DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record for key "
1698 "[%s] is corrupt: %u items expected and found, but "
1699 "the record contains additional %u bytes\n",
1700 path
, num_items
, buflen
));
1704 if (i
< num_items
) {
1705 DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record for key "
1706 "[%s] is corrupt: %u items expected, but only %u "
1708 path
, num_items
, i
+1));
1715 TALLOC_FREE(mem_ctx
);
1720 /***********************************************************************
1721 Retrieve an array of strings containing subkeys. Memory should be
1722 released by the caller.
1723 ***********************************************************************/
1725 static WERROR
regdb_fetch_keys_internal(struct db_context
*db
, const char *key
,
1726 struct regsubkey_ctr
*ctr
)
1731 uint32_t buflen
, len
;
1734 TALLOC_CTX
*frame
= talloc_stackframe();
1736 int seqnum
[2], count
;
1738 DEBUG(11,("regdb_fetch_keys: Enter key => [%s]\n", key
? key
: "NULL"));
1740 if (!regdb_key_exists(db
, key
)) {
1741 DEBUG(10, ("key [%s] not found\n", key
));
1742 werr
= WERR_NOT_FOUND
;
1746 werr
= regsubkey_ctr_reinit(ctr
);
1747 W_ERROR_NOT_OK_GOTO_DONE(werr
);
1751 seqnum
[0] = dbwrap_get_seqnum(db
);
1755 TALLOC_FREE(value
.dptr
);
1756 value
= regdb_fetch_key_internal(db
, frame
, key
);
1757 seqnum
[count
% 2] = dbwrap_get_seqnum(db
);
1759 } while (seqnum
[0] != seqnum
[1]);
1762 DEBUG(5, ("regdb_fetch_keys_internal: it took %d attempts to "
1763 "fetch key '%s' with constant seqnum\n",
1767 werr
= regsubkey_ctr_set_seqnum(ctr
, seqnum
[0]);
1768 if (!W_ERROR_IS_OK(werr
)) {
1772 if (value
.dsize
== 0 || value
.dptr
== NULL
) {
1773 DEBUG(10, ("regdb_fetch_keys: no subkeys found for key [%s]\n",
1779 buflen
= value
.dsize
;
1780 len
= tdb_unpack( buf
, buflen
, "d", &num_items
);
1781 if (len
== (uint32_t)-1) {
1782 werr
= WERR_NOT_FOUND
;
1786 for (i
=0; i
<num_items
; i
++) {
1787 len
+= tdb_unpack(buf
+len
, buflen
-len
, "f", subkeyname
);
1788 werr
= regsubkey_ctr_addkey(ctr
, subkeyname
);
1789 if (!W_ERROR_IS_OK(werr
)) {
1790 DEBUG(5, ("regdb_fetch_keys: regsubkey_ctr_addkey "
1791 "failed: %s\n", win_errstr(werr
)));
1797 DEBUG(11,("regdb_fetch_keys: Exit [%d] items\n", num_items
));
1804 static int regdb_fetch_keys(const char *key
, struct regsubkey_ctr
*ctr
)
1808 werr
= regdb_fetch_keys_internal(regdb
, key
, ctr
);
1809 if (!W_ERROR_IS_OK(werr
)) {
1813 return regsubkey_ctr_numkeys(ctr
);
1816 /****************************************************************************
1817 Unpack a list of registry values frem the TDB
1818 ***************************************************************************/
1820 static int regdb_unpack_values(struct regval_ctr
*values
, uint8_t *buf
, int buflen
)
1827 uint32_t num_values
= 0;
1830 /* loop and unpack the rest of the registry values */
1832 len
+= tdb_unpack(buf
+len
, buflen
-len
, "d", &num_values
);
1834 for ( i
=0; i
<num_values
; i
++ ) {
1835 /* unpack the next regval */
1840 valuename
[0] = '\0';
1841 len
+= tdb_unpack(buf
+len
, buflen
-len
, "fdB",
1847 regval_ctr_addvalue(values
, valuename
, type
,
1848 (uint8_t *)data_p
, size
);
1849 SAFE_FREE(data_p
); /* 'B' option to tdb_unpack does a malloc() */
1851 DEBUG(10, ("regdb_unpack_values: value[%d]: name[%s] len[%d]\n",
1852 i
, valuename
, size
));
1858 /****************************************************************************
1859 Pack all values in all printer keys
1860 ***************************************************************************/
1862 static int regdb_pack_values(struct regval_ctr
*values
, uint8_t *buf
, int buflen
)
1866 struct regval_blob
*val
;
1872 num_values
= regval_ctr_numvals( values
);
1874 /* pack the number of values first */
1876 len
+= tdb_pack( buf
+len
, buflen
-len
, "d", num_values
);
1878 /* loop over all values */
1880 for ( i
=0; i
<num_values
; i
++ ) {
1881 val
= regval_ctr_specific_value( values
, i
);
1882 len
+= tdb_pack(buf
+len
, buflen
-len
, "fdB",
1886 regval_data_p(val
) );
1892 /***********************************************************************
1893 Retrieve an array of strings containing subkeys. Memory should be
1894 released by the caller.
1895 ***********************************************************************/
1897 static int regdb_fetch_values_internal(struct db_context
*db
, const char* key
,
1898 struct regval_ctr
*values
)
1900 char *keystr
= NULL
;
1901 TALLOC_CTX
*ctx
= talloc_stackframe();
1905 int seqnum
[2], count
;
1907 DEBUG(10,("regdb_fetch_values: Looking for values of key [%s]\n", key
));
1909 if (!regdb_key_exists(db
, key
)) {
1910 DEBUG(10, ("regb_fetch_values: key [%s] does not exist\n",
1916 keystr
= talloc_asprintf(ctx
, "%s\\%s", REG_VALUE_PREFIX
, key
);
1923 seqnum
[0] = dbwrap_get_seqnum(db
);
1927 TALLOC_FREE(value
.dptr
);
1928 value
= regdb_fetch_key_internal(db
, ctx
, keystr
);
1929 seqnum
[count
% 2] = dbwrap_get_seqnum(db
);
1930 } while (seqnum
[0] != seqnum
[1]);
1933 DEBUG(5, ("regdb_fetch_values_internal: it took %d attempts "
1934 "to fetch key '%s' with constant seqnum\n",
1938 werr
= regval_ctr_set_seqnum(values
, seqnum
[0]);
1939 if (!W_ERROR_IS_OK(werr
)) {
1944 /* all keys have zero values by default */
1948 regdb_unpack_values(values
, value
.dptr
, value
.dsize
);
1949 ret
= regval_ctr_numvals(values
);
1956 static int regdb_fetch_values(const char* key
, struct regval_ctr
*values
)
1958 return regdb_fetch_values_internal(regdb
, key
, values
);
1961 static NTSTATUS
regdb_store_values_internal(struct db_context
*db
,
1963 struct regval_ctr
*values
)
1965 TDB_DATA old_data
, data
;
1966 char *keystr
= NULL
;
1967 TALLOC_CTX
*ctx
= talloc_stackframe();
1972 DEBUG(10,("regdb_store_values: Looking for values of key [%s]\n", key
));
1974 if (!regdb_key_exists(db
, key
)) {
1975 status
= NT_STATUS_NOT_FOUND
;
1979 if (regval_ctr_numvals(values
) == 0) {
1980 werr
= regdb_delete_values(db
, key
);
1981 if (!W_ERROR_IS_OK(werr
)) {
1982 status
= werror_to_ntstatus(werr
);
1987 * update the seqnum in the cache to prevent the next read
1988 * from going to disk
1990 werr
= regval_ctr_set_seqnum(values
, dbwrap_get_seqnum(db
));
1991 status
= werror_to_ntstatus(werr
);
1997 len
= regdb_pack_values(values
, data
.dptr
, data
.dsize
);
1999 DEBUG(0,("regdb_store_values: unable to pack values. len <= 0\n"));
2000 status
= NT_STATUS_UNSUCCESSFUL
;
2004 data
.dptr
= talloc_array(ctx
, uint8_t, len
);
2007 len
= regdb_pack_values(values
, data
.dptr
, data
.dsize
);
2009 SMB_ASSERT( len
== data
.dsize
);
2011 keystr
= talloc_asprintf(ctx
, "%s\\%s", REG_VALUE_PREFIX
, key
);
2013 status
= NT_STATUS_NO_MEMORY
;
2016 keystr
= normalize_reg_path(ctx
, keystr
);
2018 status
= NT_STATUS_NO_MEMORY
;
2022 status
= dbwrap_fetch_bystring(db
, ctx
, keystr
, &old_data
);
2024 if (NT_STATUS_IS_OK(status
)
2025 && (old_data
.dptr
!= NULL
)
2026 && (old_data
.dsize
== data
.dsize
)
2027 && (memcmp(old_data
.dptr
, data
.dptr
, data
.dsize
) == 0))
2029 status
= NT_STATUS_OK
;
2033 status
= dbwrap_trans_store_bystring(db
, keystr
, data
, TDB_REPLACE
);
2034 if (!NT_STATUS_IS_OK(status
)) {
2035 DEBUG(0, ("regdb_store_values_internal: error storing: %s\n", nt_errstr(status
)));
2040 * update the seqnum in the cache to prevent the next read
2041 * from going to disk
2043 werr
= regval_ctr_set_seqnum(values
, dbwrap_get_seqnum(db
));
2044 status
= werror_to_ntstatus(werr
);
2051 struct regdb_store_values_ctx
{
2053 struct regval_ctr
*values
;
2056 static NTSTATUS
regdb_store_values_action(struct db_context
*db
,
2060 struct regdb_store_values_ctx
*ctx
=
2061 (struct regdb_store_values_ctx
*)private_data
;
2063 status
= regdb_store_values_internal(db
, ctx
->key
, ctx
->values
);
2068 static bool regdb_store_values(const char *key
, struct regval_ctr
*values
)
2071 struct regdb_store_values_ctx ctx
;
2074 ctx
.values
= values
;
2076 werr
= regdb_trans_do(regdb
, regdb_store_values_action
, &ctx
);
2078 return W_ERROR_IS_OK(werr
);
2081 static WERROR
regdb_get_secdesc(TALLOC_CTX
*mem_ctx
, const char *key
,
2082 struct security_descriptor
**psecdesc
)
2087 TALLOC_CTX
*tmp_ctx
= talloc_stackframe();
2088 WERROR err
= WERR_OK
;
2090 DEBUG(10, ("regdb_get_secdesc: Getting secdesc of key [%s]\n", key
));
2092 if (!regdb_key_exists(regdb
, key
)) {
2093 err
= WERR_FILE_NOT_FOUND
;
2097 tdbkey
= talloc_asprintf(tmp_ctx
, "%s\\%s", REG_SECDESC_PREFIX
, key
);
2098 if (tdbkey
== NULL
) {
2099 err
= WERR_NOT_ENOUGH_MEMORY
;
2103 tdbkey
= normalize_reg_path(tmp_ctx
, tdbkey
);
2104 if (tdbkey
== NULL
) {
2105 err
= WERR_NOT_ENOUGH_MEMORY
;
2109 status
= dbwrap_fetch_bystring(regdb
, tmp_ctx
, tdbkey
, &data
);
2110 if (!NT_STATUS_IS_OK(status
)) {
2111 err
= WERR_FILE_NOT_FOUND
;
2115 status
= unmarshall_sec_desc(mem_ctx
, (uint8_t *)data
.dptr
, data
.dsize
,
2118 if (NT_STATUS_EQUAL(status
, NT_STATUS_NO_MEMORY
)) {
2119 err
= WERR_NOT_ENOUGH_MEMORY
;
2120 } else if (!NT_STATUS_IS_OK(status
)) {
2121 err
= WERR_REGISTRY_CORRUPT
;
2125 TALLOC_FREE(tmp_ctx
);
2129 struct regdb_set_secdesc_ctx
{
2131 struct security_descriptor
*secdesc
;
2134 static NTSTATUS
regdb_set_secdesc_action(struct db_context
*db
,
2140 struct regdb_set_secdesc_ctx
*ctx
=
2141 (struct regdb_set_secdesc_ctx
*)private_data
;
2142 TALLOC_CTX
*frame
= talloc_stackframe();
2144 tdbkey
= talloc_asprintf(frame
, "%s\\%s", REG_SECDESC_PREFIX
, ctx
->key
);
2145 if (tdbkey
== NULL
) {
2146 status
= NT_STATUS_NO_MEMORY
;
2150 tdbkey
= normalize_reg_path(frame
, tdbkey
);
2151 if (tdbkey
== NULL
) {
2152 status
= NT_STATUS_NO_MEMORY
;
2156 if (ctx
->secdesc
== NULL
) {
2157 /* assuming a delete */
2158 status
= dbwrap_delete_bystring(db
, tdbkey
);
2162 status
= marshall_sec_desc(frame
, ctx
->secdesc
, &tdbdata
.dptr
,
2164 if (!NT_STATUS_IS_OK(status
)) {
2168 status
= dbwrap_store_bystring(db
, tdbkey
, tdbdata
, 0);
2175 static WERROR
regdb_set_secdesc(const char *key
,
2176 struct security_descriptor
*secdesc
)
2179 struct regdb_set_secdesc_ctx ctx
;
2181 if (!regdb_key_exists(regdb
, key
)) {
2182 err
= WERR_FILE_NOT_FOUND
;
2187 ctx
.secdesc
= secdesc
;
2189 err
= regdb_trans_do(regdb
, regdb_set_secdesc_action
, &ctx
);
2195 static bool regdb_subkeys_need_update(struct regsubkey_ctr
*subkeys
)
2197 return (regdb_get_seqnum() != regsubkey_ctr_get_seqnum(subkeys
));
2200 static bool regdb_values_need_update(struct regval_ctr
*values
)
2202 return (regdb_get_seqnum() != regval_ctr_get_seqnum(values
));
2206 * Table of function pointers for default access
2209 struct registry_ops regdb_ops
= {
2210 .fetch_subkeys
= regdb_fetch_keys
,
2211 .fetch_values
= regdb_fetch_values
,
2212 .store_subkeys
= regdb_store_keys
,
2213 .store_values
= regdb_store_values
,
2214 .create_subkey
= regdb_create_subkey
,
2215 .delete_subkey
= regdb_delete_subkey
,
2216 .get_secdesc
= regdb_get_secdesc
,
2217 .set_secdesc
= regdb_set_secdesc
,
2218 .subkeys_need_update
= regdb_subkeys_need_update
,
2219 .values_need_update
= regdb_values_need_update