f9db39f4ae137f08cc5c036928d4ea9c0f6c448c
[gd/samba-autobuild/.git] / source4 / lib / registry / registry.h
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
24 struct registry_context;
25 struct loadparm_context;
26 struct 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
46 struct hive_key {
47         const struct hive_operations *ops;
48 };
49
50 struct 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
150 struct cli_credentials;
151 struct auth_session_info;
152 struct event_context;
153
154 WERROR reg_open_hive(TALLOC_CTX *parent_ctx, const char *location,
155                      struct auth_session_info *session_info,
156                      struct cli_credentials *credentials,
157                      struct event_context *ev_ctx,
158                      struct loadparm_context *lp_ctx,
159                      struct hive_key **root);
160 WERROR 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);
165 WERROR 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);
169 WERROR hive_key_del(const struct hive_key *key, const char *name);
170 WERROR hive_get_key_by_name(TALLOC_CTX *mem_ctx,
171                             const struct hive_key *key, const char *name,
172                             struct hive_key **subkey);
173 WERROR 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
179 WERROR hive_key_set_value(struct hive_key *key, const char *name,
180                       uint32_t type, const DATA_BLOB data);
181
182 WERROR hive_get_value(TALLOC_CTX *mem_ctx,
183                       struct hive_key *key, const char *name,
184                       uint32_t *type, DATA_BLOB *data);
185 WERROR 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);
189 WERROR hive_get_sec_desc(TALLOC_CTX *mem_ctx,
190                          struct hive_key *key,
191                          struct security_descriptor **security);
192
193 WERROR hive_set_sec_desc(struct hive_key *key, 
194                          const struct security_descriptor *security);
195
196 WERROR hive_key_del_value(struct hive_key *key, const char *name);
197
198 WERROR hive_key_flush(struct hive_key *key);
199
200
201 /* Individual backends */
202 WERROR reg_open_directory(TALLOC_CTX *parent_ctx,
203                           const char *location, struct hive_key **key);
204 WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx,
205                           const char *location, struct smb_iconv_convenience *iconv_convenience,
206                           struct hive_key **key);
207 WERROR 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 event_context *ev_ctx,
211                          struct loadparm_context *lp_ctx,
212                          struct hive_key **k);
213
214
215 WERROR reg_create_directory(TALLOC_CTX *parent_ctx,
216                             const char *location, struct hive_key **key);
217 WERROR 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
239 struct reg_predefined_key {
240         uint32_t handle;
241         const char *name;
242 };
243
244 extern 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
255 struct reg_key_operations;
256
257 /* structure to store the registry handles */
258 struct registry_key
259 {
260         struct registry_context *context;
261 };
262
263 struct registry_value
264 {
265         const char *name;
266         unsigned int data_type;
267         DATA_BLOB data;
268 };
269
270 /* FIXME */
271 typedef void (*reg_key_notification_function) (void);
272 typedef void (*reg_value_notification_function) (void);
273
274 struct cli_credentials;
275
276 struct 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  */
355 struct registry_context {
356         const struct registry_operations *ops;
357 };
358
359 struct auth_session_info;
360 struct event_context;
361 struct loadparm_context;
362
363 /**
364  * Open the locally defined registry.
365  */
366 WERROR reg_open_local(TALLOC_CTX *mem_ctx,
367                       struct registry_context **ctx);
368
369 WERROR reg_open_samba(TALLOC_CTX *mem_ctx,
370                       struct registry_context **ctx,
371                       struct event_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  */
379 WERROR 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 event_context *ev);
384
385 WERROR reg_open_wine(struct registry_context **ctx, const char *path);
386
387 const char *reg_get_predef_name(uint32_t hkey);
388 WERROR reg_get_predefined_key_by_name(struct registry_context *ctx,
389                                       const char *name,
390                                       struct registry_key **key);
391 WERROR reg_get_predefined_key(struct registry_context *ctx,
392                               uint32_t hkey,
393                               struct registry_key **key);
394
395 WERROR reg_open_key(TALLOC_CTX *mem_ctx, struct registry_key *parent,
396                     const char *name, struct registry_key **result);
397
398 WERROR 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);
403 WERROR 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);
412 WERROR 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);
418 WERROR 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);
422 WERROR 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);
427 WERROR reg_key_del(struct registry_key *parent, const char *name);
428 WERROR 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);
433 WERROR reg_val_set(struct registry_key *key, const char *value,
434                    uint32_t type, DATA_BLOB data);
435 WERROR reg_get_sec_desc(TALLOC_CTX *ctx, const struct registry_key *key,
436                         struct security_descriptor **secdesc);
437 WERROR reg_del_value(struct registry_key *key, const char *valname);
438 WERROR reg_key_flush(struct registry_key *key);
439 WERROR 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 */
447 const char *str_regtype(int type);
448 char *reg_val_data_string(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t type, const DATA_BLOB data);
449 char *reg_val_description(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, const char *name,
450                           uint32_t type, const DATA_BLOB data);
451 bool 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);
453 WERROR reg_open_key_abs(TALLOC_CTX *mem_ctx, struct registry_context *handle,
454                         const char *name, struct registry_key **result);
455 WERROR reg_key_del_abs(struct registry_context *ctx, const char *path);
456 WERROR 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);
460 WERROR reg_load_key(struct registry_context *ctx, struct registry_key *key,
461                     const char *name, const char *filename);
462
463 WERROR reg_mount_hive(struct registry_context *rctx,
464                       struct hive_key *hive_key,
465                       uint32_t key_id,
466                       const char **elements);
467
468 struct registry_key *reg_import_hive_key(struct registry_context *ctx,
469                                          struct hive_key *hive,
470                                          uint32_t predef_key,
471                                          const char **elements);
472 WERROR reg_set_sec_desc(struct registry_key *key,
473                         const struct security_descriptor *security);
474
475 struct 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
487 WERROR reg_diff_apply(struct registry_context *ctx, 
488                                           struct smb_iconv_convenience *ic, const char *filename);
489
490 WERROR reg_generate_diff(struct registry_context *ctx1,
491                          struct registry_context *ctx2,
492                          const struct reg_diff_callbacks *callbacks,
493                          void *callback_data);
494 WERROR 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);
498 WERROR 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);
502 WERROR 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);
507 WERROR 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
512 WERROR 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
517 WERROR 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
522 WERROR local_get_predefined_key(struct registry_context *ctx,
523                                 uint32_t key_id, struct registry_key **key);
524
525
526 #endif /* _REGISTRY_H */