libgpo: rename debug_gpext_header to gpext_debug_header.
[metze/samba/wip.git] / source3 / libgpo / gpext / registry.c
1 /*
2  *  Unix SMB/CIFS implementation.
3  *  Group Policy Support
4  *  Copyright (C) Guenther Deschner 2007-2008,2010
5  *
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.
10  *
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.
15  *
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/>.
18  */
19
20 #include "includes.h"
21 #include "../libgpo/gpo_ini.h"
22 #include "../libgpo/gpo.h"
23 #include "libgpo/gpo_proto.h"
24 #include "registry.h"
25 #include "../librpc/gen_ndr/ndr_preg.h"
26
27 #define GP_EXT_NAME "registry"
28
29 /* more info can be found at:
30  * http://msdn2.microsoft.com/en-us/library/aa374407.aspx */
31
32 #define GP_REGPOL_FILE  "Registry.pol"
33
34 #define GP_REGPOL_FILE_SIGNATURE 0x67655250 /* 'PReg' */
35 #define GP_REGPOL_FILE_VERSION 1
36
37 static TALLOC_CTX *ctx = NULL;
38
39 /****************************************************************
40 ****************************************************************/
41
42 static bool reg_parse_value(TALLOC_CTX *mem_ctx,
43                             const char **value,
44                             enum gp_reg_action *action)
45 {
46         if (!*value) {
47                 *action = GP_REG_ACTION_ADD_KEY;
48                 return true;
49         }
50
51         if (strncmp(*value, "**", 2) != 0) {
52                 *action = GP_REG_ACTION_ADD_VALUE;
53                 return true;
54         }
55
56         if (strnequal(*value, "**DelVals.", 10)) {
57                 *action = GP_REG_ACTION_DEL_ALL_VALUES;
58                 return true;
59         }
60
61         if (strnequal(*value, "**Del.", 6)) {
62                 *value = talloc_strdup(mem_ctx, *value + 6);
63                 *action = GP_REG_ACTION_DEL_VALUE;
64                 return true;
65         }
66
67         if (strnequal(*value, "**SecureKey", 11)) {
68                 if (strnequal(*value, "**SecureKey=1", 13)) {
69                         *action = GP_REG_ACTION_SEC_KEY_SET;
70                         return true;
71                 }
72
73  /*************** not tested from here on ***************/
74                 if (strnequal(*value, "**SecureKey=0", 13)) {
75                         smb_panic("not supported: **SecureKey=0");
76                         *action = GP_REG_ACTION_SEC_KEY_RESET;
77                         return true;
78                 }
79                 DEBUG(0,("unknown: SecureKey: %s\n", *value));
80                 smb_panic("not supported SecureKey method");
81                 return false;
82         }
83
84         if (strnequal(*value, "**DeleteValues", strlen("**DeleteValues"))) {
85                 smb_panic("not supported: **DeleteValues");
86                 *action = GP_REG_ACTION_DEL_VALUES;
87                 return false;
88         }
89
90         if (strnequal(*value, "**DeleteKeys", strlen("**DeleteKeys"))) {
91                 smb_panic("not supported: **DeleteKeys");
92                 *action = GP_REG_ACTION_DEL_KEYS;
93                 return false;
94         }
95
96         DEBUG(0,("unknown value: %s\n", *value));
97         smb_panic(*value);
98         return false;
99 }
100
101 /****************************************************************
102 ****************************************************************/
103
104 static bool gp_reg_entry_from_file_entry(TALLOC_CTX *mem_ctx,
105                                          struct preg_entry *r,
106                                          struct gp_registry_entry **reg_entry)
107 {
108         struct registry_value *data = NULL;
109         struct gp_registry_entry *entry = NULL;
110         enum gp_reg_action action = GP_REG_ACTION_NONE;
111
112         ZERO_STRUCTP(*reg_entry);
113
114         data = talloc_zero(mem_ctx, struct registry_value);
115         if (!data)
116                 return false;
117
118         data->type = r->type;
119         data->data = data_blob_talloc(data, r->data, r->size);
120
121         entry = talloc_zero(mem_ctx, struct gp_registry_entry);
122         if (!entry)
123                 return false;
124
125         if (!reg_parse_value(mem_ctx, &r->valuename, &action))
126                 return false;
127
128         entry->key = talloc_strdup(entry, r->keyname);
129         entry->value = talloc_strdup(entry, r->valuename);
130         entry->data = data;
131         entry->action = action;
132
133         *reg_entry = entry;
134
135         return true;
136 }
137
138 /****************************************************************
139 ****************************************************************/
140
141 static NTSTATUS reg_parse_registry(TALLOC_CTX *mem_ctx,
142                                    uint32_t flags,
143                                    const char *filename,
144                                    struct gp_registry_entry **entries_p,
145                                    size_t *num_entries_p)
146 {
147         DATA_BLOB blob;
148         NTSTATUS status;
149         enum ndr_err_code ndr_err;
150         const char *real_filename = NULL;
151         struct preg_file r;
152         struct gp_registry_entry *entries = NULL;
153         size_t num_entries = 0;
154         int i;
155
156         status = gp_find_file(mem_ctx,
157                               flags,
158                               filename,
159                               GP_REGPOL_FILE,
160                               &real_filename);
161         if (!NT_STATUS_IS_OK(status)) {
162                 return status;
163         }
164
165         blob.data = (uint8_t *)file_load(real_filename, &blob.length, 0, NULL);
166         if (!blob.data) {
167                 return NT_STATUS_CANNOT_LOAD_REGISTRY_FILE;
168         }
169
170         ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
171                         (ndr_pull_flags_fn_t)ndr_pull_preg_file);
172         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
173                 status = ndr_map_error2ntstatus(ndr_err);
174                 goto out;
175         }
176
177         if (!strequal(r.header.signature, "PReg")) {
178                 status = NT_STATUS_INVALID_PARAMETER;
179                 goto out;
180         }
181
182         if (r.header.version != GP_REGPOL_FILE_VERSION) {
183                 status = NT_STATUS_INVALID_PARAMETER;
184                 goto out;
185         }
186
187         for (i=0; i < r.num_entries; i++) {
188
189                 struct gp_registry_entry *r_entry = NULL;
190
191                 if (!gp_reg_entry_from_file_entry(mem_ctx,
192                                                   &r.entries[i],
193                                                   &r_entry)) {
194                         status = NT_STATUS_NO_MEMORY;
195                         goto out;
196                 }
197
198                 if (!add_gp_registry_entry_to_array(mem_ctx,
199                                                     r_entry,
200                                                     &entries,
201                                                     &num_entries)) {
202                         status = NT_STATUS_NO_MEMORY;
203                         goto out;
204                 }
205         }
206
207         *entries_p = entries;
208         *num_entries_p = num_entries;
209
210         status = NT_STATUS_OK;
211
212  out:
213         data_blob_free(&blob);
214         return status;
215 }
216
217 /****************************************************************
218 ****************************************************************/
219
220 static WERROR reg_apply_registry(TALLOC_CTX *mem_ctx,
221                                  const struct security_token *token,
222                                  struct registry_key *root_key,
223                                  uint32_t flags,
224                                  struct gp_registry_entry *entries,
225                                  size_t num_entries)
226 {
227         struct gp_registry_context *reg_ctx = NULL;
228         WERROR werr;
229         size_t i;
230
231         if (num_entries == 0) {
232                 return WERR_OK;
233         }
234
235 #if 0
236         if (flags & GPO_LIST_FLAG_MACHINE) {
237                 werr = gp_init_reg_ctx(mem_ctx, KEY_HKLM, REG_KEY_WRITE,
238                                        get_system_token(),
239                                        &reg_ctx);
240         } else {
241                 werr = gp_init_reg_ctx(mem_ctx, KEY_HKCU, REG_KEY_WRITE,
242                                        token,
243                                        &reg_ctx);
244         }
245         W_ERROR_NOT_OK_RETURN(werr);
246 #endif
247         for (i=0; i<num_entries; i++) {
248
249                 /* FIXME: maybe we should check here if we attempt to go beyond
250                  * the 4 allowed reg keys */
251
252                 werr = reg_apply_registry_entry(mem_ctx, root_key,
253                                                 reg_ctx,
254                                                 &(entries)[i],
255                                                 token, flags);
256                 if (!W_ERROR_IS_OK(werr)) {
257                         DEBUG(0,("failed to apply registry: %s\n",
258                                 win_errstr(werr)));
259                         goto done;
260                 }
261         }
262
263 done:
264         gp_free_reg_ctx(reg_ctx);
265         return werr;
266 }
267
268
269 /****************************************************************
270 ****************************************************************/
271
272 static NTSTATUS registry_process_group_policy(TALLOC_CTX *mem_ctx,
273                                               uint32_t flags,
274                                               struct registry_key *root_key,
275                                               const struct security_token *token,
276                                               struct GROUP_POLICY_OBJECT *gpo,
277                                               const char *extension_guid,
278                                               const char *snapin_guid)
279 {
280         NTSTATUS status;
281         WERROR werr;
282         struct gp_registry_entry *entries = NULL;
283         size_t num_entries = 0;
284         char *unix_path = NULL;
285
286         gpext_debug_header(0, "registry_process_group_policy", flags, gpo,
287                            extension_guid, snapin_guid);
288
289         status = gpo_get_unix_path(mem_ctx, cache_path(GPO_CACHE_DIR), gpo, &unix_path);
290         NT_STATUS_NOT_OK_RETURN(status);
291
292         status = reg_parse_registry(mem_ctx,
293                                     flags,
294                                     unix_path,
295                                     &entries,
296                                     &num_entries);
297         if (!NT_STATUS_IS_OK(status)) {
298                 DEBUG(0,("failed to parse registry: %s\n",
299                         nt_errstr(status)));
300                 return status;
301         }
302
303         dump_reg_entries(flags, "READ", entries, num_entries);
304
305         werr = reg_apply_registry(mem_ctx, token, root_key, flags,
306                                   entries, num_entries);
307         if (!W_ERROR_IS_OK(werr)) {
308                 DEBUG(0,("failed to apply registry: %s\n",
309                         win_errstr(werr)));
310                 return werror_to_ntstatus(werr);
311         }
312
313         return NT_STATUS_OK;
314 }
315
316 /****************************************************************
317 ****************************************************************/
318
319 static NTSTATUS registry_get_reg_config(TALLOC_CTX *mem_ctx,
320                                         struct gp_extension_reg_info **reg_info)
321 {
322         NTSTATUS status;
323         struct gp_extension_reg_info *info = NULL;
324         struct gp_extension_reg_table table[] = {
325                 { "ProcessGroupPolicy", REG_SZ, "registry_process_group_policy" },
326                 { NULL, REG_NONE, NULL }
327         };
328
329         info = talloc_zero(mem_ctx, struct gp_extension_reg_info);
330         NT_STATUS_HAVE_NO_MEMORY(info);
331
332         status = gp_ext_info_add_entry(mem_ctx, GP_EXT_NAME,
333                                        GP_EXT_GUID_REGISTRY,
334                                        table, info);
335         NT_STATUS_NOT_OK_RETURN(status);
336
337         *reg_info = info;
338
339         return NT_STATUS_OK;
340 }
341
342 /****************************************************************
343 ****************************************************************/
344
345 static NTSTATUS registry_initialize(TALLOC_CTX *mem_ctx)
346 {
347         return NT_STATUS_OK;
348 }
349
350 /****************************************************************
351 ****************************************************************/
352
353 static NTSTATUS registry_shutdown(void)
354 {
355         NTSTATUS status;
356
357         status = unregister_gp_extension(GP_EXT_NAME);
358         if (NT_STATUS_IS_OK(status)) {
359                 return status;
360         }
361
362         TALLOC_FREE(ctx);
363
364         return NT_STATUS_OK;
365 }
366
367 /****************************************************************
368 ****************************************************************/
369
370 static struct gp_extension_methods registry_methods = {
371         .initialize             = registry_initialize,
372         .process_group_policy   = registry_process_group_policy,
373         .get_reg_config         = registry_get_reg_config,
374         .shutdown               = registry_shutdown
375 };
376
377 /****************************************************************
378 ****************************************************************/
379
380 NTSTATUS gpext_registry_init(void)
381 {
382         NTSTATUS status;
383
384         ctx = talloc_init("gpext_registry_init");
385         NT_STATUS_HAVE_NO_MEMORY(ctx);
386
387         status = register_gp_extension(ctx, SMB_GPEXT_INTERFACE_VERSION,
388                                        GP_EXT_NAME, GP_EXT_GUID_REGISTRY,
389                                        &registry_methods);
390         if (!NT_STATUS_IS_OK(status)) {
391                 TALLOC_FREE(ctx);
392         }
393
394         return status;
395 }