source: vendor/3.5.5/source4/lib/registry/registry.h

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

Samba 3.5.0: Initial import
File size: 16.5 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Registry interface
4 Copyright (C) Gerald Carter 2002.
5 Copyright (C) Jelmer Vernooij 2003-2007.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19*/
20
21#ifndef _REGISTRY_H /* _REGISTRY_H */
22#define _REGISTRY_H
23
24struct registry_context;
25struct loadparm_context;
26struct smb_iconv_convenience;
27
28#include <talloc.h>
29#include "libcli/util/werror.h"
30#include "librpc/gen_ndr/security.h"
31#include "libcli/util/ntstatus.h"
32#include "../lib/util/time.h"
33#include "../lib/util/data_blob.h"
34
35/**
36 * The hive API. This API is generally used for
37 * reading a specific file that contains just one hive.
38 *
39 * Good examples are .DAT (NTUSER.DAT) files.
40 *
41 * This API does not have any notification support (that
42 * should be provided by the registry implementation), nor
43 * does it understand what predefined keys are.
44 */
45
46struct hive_key {
47 const struct hive_operations *ops;
48};
49
50struct hive_operations {
51 const char *name;
52
53 /**
54 * Open a specific subkey
55 */
56 WERROR (*enum_key) (TALLOC_CTX *mem_ctx,
57 const struct hive_key *key, uint32_t idx,
58 const char **name,
59 const char **classname,
60 NTTIME *last_mod_time);
61
62 /**
63 * Open a subkey by name
64 */
65 WERROR (*get_key_by_name) (TALLOC_CTX *mem_ctx,
66 const struct hive_key *key, const char *name,
67 struct hive_key **subkey);
68
69 /**
70 * Add a new key.
71 */
72 WERROR (*add_key) (TALLOC_CTX *ctx,
73 const struct hive_key *parent_key, const char *name,
74 const char *classname,
75 struct security_descriptor *desc,
76 struct hive_key **key);
77 /**
78 * Remove an existing key.
79 */
80 WERROR (*del_key) (const struct hive_key *key, const char *name);
81
82 /**
83 * Force write of a key to disk.
84 */
85 WERROR (*flush_key) (struct hive_key *key);
86
87 /**
88 * Retrieve a registry value with a specific index.
89 */
90 WERROR (*enum_value) (TALLOC_CTX *mem_ctx,
91 struct hive_key *key, int idx,
92 const char **name, uint32_t *type,
93 DATA_BLOB *data);
94
95 /**
96 * Retrieve a registry value with the specified name
97 */
98 WERROR (*get_value_by_name) (TALLOC_CTX *mem_ctx,
99 struct hive_key *key, const char *name,
100 uint32_t *type, DATA_BLOB *data);
101
102 /**
103 * Set a value on the specified registry key.
104 */
105 WERROR (*set_value) (struct hive_key *key, const char *name,
106 uint32_t type, const DATA_BLOB data);
107
108 /**
109 * Remove a value.
110 */
111 WERROR (*delete_value) (struct hive_key *key, const char *name);
112
113 /* Security Descriptors */
114
115 /**
116 * Change the security descriptor on a registry key.
117 *
118 * This should return WERR_NOT_SUPPORTED if the underlying
119 * format does not have a mechanism for storing
120 * security descriptors.
121 */
122 WERROR (*set_sec_desc) (struct hive_key *key,
123 const struct security_descriptor *desc);
124
125 /**
126 * Retrieve the security descriptor on a registry key.
127 *
128 * This should return WERR_NOT_SUPPORTED if the underlying
129 * format does not have a mechanism for storing
130 * security descriptors.
131 */
132 WERROR (*get_sec_desc) (TALLOC_CTX *ctx,
133 const struct hive_key *key,
134 struct security_descriptor **desc);
135
136 /**
137 * Retrieve general information about a key.
138 */
139 WERROR (*get_key_info) (TALLOC_CTX *mem_ctx,
140 const struct hive_key *key,
141 const char **classname,
142 uint32_t *num_subkeys,
143 uint32_t *num_values,
144 NTTIME *last_change_time,
145 uint32_t *max_subkeynamelen,
146 uint32_t *max_valnamelen,
147 uint32_t *max_valbufsize);
148};
149
150struct cli_credentials;
151struct auth_session_info;
152struct tevent_context;
153
154WERROR reg_open_hive(TALLOC_CTX *parent_ctx, const char *location,
155 struct auth_session_info *session_info,
156 struct cli_credentials *credentials,
157 struct tevent_context *ev_ctx,
158 struct loadparm_context *lp_ctx,
159 struct hive_key **root);
160WERROR hive_key_get_info(TALLOC_CTX *mem_ctx, const struct hive_key *key,
161 const char **classname, uint32_t *num_subkeys,
162 uint32_t *num_values, NTTIME *last_change_time,
163 uint32_t *max_subkeynamelen,
164 uint32_t *max_valnamelen, uint32_t *max_valbufsize);
165WERROR hive_key_add_name(TALLOC_CTX *ctx, const struct hive_key *parent_key,
166 const char *name, const char *classname,
167 struct security_descriptor *desc,
168 struct hive_key **key);
169WERROR hive_key_del(const struct hive_key *key, const char *name);
170WERROR hive_get_key_by_name(TALLOC_CTX *mem_ctx,
171 const struct hive_key *key, const char *name,
172 struct hive_key **subkey);
173WERROR hive_enum_key(TALLOC_CTX *mem_ctx,
174 const struct hive_key *key, uint32_t idx,
175 const char **name,
176 const char **classname,
177 NTTIME *last_mod_time);
178
179WERROR hive_key_set_value(struct hive_key *key, const char *name,
180 uint32_t type, const DATA_BLOB data);
181
182WERROR hive_get_value(TALLOC_CTX *mem_ctx,
183 struct hive_key *key, const char *name,
184 uint32_t *type, DATA_BLOB *data);
185WERROR hive_get_value_by_index(TALLOC_CTX *mem_ctx,
186 struct hive_key *key, uint32_t idx,
187 const char **name,
188 uint32_t *type, DATA_BLOB *data);
189WERROR hive_get_sec_desc(TALLOC_CTX *mem_ctx,
190 struct hive_key *key,
191 struct security_descriptor **security);
192
193WERROR hive_set_sec_desc(struct hive_key *key,
194 const struct security_descriptor *security);
195
196WERROR hive_key_del_value(struct hive_key *key, const char *name);
197
198WERROR hive_key_flush(struct hive_key *key);
199
200
201/* Individual backends */
202WERROR reg_open_directory(TALLOC_CTX *parent_ctx,
203 const char *location, struct hive_key **key);
204WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx,
205 const char *location, struct smb_iconv_convenience *iconv_convenience,
206 struct hive_key **key);
207WERROR reg_open_ldb_file(TALLOC_CTX *parent_ctx, const char *location,
208 struct auth_session_info *session_info,
209 struct cli_credentials *credentials,
210 struct tevent_context *ev_ctx,
211 struct loadparm_context *lp_ctx,
212 struct hive_key **k);
213
214
215WERROR reg_create_directory(TALLOC_CTX *parent_ctx,
216 const char *location, struct hive_key **key);
217WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx,
218 struct smb_iconv_convenience *iconv_convenience,
219 const char *location,
220 int major_version,
221 struct hive_key **key);
222
223
224
225/* Handles for the predefined keys */
226#define HKEY_CLASSES_ROOT 0x80000000
227#define HKEY_CURRENT_USER 0x80000001
228#define HKEY_LOCAL_MACHINE 0x80000002
229#define HKEY_USERS 0x80000003
230#define HKEY_PERFORMANCE_DATA 0x80000004
231#define HKEY_CURRENT_CONFIG 0x80000005
232#define HKEY_DYN_DATA 0x80000006
233#define HKEY_PERFORMANCE_TEXT 0x80000050
234#define HKEY_PERFORMANCE_NLSTEXT 0x80000060
235
236#define HKEY_FIRST HKEY_CLASSES_ROOT
237#define HKEY_LAST HKEY_PERFORMANCE_NLSTEXT
238
239struct reg_predefined_key {
240 uint32_t handle;
241 const char *name;
242};
243
244extern const struct reg_predefined_key reg_predefined_keys[];
245
246#define REG_DELETE -1
247
248/*
249 * The general idea here is that every backend provides a 'hive'. Combining
250 * various hives gives you a complete registry like windows has
251 */
252
253#define REGISTRY_INTERFACE_VERSION 1
254
255struct reg_key_operations;
256
257/* structure to store the registry handles */
258struct registry_key
259{
260 struct registry_context *context;
261};
262
263struct registry_value
264{
265 const char *name;
266 unsigned int data_type;
267 DATA_BLOB data;
268};
269
270/* FIXME */
271typedef void (*reg_key_notification_function) (void);
272typedef void (*reg_value_notification_function) (void);
273
274struct cli_credentials;
275
276struct registry_operations {
277 const char *name;
278
279 WERROR (*get_key_info) (TALLOC_CTX *mem_ctx,
280 const struct registry_key *key,
281 const char **classname,
282 uint32_t *numsubkeys,
283 uint32_t *numvalues,
284 NTTIME *last_change_time,
285 uint32_t *max_subkeynamelen,
286 uint32_t *max_valnamelen,
287 uint32_t *max_valbufsize);
288
289 WERROR (*flush_key) (struct registry_key *key);
290
291 WERROR (*get_predefined_key) (struct registry_context *ctx,
292 uint32_t key_id,
293 struct registry_key **key);
294
295 WERROR (*open_key) (TALLOC_CTX *mem_ctx,
296 struct registry_key *parent,
297 const char *path,
298 struct registry_key **key);
299
300 WERROR (*create_key) (TALLOC_CTX *mem_ctx,
301 struct registry_key *parent,
302 const char *name,
303 const char *key_class,
304 struct security_descriptor *security,
305 struct registry_key **key);
306
307 WERROR (*delete_key) (struct registry_key *key, const char *name);
308
309 WERROR (*delete_value) (struct registry_key *key, const char *name);
310
311 WERROR (*enum_key) (TALLOC_CTX *mem_ctx,
312 const struct registry_key *key, uint32_t idx,
313 const char **name,
314 const char **keyclass,
315 NTTIME *last_changed_time);
316
317 WERROR (*enum_value) (TALLOC_CTX *mem_ctx,
318 const struct registry_key *key, uint32_t idx,
319 const char **name,
320 uint32_t *type,
321 DATA_BLOB *data);
322
323 WERROR (*get_sec_desc) (TALLOC_CTX *mem_ctx,
324 const struct registry_key *key,
325 struct security_descriptor **security);
326
327 WERROR (*set_sec_desc) (struct registry_key *key,
328 const struct security_descriptor *security);
329
330 WERROR (*load_key) (struct registry_key *key,
331 const char *key_name,
332 const char *path);
333
334 WERROR (*unload_key) (struct registry_key *key, const char *name);
335
336 WERROR (*notify_value_change) (struct registry_key *key,
337 reg_value_notification_function fn);
338
339 WERROR (*get_value) (TALLOC_CTX *mem_ctx,
340 const struct registry_key *key,
341 const char *name,
342 uint32_t *type,
343 DATA_BLOB *data);
344
345 WERROR (*set_value) (struct registry_key *key,
346 const char *name,
347 uint32_t type,
348 const DATA_BLOB data);
349};
350
351/**
352 * Handle to a full registry
353 * contains zero or more hives
354 */
355struct registry_context {
356 const struct registry_operations *ops;
357};
358
359struct auth_session_info;
360struct tevent_context;
361struct loadparm_context;
362
363/**
364 * Open the locally defined registry.
365 */
366WERROR reg_open_local(TALLOC_CTX *mem_ctx,
367 struct registry_context **ctx);
368
369WERROR reg_open_samba(TALLOC_CTX *mem_ctx,
370 struct registry_context **ctx,
371 struct tevent_context *ev_ctx,
372 struct loadparm_context *lp_ctx,
373 struct auth_session_info *session_info,
374 struct cli_credentials *credentials);
375
376/**
377 * Open the registry on a remote machine.
378 */
379WERROR reg_open_remote(struct registry_context **ctx,
380 struct auth_session_info *session_info,
381 struct cli_credentials *credentials,
382 struct loadparm_context *lp_ctx,
383 const char *location, struct tevent_context *ev);
384
385WERROR reg_open_wine(struct registry_context **ctx, const char *path);
386
387const char *reg_get_predef_name(uint32_t hkey);
388WERROR reg_get_predefined_key_by_name(struct registry_context *ctx,
389 const char *name,
390 struct registry_key **key);
391WERROR reg_get_predefined_key(struct registry_context *ctx,
392 uint32_t hkey,
393 struct registry_key **key);
394
395WERROR reg_open_key(TALLOC_CTX *mem_ctx, struct registry_key *parent,
396 const char *name, struct registry_key **result);
397
398WERROR reg_key_get_value_by_index(TALLOC_CTX *mem_ctx,
399 const struct registry_key *key, uint32_t idx,
400 const char **name,
401 uint32_t *type,
402 DATA_BLOB *data);
403WERROR reg_key_get_info(TALLOC_CTX *mem_ctx,
404 const struct registry_key *key,
405 const char **class_name,
406 uint32_t *num_subkeys,
407 uint32_t *num_values,
408 NTTIME *last_change_time,
409 uint32_t *max_subkeynamelen,
410 uint32_t *max_valnamelen,
411 uint32_t *max_valbufsize);
412WERROR reg_key_get_subkey_by_index(TALLOC_CTX *mem_ctx,
413 const struct registry_key *key,
414 int idx,
415 const char **name,
416 const char **classname,
417 NTTIME *last_mod_time);
418WERROR reg_key_get_subkey_by_name(TALLOC_CTX *mem_ctx,
419 const struct registry_key *key,
420 const char *name,
421 struct registry_key **subkey);
422WERROR reg_key_get_value_by_name(TALLOC_CTX *mem_ctx,
423 const struct registry_key *key,
424 const char *name,
425 uint32_t *type,
426 DATA_BLOB *data);
427WERROR reg_key_del(struct registry_key *parent, const char *name);
428WERROR reg_key_add_name(TALLOC_CTX *mem_ctx,
429 struct registry_key *parent, const char *name,
430 const char *classname,
431 struct security_descriptor *desc,
432 struct registry_key **newkey);
433WERROR reg_val_set(struct registry_key *key, const char *value,
434 uint32_t type, DATA_BLOB data);
435WERROR reg_get_sec_desc(TALLOC_CTX *ctx, const struct registry_key *key,
436 struct security_descriptor **secdesc);
437WERROR reg_del_value(struct registry_key *key, const char *valname);
438WERROR reg_key_flush(struct registry_key *key);
439WERROR reg_create_key(TALLOC_CTX *mem_ctx,
440 struct registry_key *parent,
441 const char *name,
442 const char *key_class,
443 struct security_descriptor *security,
444 struct registry_key **key);
445
446/* Utility functions */
447const char *str_regtype(int type);
448char *reg_val_data_string(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t type, const DATA_BLOB data);
449char *reg_val_description(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, const char *name,
450 uint32_t type, const DATA_BLOB data);
451bool reg_string_to_val(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, const char *type_str,
452 const char *data_str, uint32_t *type, DATA_BLOB *data);
453WERROR reg_open_key_abs(TALLOC_CTX *mem_ctx, struct registry_context *handle,
454 const char *name, struct registry_key **result);
455WERROR reg_key_del_abs(struct registry_context *ctx, const char *path);
456WERROR reg_key_add_abs(TALLOC_CTX *mem_ctx, struct registry_context *ctx,
457 const char *path, uint32_t access_mask,
458 struct security_descriptor *sec_desc,
459 struct registry_key **result);
460WERROR reg_load_key(struct registry_context *ctx, struct registry_key *key,
461 const char *name, const char *filename);
462
463WERROR reg_mount_hive(struct registry_context *rctx,
464 struct hive_key *hive_key,
465 uint32_t key_id,
466 const char **elements);
467
468struct registry_key *reg_import_hive_key(struct registry_context *ctx,
469 struct hive_key *hive,
470 uint32_t predef_key,
471 const char **elements);
472WERROR reg_set_sec_desc(struct registry_key *key,
473 const struct security_descriptor *security);
474
475struct reg_diff_callbacks {
476 WERROR (*add_key) (void *callback_data, const char *key_name);
477 WERROR (*set_value) (void *callback_data, const char *key_name,
478 const char *value_name, uint32_t value_type,
479 DATA_BLOB value);
480 WERROR (*del_value) (void *callback_data, const char *key_name,
481 const char *value_name);
482 WERROR (*del_key) (void *callback_data, const char *key_name);
483 WERROR (*del_all_values) (void *callback_data, const char *key_name);
484 WERROR (*done) (void *callback_data);
485};
486
487WERROR reg_diff_apply(struct registry_context *ctx,
488 struct smb_iconv_convenience *ic, const char *filename);
489
490WERROR reg_generate_diff(struct registry_context *ctx1,
491 struct registry_context *ctx2,
492 const struct reg_diff_callbacks *callbacks,
493 void *callback_data);
494WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
495 struct smb_iconv_convenience *iconv_convenience,
496 struct reg_diff_callbacks **callbacks,
497 void **callback_data);
498WERROR reg_preg_diff_save(TALLOC_CTX *ctx, const char *filename,
499 struct smb_iconv_convenience *ic,
500 struct reg_diff_callbacks **callbacks,
501 void **callback_data);
502WERROR reg_generate_diff_key(struct registry_key *oldkey,
503 struct registry_key *newkey,
504 const char *path,
505 const struct reg_diff_callbacks *callbacks,
506 void *callback_data);
507WERROR reg_diff_load(const char *filename,
508 struct smb_iconv_convenience *iconv_convenience,
509 const struct reg_diff_callbacks *callbacks,
510 void *callback_data);
511
512WERROR reg_dotreg_diff_load(int fd,
513 struct smb_iconv_convenience *iconv_convenience,
514 const struct reg_diff_callbacks *callbacks,
515 void *callback_data);
516
517WERROR reg_preg_diff_load(int fd,
518 struct smb_iconv_convenience *iconv_convenience,
519 const struct reg_diff_callbacks *callbacks,
520 void *callback_data);
521
522WERROR local_get_predefined_key(struct registry_context *ctx,
523 uint32_t key_id, struct registry_key **key);
524
525
526#endif /* _REGISTRY_H */
Note: See TracBrowser for help on using the repository browser.