source: trunk/server/source3/libgpo/gpext/scripts.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 12.2 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 * Group Policy Support
4 * Copyright (C) Guenther Deschner 2007
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 "registry/reg_api.h"
26#include "../libcli/registry/util_reg.h"
27
28#define GP_EXT_NAME "scripts"
29
30#define KEY_GP_SCRIPTS "Software\\Policies\\Microsoft\\Windows\\System\\Scripts"
31
32#define GP_SCRIPTS_INI "Scripts/scripts.ini"
33
34#define GP_SCRIPTS_INI_STARTUP "Startup"
35#define GP_SCRIPTS_INI_SHUTDOWN "Shutdown"
36#define GP_SCRIPTS_INI_LOGON "Logon"
37#define GP_SCRIPTS_INI_LOGOFF "Logoff"
38
39#define GP_SCRIPTS_SECTION_CMDLINE "cmdline"
40#define GP_SCRIPTS_SECTION_PARAMETERS "parameters"
41
42#define GP_SCRIPTS_REG_VAL_SCRIPT "Script"
43#define GP_SCRIPTS_REG_VAL_PARAMETERS "Parameters"
44#define GP_SCRIPTS_REG_VAL_EXECTIME "ExecTime"
45
46static TALLOC_CTX *ctx = NULL;
47
48/****************************************************************
49****************************************************************/
50
51static NTSTATUS scripts_get_reg_config(TALLOC_CTX *mem_ctx,
52 struct gp_extension_reg_info **reg_info)
53{
54 NTSTATUS status;
55 struct gp_extension_reg_info *info = NULL;
56
57 struct gp_extension_reg_table table[] = {
58 { "ProcessGroupPolicy", REG_SZ, "scripts_process_group_policy" },
59 { "NoGPOListChanges", REG_DWORD, "1" },
60 { "NoSlowLink", REG_DWORD, "1" },
61 { "NotifyLinkTransition", REG_DWORD, "1" },
62 { NULL, REG_NONE, NULL },
63 };
64
65 info = TALLOC_ZERO_P(mem_ctx, struct gp_extension_reg_info);
66 NT_STATUS_HAVE_NO_MEMORY(info);
67
68 status = gp_ext_info_add_entry(mem_ctx, GP_EXT_NAME,
69 GP_EXT_GUID_SCRIPTS,
70 table, info);
71 NT_STATUS_NOT_OK_RETURN(status);
72
73 *reg_info = info;
74
75 return NT_STATUS_OK;
76}
77
78/****************************************************************
79****************************************************************/
80
81static NTSTATUS generate_gp_registry_entry(TALLOC_CTX *mem_ctx,
82 const char *key,
83 const char *value,
84 uint32_t data_type,
85 const void *data_p,
86 enum gp_reg_action action,
87 struct gp_registry_entry **entry_out)
88{
89 struct gp_registry_entry *entry = NULL;
90 struct registry_value *data = NULL;
91
92 entry = TALLOC_ZERO_P(mem_ctx, struct gp_registry_entry);
93 NT_STATUS_HAVE_NO_MEMORY(entry);
94
95 data = TALLOC_ZERO_P(mem_ctx, struct registry_value);
96 NT_STATUS_HAVE_NO_MEMORY(data);
97
98 data->type = data_type;
99 switch (data->type) {
100 case REG_QWORD:
101 data->data = data_blob_talloc(mem_ctx, NULL, 8);
102 SBVAL(data->data.data, 0, *(uint64_t *)data_p);
103 break;
104 case REG_SZ:
105 if (!push_reg_sz(mem_ctx, &data->data, (char *)data_p)) {
106 return NT_STATUS_NO_MEMORY;
107 }
108 break;
109 default:
110 return NT_STATUS_NOT_SUPPORTED;
111 }
112
113 entry->key = key;
114 entry->data = data;
115 entry->action = action;
116 entry->value = talloc_strdup(mem_ctx, value);
117 NT_STATUS_HAVE_NO_MEMORY(entry->value);
118
119 *entry_out = entry;
120
121 return NT_STATUS_OK;
122}
123
124/****************************************************************
125****************************************************************/
126
127static NTSTATUS scripts_parse_ini_section(struct gp_inifile_context *ini_ctx,
128 uint32_t flags,
129 const char *section,
130 struct gp_registry_entry **entries,
131 size_t *num_entries)
132{
133 NTSTATUS status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
134 NTSTATUS result;
135 int i = 0;
136
137 while (1) {
138
139 const char *key = NULL;
140 char *script = NULL;
141 const char *count = NULL;
142 char *parameters = NULL;
143
144 count = talloc_asprintf(ini_ctx->mem_ctx, "%d", i);
145 NT_STATUS_HAVE_NO_MEMORY(count);
146
147 key = talloc_asprintf(ini_ctx->mem_ctx, "%s:%s%s",
148 section, count,
149 GP_SCRIPTS_SECTION_CMDLINE);
150 NT_STATUS_HAVE_NO_MEMORY(key);
151
152 result = gp_inifile_getstring(ini_ctx, key, &script);
153 if (!NT_STATUS_IS_OK(result)) {
154 break;
155 }
156
157 key = talloc_asprintf(ini_ctx->mem_ctx, "%s:%s%s",
158 section, count,
159 GP_SCRIPTS_SECTION_PARAMETERS);
160 NT_STATUS_HAVE_NO_MEMORY(key);
161
162 result = gp_inifile_getstring(ini_ctx, key, &parameters);
163 if (!NT_STATUS_IS_OK(result)) {
164 break;
165 }
166
167 {
168 struct gp_registry_entry *entry = NULL;
169 status = generate_gp_registry_entry(ini_ctx->mem_ctx,
170 count,
171 GP_SCRIPTS_REG_VAL_SCRIPT,
172 REG_SZ,
173 script,
174 GP_REG_ACTION_ADD_VALUE,
175 &entry);
176 NT_STATUS_NOT_OK_RETURN(status);
177 if (!add_gp_registry_entry_to_array(ini_ctx->mem_ctx,
178 entry,
179 entries,
180 num_entries)) {
181 return NT_STATUS_NO_MEMORY;
182 }
183 }
184 {
185 struct gp_registry_entry *entry = NULL;
186 status = generate_gp_registry_entry(ini_ctx->mem_ctx,
187 count,
188 GP_SCRIPTS_REG_VAL_PARAMETERS,
189 REG_SZ,
190 parameters,
191 GP_REG_ACTION_ADD_VALUE,
192 &entry);
193 NT_STATUS_NOT_OK_RETURN(status);
194 if (!add_gp_registry_entry_to_array(ini_ctx->mem_ctx,
195 entry,
196 entries,
197 num_entries)) {
198 return NT_STATUS_NO_MEMORY;
199 }
200 }
201 {
202 struct gp_registry_entry *entry = NULL;
203 status = generate_gp_registry_entry(ini_ctx->mem_ctx,
204 count,
205 GP_SCRIPTS_REG_VAL_EXECTIME,
206 REG_QWORD,
207 0,
208 GP_REG_ACTION_ADD_VALUE,
209 &entry);
210 NT_STATUS_NOT_OK_RETURN(status);
211 if (!add_gp_registry_entry_to_array(ini_ctx->mem_ctx,
212 entry,
213 entries,
214 num_entries)) {
215 return NT_STATUS_NO_MEMORY;
216 }
217 }
218 status = NT_STATUS_OK;
219 i++;
220 }
221
222 return status;
223}
224
225/****************************************************************
226****************************************************************/
227
228static WERROR scripts_store_reg_gpovals(TALLOC_CTX *mem_ctx,
229 struct registry_key *key,
230 struct GROUP_POLICY_OBJECT *gpo)
231{
232 WERROR werr;
233
234 if (!key || !gpo) {
235 return WERR_INVALID_PARAM;
236 }
237
238 werr = gp_store_reg_val_sz(mem_ctx, key, "DisplayName",
239 gpo->display_name);
240 W_ERROR_NOT_OK_RETURN(werr);
241
242 werr = gp_store_reg_val_sz(mem_ctx, key, "FileSysPath",
243 gpo->file_sys_path);
244 W_ERROR_NOT_OK_RETURN(werr);
245
246 werr = gp_store_reg_val_sz(mem_ctx, key, "GPO-ID",
247 gpo->ds_path);
248 W_ERROR_NOT_OK_RETURN(werr);
249
250 werr = gp_store_reg_val_sz(mem_ctx, key, "GPOName",
251 gpo->name);
252 W_ERROR_NOT_OK_RETURN(werr);
253
254 werr = gp_store_reg_val_sz(mem_ctx, key, "SOM-ID",
255 gpo->link);
256 W_ERROR_NOT_OK_RETURN(werr);
257
258 return werr;
259}
260
261/****************************************************************
262****************************************************************/
263
264static WERROR scripts_apply(TALLOC_CTX *mem_ctx,
265 const struct security_token *token,
266 struct registry_key *root_key,
267 uint32_t flags,
268 const char *section,
269 struct GROUP_POLICY_OBJECT *gpo,
270 struct gp_registry_entry *entries,
271 size_t num_entries)
272{
273 struct gp_registry_context *reg_ctx = NULL;
274 WERROR werr;
275 size_t i;
276 const char *keystr = NULL;
277 int count = 0;
278
279 if (num_entries == 0) {
280 return WERR_OK;
281 }
282
283#if 0
284 if (flags & GPO_INFO_FLAG_MACHINE) {
285 struct security_token *tmp_token;
286
287 tmp_token = registry_create_system_token(mem_ctx);
288 W_ERROR_HAVE_NO_MEMORY(tmp_token);
289
290 werr = gp_init_reg_ctx(mem_ctx, KEY_HKLM, REG_KEY_WRITE,
291 tmp_token,
292 &reg_ctx);
293 } else {
294 werr = gp_init_reg_ctx(mem_ctx, KEY_HKCU, REG_KEY_WRITE,
295 token,
296 &reg_ctx);
297 }
298 W_ERROR_NOT_OK_RETURN(werr);
299#endif
300
301 keystr = talloc_asprintf(mem_ctx, "%s\\%s\\%d", KEY_GP_SCRIPTS,
302 section, count++);
303 W_ERROR_HAVE_NO_MEMORY(keystr);
304
305 reg_deletekey_recursive(root_key, keystr);
306
307 werr = gp_store_reg_subkey(mem_ctx, keystr,
308 root_key, &root_key);
309 if (!W_ERROR_IS_OK(werr)) {
310 goto done;
311 }
312
313 werr = scripts_store_reg_gpovals(mem_ctx, root_key, gpo);
314 if (!W_ERROR_IS_OK(werr)) {
315 goto done;
316 }
317
318 for (i=0; i<num_entries; i++) {
319
320 werr = reg_apply_registry_entry(mem_ctx, root_key, reg_ctx,
321 &(entries)[i],
322 token, flags);
323 if (!W_ERROR_IS_OK(werr)) {
324 DEBUG(0,("failed to apply registry: %s\n",
325 win_errstr(werr)));
326 goto done;
327 }
328 }
329
330 done:
331 gp_free_reg_ctx(reg_ctx);
332 return werr;
333}
334
335/****************************************************************
336****************************************************************/
337
338static NTSTATUS scripts_process_group_policy(ADS_STRUCT *ads,
339 TALLOC_CTX *mem_ctx,
340 uint32_t flags,
341 struct registry_key *root_key,
342 const struct security_token *token,
343 struct GROUP_POLICY_OBJECT *gpo,
344 const char *extension_guid,
345 const char *snapin_guid)
346{
347 NTSTATUS status;
348 WERROR werr;
349 int i = 0;
350 char *unix_path = NULL;
351 struct gp_inifile_context *ini_ctx = NULL;
352 struct gp_registry_entry *entries = NULL;
353 size_t num_entries = 0;
354 const char *list[] = {
355 GP_SCRIPTS_INI_STARTUP,
356 GP_SCRIPTS_INI_SHUTDOWN,
357 GP_SCRIPTS_INI_LOGON,
358 GP_SCRIPTS_INI_LOGOFF
359 };
360
361 debug_gpext_header(0, "scripts_process_group_policy", flags, gpo,
362 extension_guid, snapin_guid);
363
364 status = gpo_get_unix_path(mem_ctx, cache_path(GPO_CACHE_DIR), gpo, &unix_path);
365 NT_STATUS_NOT_OK_RETURN(status);
366
367 status = gp_inifile_init_context(mem_ctx, flags, unix_path,
368 GP_SCRIPTS_INI, &ini_ctx);
369 NT_STATUS_NOT_OK_RETURN(status);
370
371 for (i = 0; i < ARRAY_SIZE(list); i++) {
372
373 TALLOC_FREE(entries);
374 num_entries = 0;
375
376 status = scripts_parse_ini_section(ini_ctx, flags, list[i],
377 &entries, &num_entries);
378 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
379 continue;
380 }
381
382 if (!NT_STATUS_IS_OK(status)) {
383 return status;
384 }
385
386 dump_reg_entries(flags, "READ", entries, num_entries);
387
388 werr = scripts_apply(ini_ctx->mem_ctx, token, root_key,
389 flags, list[i], gpo, entries, num_entries);
390 if (!W_ERROR_IS_OK(werr)) {
391 continue; /* FIXME: finally fix storing emtpy strings and REG_QWORD! */
392 TALLOC_FREE(ini_ctx);
393 return werror_to_ntstatus(werr);
394 }
395 }
396
397 TALLOC_FREE(ini_ctx);
398 return NT_STATUS_OK;
399}
400
401/****************************************************************
402****************************************************************/
403
404static NTSTATUS scripts_initialize(TALLOC_CTX *mem_ctx)
405{
406 return NT_STATUS_OK;
407}
408
409/****************************************************************
410****************************************************************/
411
412static NTSTATUS scripts_shutdown(void)
413{
414 NTSTATUS status;
415
416 status = unregister_gp_extension(GP_EXT_NAME);
417 if (NT_STATUS_IS_OK(status)) {
418 return status;
419 }
420
421 TALLOC_FREE(ctx);
422
423 return NT_STATUS_OK;
424}
425
426/****************************************************************
427****************************************************************/
428
429static struct gp_extension_methods scripts_methods = {
430 .initialize = scripts_initialize,
431 .process_group_policy = scripts_process_group_policy,
432 .get_reg_config = scripts_get_reg_config,
433 .shutdown = scripts_shutdown
434};
435
436/****************************************************************
437****************************************************************/
438
439NTSTATUS gpext_scripts_init(void)
440{
441 NTSTATUS status;
442
443 ctx = talloc_init("gpext_scripts_init");
444 NT_STATUS_HAVE_NO_MEMORY(ctx);
445
446 status = register_gp_extension(ctx, SMB_GPEXT_INTERFACE_VERSION,
447 GP_EXT_NAME, GP_EXT_GUID_SCRIPTS,
448 &scripts_methods);
449 if (!NT_STATUS_IS_OK(status)) {
450 TALLOC_FREE(ctx);
451 }
452
453 return status;
454}
Note: See TracBrowser for help on using the repository browser.