2 Unix SMB/CIFS implementation.
3 Transparent registry backend handling
4 Copyright (C) Jelmer Vernooij 2003-2007.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 #include "../lib/util/dlinklist.h"
22 #include "lib/registry/registry.h"
23 #include "system/filesys.h"
28 * @brief Main registry functions
31 const struct reg_predefined_key reg_predefined_keys
[] = {
32 {HKEY_CLASSES_ROOT
,"HKEY_CLASSES_ROOT" },
33 {HKEY_CURRENT_USER
,"HKEY_CURRENT_USER" },
34 {HKEY_LOCAL_MACHINE
, "HKEY_LOCAL_MACHINE" },
35 {HKEY_PERFORMANCE_DATA
, "HKEY_PERFORMANCE_DATA" },
36 {HKEY_USERS
, "HKEY_USERS" },
37 {HKEY_CURRENT_CONFIG
, "HKEY_CURRENT_CONFIG" },
38 {HKEY_DYN_DATA
, "HKEY_DYN_DATA" },
39 {HKEY_PERFORMANCE_TEXT
, "HKEY_PERFORMANCE_TEXT" },
40 {HKEY_PERFORMANCE_NLSTEXT
, "HKEY_PERFORMANCE_NLSTEXT" },
44 /** Obtain name of specific hkey. */
45 _PUBLIC_
const char *reg_get_predef_name(uint32_t hkey
)
48 for (i
= 0; reg_predefined_keys
[i
].name
; i
++) {
49 if (reg_predefined_keys
[i
].handle
== hkey
)
50 return reg_predefined_keys
[i
].name
;
56 /** Get predefined key by name. */
57 _PUBLIC_ WERROR
reg_get_predefined_key_by_name(struct registry_context
*ctx
,
59 struct registry_key
**key
)
63 for (i
= 0; reg_predefined_keys
[i
].name
; i
++) {
64 if (!strcasecmp(reg_predefined_keys
[i
].name
, name
))
65 return reg_get_predefined_key(ctx
,
66 reg_predefined_keys
[i
].handle
,
70 DEBUG(1, ("No predefined key with name '%s'\n", name
));
75 /** Get predefined key by id. */
76 _PUBLIC_ WERROR
reg_get_predefined_key(struct registry_context
*ctx
,
77 uint32_t hkey
, struct registry_key
**key
)
79 return ctx
->ops
->get_predefined_key(ctx
, hkey
, key
);
84 * First tries to use the open_key function from the backend
85 * then falls back to get_subkey_by_name and later get_subkey_by_index
87 _PUBLIC_ WERROR
reg_open_key(TALLOC_CTX
*mem_ctx
, struct registry_key
*parent
,
88 const char *name
, struct registry_key
**result
)
91 DEBUG(0, ("Invalid parent key specified for open of '%s'\n",
93 return WERR_INVALID_PARAM
;
96 if (parent
->context
->ops
->open_key
== NULL
) {
97 DEBUG(0, ("Registry backend doesn't have open_key!\n"));
98 return WERR_NOT_SUPPORTED
;
101 return parent
->context
->ops
->open_key(mem_ctx
, parent
, name
, result
);
107 _PUBLIC_ WERROR
reg_key_get_value_by_index(TALLOC_CTX
*mem_ctx
,
108 const struct registry_key
*key
,
109 uint32_t idx
, const char **name
,
110 uint32_t *type
, DATA_BLOB
*data
)
113 return WERR_INVALID_PARAM
;
115 if (key
->context
->ops
->enum_value
== NULL
)
116 return WERR_NOT_SUPPORTED
;
118 return key
->context
->ops
->enum_value(mem_ctx
, key
, idx
, name
,
123 * Get the number of subkeys.
125 _PUBLIC_ WERROR
reg_key_get_info(TALLOC_CTX
*mem_ctx
,
126 const struct registry_key
*key
,
127 const char **classname
,
128 uint32_t *num_subkeys
,
129 uint32_t *num_values
,
130 NTTIME
*last_change_time
,
131 uint32_t *max_subkeynamelen
,
132 uint32_t *max_valnamelen
,
133 uint32_t *max_valbufsize
)
136 return WERR_INVALID_PARAM
;
138 if (key
->context
->ops
->get_key_info
== NULL
)
139 return WERR_NOT_SUPPORTED
;
141 return key
->context
->ops
->get_key_info(mem_ctx
,
142 key
, classname
, num_subkeys
,
143 num_values
, last_change_time
,
145 max_valnamelen
, max_valbufsize
);
149 * Get subkey by index.
151 _PUBLIC_ WERROR
reg_key_get_subkey_by_index(TALLOC_CTX
*mem_ctx
,
152 const struct registry_key
*key
,
153 uint32_t idx
, const char **name
,
154 const char **keyclass
,
155 NTTIME
*last_changed_time
)
158 return WERR_INVALID_PARAM
;
160 if (key
->context
->ops
->enum_key
== NULL
)
161 return WERR_NOT_SUPPORTED
;
163 return key
->context
->ops
->enum_key(mem_ctx
, key
, idx
, name
,
164 keyclass
, last_changed_time
);
170 _PUBLIC_ WERROR
reg_key_get_value_by_name(TALLOC_CTX
*mem_ctx
,
171 const struct registry_key
*key
,
177 return WERR_INVALID_PARAM
;
179 if (key
->context
->ops
->get_value
== NULL
)
180 return WERR_NOT_SUPPORTED
;
182 return key
->context
->ops
->get_value(mem_ctx
, key
, name
, type
, data
);
188 _PUBLIC_ WERROR
reg_key_del(struct registry_key
*parent
, const char *name
)
191 return WERR_INVALID_PARAM
;
193 if (parent
->context
->ops
->delete_key
== NULL
)
194 return WERR_NOT_SUPPORTED
;
196 return parent
->context
->ops
->delete_key(parent
, name
);
202 _PUBLIC_ WERROR
reg_key_add_name(TALLOC_CTX
*mem_ctx
,
203 struct registry_key
*parent
,
204 const char *name
, const char *key_class
,
205 struct security_descriptor
*desc
,
206 struct registry_key
**newkey
)
209 return WERR_INVALID_PARAM
;
211 if (parent
->context
->ops
->create_key
== NULL
) {
212 DEBUG(1, ("Backend '%s' doesn't support method add_key\n",
213 parent
->context
->ops
->name
));
214 return WERR_NOT_SUPPORTED
;
217 return parent
->context
->ops
->create_key(mem_ctx
, parent
, name
,
218 key_class
, desc
, newkey
);
224 _PUBLIC_ WERROR
reg_val_set(struct registry_key
*key
, const char *value
,
225 uint32_t type
, const DATA_BLOB data
)
228 return WERR_INVALID_PARAM
;
230 /* A 'real' set function has preference */
231 if (key
->context
->ops
->set_value
== NULL
) {
232 DEBUG(1, ("Backend '%s' doesn't support method set_value\n",
233 key
->context
->ops
->name
));
234 return WERR_NOT_SUPPORTED
;
237 return key
->context
->ops
->set_value(key
, value
, type
, data
);
241 * Get the security descriptor on a key.
243 _PUBLIC_ WERROR
reg_get_sec_desc(TALLOC_CTX
*ctx
,
244 const struct registry_key
*key
,
245 struct security_descriptor
**secdesc
)
248 return WERR_INVALID_PARAM
;
250 /* A 'real' set function has preference */
251 if (key
->context
->ops
->get_sec_desc
== NULL
)
252 return WERR_NOT_SUPPORTED
;
254 return key
->context
->ops
->get_sec_desc(ctx
, key
, secdesc
);
260 _PUBLIC_ WERROR
reg_del_value(struct registry_key
*key
, const char *valname
)
263 return WERR_INVALID_PARAM
;
265 if (key
->context
->ops
->delete_value
== NULL
)
266 return WERR_NOT_SUPPORTED
;
268 return key
->context
->ops
->delete_value(key
, valname
);
272 * Flush a key to disk.
274 _PUBLIC_ WERROR
reg_key_flush(struct registry_key
*key
)
277 return WERR_INVALID_PARAM
;
279 if (key
->context
->ops
->flush_key
== NULL
)
280 return WERR_NOT_SUPPORTED
;
282 return key
->context
->ops
->flush_key(key
);
285 _PUBLIC_ WERROR
reg_set_sec_desc(struct registry_key
*key
,
286 const struct security_descriptor
*security
)
289 return WERR_INVALID_PARAM
;
291 if (key
->context
->ops
->set_sec_desc
== NULL
)
292 return WERR_NOT_SUPPORTED
;
294 return key
->context
->ops
->set_sec_desc(key
, security
);