?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fixed seg fault in registry frontend caused by trying to
[Samba.git] / source / rpcclient / cmd_reg.c
blobc089917f9b66d1f36b57a52f15fc2310322c007e
1 /*
2 Unix SMB/CIFS implementation.
3 NT Domain Authentication SMB / MSRPC client
4 Copyright (C) Andrew Tridgell 1994-1997
5 Copyright (C) Luke Kenneth Casson Leighton 1996-1997
6 Copyright (C) Simo Sorce 2001
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include "includes.h"
24 #include "rpcclient.h"
25
26 /*
27 * keys. of the form:
28 * ----
29 *
30 * [HKLM]|[HKU]\[parent_keyname_components]\[subkey]|[value]
31 *
32 * reg_getsubkey() splits this down into:
33 * [HKLM]|[HKU]\[parent_keyname_components] and [subkey]|[value]
34 *
35 * do_reg_connect() splits the left side down further into:
36 * [HKLM]|[HKU] and [parent_keyname_components].
37 *
38 * HKLM is short for HKEY_LOCAL_MACHINE
39 * HKU is short for HKEY_USERS
40 *
41 * oh, and HKEY stands for "Hive Key".
42 *
43 */
44
45 #if 0 /* Simo: reg functions need to be updated to the new cmd interface */
46
47 /****************************************************************************
48 nt registry enum
49 ****************************************************************************/
50 static void cmd_reg_enum(struct client_info *info)
51 {
52 BOOL res = True;
53 BOOL res1 = True;
54 BOOL res2 = True;
55 int i;
56
57 POLICY_HND key_pol;
58 fstring full_keyname;
59 fstring key_name;
60
61 /*
62 * query key info
63 */
64
65 fstring key_class;
66 uint32 max_class_len = 0;
67 uint32 num_subkeys;
68 uint32 max_subkeylen;
69 uint32 max_subkeysize;
70 uint32 num_values;
71 uint32 max_valnamelen;
72 uint32 max_valbufsize;
73 uint32 sec_desc;
74 NTTIME mod_time;
75
76 /*
77 * unknown 0x1a request
78 */
79
80 uint32 unk_1a_response;
81
82 DEBUG(5, ("cmd_reg_enum: smb_cli->fd:%d\n", smb_cli->fd));
83
84 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
85 {
86 fprintf(out_hnd, "regenum <key_name>\n");
87 return;
88 }
89
90 /* open WINREG session. */
91 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
92
93 /* open registry receive a policy handle */
94 res = res ? do_reg_connect(smb_cli, full_keyname, key_name,
95 &info->dom.reg_pol_connect) : False;
96
97 if ((*key_name) != 0)
98 {
99 /* open an entry */
100 res1 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
101 key_name, 0x02000000, &key_pol) : False;
102 }
103 else
104 {
105 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
106 }
107
108 res1 = res1 ? do_reg_query_key(smb_cli,
109 &key_pol,
110 key_class, &max_class_len,
111 &num_subkeys, &max_subkeylen, &max_subkeysize,
112 &num_values, &max_valnamelen, &max_valbufsize,
113 &sec_desc, &mod_time) : False;
114
115 if (res1 && num_subkeys > 0)
116 {
117 fprintf(out_hnd,"Subkeys\n");
118 fprintf(out_hnd,"-------\n");
119 }
120
121 for (i = 0; i < num_subkeys; i++)
122 {
123 /*
124 * enumerate key
125 */
126
127 fstring enum_name;
128 uint32 enum_unk1;
129 uint32 enum_unk2;
130 time_t key_mod_time;
131
132 /* unknown 1a it */
133 res2 = res1 ? do_reg_unknown_1a(smb_cli, &key_pol,
134 &unk_1a_response) : False;
135
136 if (res2 && unk_1a_response != 5)
137 {
138 fprintf(out_hnd,"Unknown 1a response: %x\n", unk_1a_response);
139 }
140
141 /* enum key */
142 res2 = res2 ? do_reg_enum_key(smb_cli, &key_pol,
143 i, enum_name,
144 &enum_unk1, &enum_unk2,
145 &key_mod_time) : False;
146
147 if (res2)
148 {
149 display_reg_key_info(out_hnd, ACTION_HEADER , enum_name, key_mod_time);
150 display_reg_key_info(out_hnd, ACTION_ENUMERATE, enum_name, key_mod_time);
151 display_reg_key_info(out_hnd, ACTION_FOOTER , enum_name, key_mod_time);
152 }
153
154 }
155
156 if (num_values > 0)
157 {
158 fprintf(out_hnd,"Key Values\n");
159 fprintf(out_hnd,"----------\n");
160 }
161
162 for (i = 0; i < num_values; i++)
163 {
164 /*
165 * enumerate key
166 */
167
168 uint32 val_type;
169 BUFFER2 value;
170 fstring val_name;
171
172 /* unknown 1a it */
173 res2 = res1 ? do_reg_unknown_1a(smb_cli, &key_pol,
174 &unk_1a_response) : False;
175
176 if (res2 && unk_1a_response != 5)
177 {
178 fprintf(out_hnd,"Unknown 1a response: %x\n", unk_1a_response);
179 }
180
181 /* enum key */
182 res2 = res2 ? do_reg_enum_val(smb_cli, &key_pol,
183 i, max_valnamelen, max_valbufsize,
184 val_name, &val_type, &value) : False;
185
186 if (res2)
187 {
188 display_reg_value_info(out_hnd, ACTION_HEADER , val_name, val_type, &value);
189 display_reg_value_info(out_hnd, ACTION_ENUMERATE, val_name, val_type, &value);
190 display_reg_value_info(out_hnd, ACTION_FOOTER , val_name, val_type, &value);
191 }
192 }
193
194 /* close the handles */
195 if ((*key_name) != 0)
196 {
197 res1 = res1 ? do_reg_close(smb_cli, &key_pol) : False;
198 }
199 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
200
201 /* close the session */
202 cli_nt_session_close(smb_cli);
203
204 if (res && res1 && res2)
205 {
206 DEBUG(5,("cmd_reg_enum: query succeeded\n"));
207 }
208 else
209 {
210 DEBUG(5,("cmd_reg_enum: query failed\n"));
211 }
212 }
213
214 /****************************************************************************
215 nt registry query key
216 ****************************************************************************/
217 static void cmd_reg_query_key(struct client_info *info)
218 {
219 BOOL res = True;
220 BOOL res1 = True;
221
222 POLICY_HND key_pol;
223 fstring full_keyname;
224 fstring key_name;
225
226 /*
227 * query key info
228 */
229
230 fstring key_class;
231 uint32 key_class_len = 0;
232 uint32 num_subkeys;
233 uint32 max_subkeylen;
234 uint32 max_subkeysize;
235 uint32 num_values;
236 uint32 max_valnamelen;
237 uint32 max_valbufsize;
238 uint32 sec_desc;
239 NTTIME mod_time;
240
241 DEBUG(5, ("cmd_reg_enum: smb_cli->fd:%d\n", smb_cli->fd));
242
243 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
244 {
245 fprintf(out_hnd, "regquery key_name\n");
246 return;
247 }
248
249 /* open WINREG session. */
250 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
251
252 /* open registry receive a policy handle */
253 res = res ? do_reg_connect(smb_cli, full_keyname, key_name,
254 &info->dom.reg_pol_connect) : False;
255
256 if ((*key_name) != 0)
257 {
258 /* open an entry */
259 res1 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
260 key_name, 0x02000000, &key_pol) : False;
261 }
262 else
263 {
264 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
265 }
266
267 res1 = res1 ? do_reg_query_key(smb_cli,
268 &key_pol,
269 key_class, &key_class_len,
270 &num_subkeys, &max_subkeylen, &max_subkeysize,
271 &num_values, &max_valnamelen, &max_valbufsize,
272 &sec_desc, &mod_time) : False;
273
274 if (res1 && key_class_len != 0)
275 {
276 res1 = res1 ? do_reg_query_key(smb_cli,
277 &key_pol,
278 key_class, &key_class_len,
279 &num_subkeys, &max_subkeylen, &max_subkeysize,
280 &num_values, &max_valnamelen, &max_valbufsize,
281 &sec_desc, &mod_time) : False;
282 }
283
284 if (res1)
285 {
286 fprintf(out_hnd,"Registry Query Info Key\n");
287 fprintf(out_hnd,"key class: %s\n", key_class);
288 fprintf(out_hnd,"subkeys, max_len, max_size: %d %d %d\n", num_subkeys, max_subkeylen, max_subkeysize);
289 fprintf(out_hnd,"vals, max_len, max_size: 0x%x 0x%x 0x%x\n", num_values, max_valnamelen, max_valbufsize);
290 fprintf(out_hnd,"sec desc: 0x%x\n", sec_desc);
291 fprintf(out_hnd,"mod time: %s\n", http_timestring(nt_time_to_unix(&mod_time)));
292 }
293
294 /* close the handles */
295 if ((*key_name) != 0)
296 {
297 res1 = res1 ? do_reg_close(smb_cli, &key_pol) : False;
298 }
299 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
300
301 /* close the session */
302 cli_nt_session_close(smb_cli);
303
304 if (res && res1)
305 {
306 DEBUG(5,("cmd_reg_query: query succeeded\n"));
307 }
308 else
309 {
310 DEBUG(5,("cmd_reg_query: query failed\n"));
311 }
312 }
313
314 /****************************************************************************
315 nt registry create value
316 ****************************************************************************/
317 static void cmd_reg_create_val(struct client_info *info)
318 {
319 BOOL res = True;
320 BOOL res3 = True;
321 BOOL res4 = True;
322
323 POLICY_HND parent_pol;
324 fstring full_keyname;
325 fstring keyname;
326 fstring parent_name;
327 fstring val_name;
328 fstring tmp;
329 uint32 val_type;
330 BUFFER3 value;
331
332 #if 0
333 uint32 unk_0;
334 uint32 unk_1;
335 /* query it */
336 res1 = res1 ? do_reg_query_info(smb_cli, &val_pol,
337 val_name, *val_type) : False;
338 #endif
339
340 DEBUG(5, ("cmd_reg_create_val: smb_cli->fd:%d\n", smb_cli->fd));
341
342 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
343 {
344 fprintf(out_hnd, "regcreate <val_name> <val_type> <val>\n");
345 return;
346 }
347
348 reg_get_subkey(full_keyname, keyname, val_name);
349
350 if (keyname[0] == 0 || val_name[0] == 0)
351 {
352 fprintf(out_hnd, "invalid key name\n");
353 return;
354 }
355
356 if (!next_token_nr(NULL, tmp, NULL, sizeof(tmp)))
357 {
358 fprintf(out_hnd, "regcreate <val_name> <val_type (1|4)> <val>\n");
359 return;
360 }
361
362 val_type = atoi(tmp);
363
364 if (val_type != 1 && val_type != 3 && val_type != 4)
365 {
366 fprintf(out_hnd, "val_type 1=UNISTR, 3=BYTES, 4=DWORD supported\n");
367 return;
368 }
369
370 if (!next_token_nr(NULL, tmp, NULL, sizeof(tmp)))
371 {
372 fprintf(out_hnd, "regcreate <val_name> <val_type (1|4)> <val>\n");
373 return;
374 }
375
376 switch (val_type)
377 {
378 case 0x01: /* UNISTR */
379 {
380 init_buffer3_str(&value, tmp, strlen(tmp)+1);
381 break;
382 }
383 case 0x03: /* BYTES */
384 {
385 init_buffer3_hex(&value, tmp);
386 break;
387 }
388 case 0x04: /* DWORD */
389 {
390 uint32 tmp_val;
391 if (strnequal(tmp, "0x", 2))
392 {
393 tmp_val = strtol(tmp, (char**)NULL, 16);
394 }
395 else
396 {
397 tmp_val = strtol(tmp, (char**)NULL, 10);
398 }
399 init_buffer3_uint32(&value, tmp_val);
400 break;
401 }
402 default:
403 {
404 fprintf(out_hnd, "i told you i only deal with UNISTR, DWORD and BYTES!\n");
405 return;
406 }
407 }
408
409 DEBUG(10,("key data:\n"));
410 dump_data(10, (char *)value.buffer, value.buf_len);
411
412 /* open WINREG session. */
413 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
414
415 /* open registry receive a policy handle */
416 res = res ? do_reg_connect(smb_cli, keyname, parent_name,
417 &info->dom.reg_pol_connect) : False;
418
419 if ((*val_name) != 0)
420 {
421 /* open an entry */
422 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
423 parent_name, 0x02000000, &parent_pol) : False;
424 }
425 else
426 {
427 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
428 }
429
430 /* create an entry */
431 res4 = res3 ? do_reg_create_val(smb_cli, &parent_pol,
432 val_name, val_type, &value) : False;
433
434 /* flush the modified key */
435 res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
436
437 /* close the val handle */
438 if ((*val_name) != 0)
439 {
440 res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
441 }
442
443 /* close the registry handles */
444 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
445
446 /* close the session */
447 cli_nt_session_close(smb_cli);
448
449 if (res && res3 && res4)
450 {
451 DEBUG(5,("cmd_reg_create_val: query succeeded\n"));
452 fprintf(out_hnd,"OK\n");
453 }
454 else
455 {
456 DEBUG(5,("cmd_reg_create_val: query failed\n"));
457 }
458 }
459
460 /****************************************************************************
461 nt registry delete value
462 ****************************************************************************/
463 static void cmd_reg_delete_val(struct client_info *info)
464 {
465 BOOL res = True;
466 BOOL res3 = True;
467 BOOL res4 = True;
468
469 POLICY_HND parent_pol;
470 fstring full_keyname;
471 fstring keyname;
472 fstring parent_name;
473 fstring val_name;
474
475 DEBUG(5, ("cmd_reg_delete_val: smb_cli->fd:%d\n", smb_cli->fd));
476
477 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
478 {
479 fprintf(out_hnd, "regdelete <val_name>\n");
480 return;
481 }
482
483 reg_get_subkey(full_keyname, keyname, val_name);
484
485 if (keyname[0] == 0 || val_name[0] == 0)
486 {
487 fprintf(out_hnd, "invalid key name\n");
488 return;
489 }
490
491 /* open WINREG session. */
492 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
493
494 /* open registry receive a policy handle */
495 res = res ? do_reg_connect(smb_cli, keyname, parent_name,
496 &info->dom.reg_pol_connect) : False;
497
498 if ((*val_name) != 0)
499 {
500 /* open an entry */
501 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
502 parent_name, 0x02000000, &parent_pol) : False;
503 }
504 else
505 {
506 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
507 }
508
509 /* delete an entry */
510 res4 = res3 ? do_reg_delete_val(smb_cli, &parent_pol, val_name) : False;
511
512 /* flush the modified key */
513 res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
514
515 /* close the key handle */
516 res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
517
518 /* close the registry handles */
519 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
520
521 /* close the session */
522 cli_nt_session_close(smb_cli);
523
524 if (res && res3 && res4)
525 {
526 DEBUG(5,("cmd_reg_delete_val: query succeeded\n"));
527 fprintf(out_hnd,"OK\n");
528 }
529 else
530 {
531 DEBUG(5,("cmd_reg_delete_val: query failed\n"));
532 }
533 }
534
535 /****************************************************************************
536 nt registry delete key
537 ****************************************************************************/
538 static void cmd_reg_delete_key(struct client_info *info)
539 {
540 BOOL res = True;
541 BOOL res3 = True;
542 BOOL res4 = True;
543
544 POLICY_HND parent_pol;
545 fstring full_keyname;
546 fstring parent_name;
547 fstring key_name;
548 fstring subkey_name;
549
550 DEBUG(5, ("cmd_reg_delete_key: smb_cli->fd:%d\n", smb_cli->fd));
551
552 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
553 {
554 fprintf(out_hnd, "regdeletekey <key_name>\n");
555 return;
556 }
557
558 reg_get_subkey(full_keyname, parent_name, subkey_name);
559
560 if (parent_name[0] == 0 || subkey_name[0] == 0)
561 {
562 fprintf(out_hnd, "invalid key name\n");
563 return;
564 }
565
566 /* open WINREG session. */
567 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
568
569 /* open registry receive a policy handle */
570 res = res ? do_reg_connect(smb_cli, parent_name, key_name,
571 &info->dom.reg_pol_connect) : False;
572
573 if ((*key_name) != 0)
574 {
575 /* open an entry */
576 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
577 key_name, 0x02000000, &parent_pol) : False;
578 }
579 else
580 {
581 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
582 }
583
584 /* create an entry */
585 res4 = res3 ? do_reg_delete_key(smb_cli, &parent_pol, subkey_name) : False;
586
587 /* flush the modified key */
588 res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
589
590 /* close the key handle */
591 if ((*key_name) != 0)
592 {
593 res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
594 }
595
596 /* close the registry handles */
597 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
598
599 /* close the session */
600 cli_nt_session_close(smb_cli);
601
602 if (res && res3 && res4)
603 {
604 DEBUG(5,("cmd_reg_delete_key: query succeeded\n"));
605 fprintf(out_hnd,"OK\n");
606 }
607 else
608 {
609 DEBUG(5,("cmd_reg_delete_key: query failed\n"));
610 }
611 }
612
613 /****************************************************************************
614 nt registry create key
615 ****************************************************************************/
616 static void cmd_reg_create_key(struct client_info *info)
617 {
618 BOOL res = True;
619 BOOL res3 = True;
620 BOOL res4 = True;
621
622 POLICY_HND parent_pol;
623 POLICY_HND key_pol;
624 fstring full_keyname;
625 fstring parent_key;
626 fstring parent_name;
627 fstring key_name;
628 fstring key_class;
629 SEC_ACCESS sam_access;
630
631 DEBUG(5, ("cmd_reg_create_key: smb_cli->fd:%d\n", smb_cli->fd));
632
633 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
634 {
635 fprintf(out_hnd, "regcreate <key_name> [key_class]\n");
636 return;
637 }
638
639 reg_get_subkey(full_keyname, parent_key, key_name);
640
641 if (parent_key[0] == 0 || key_name[0] == 0)
642 {
643 fprintf(out_hnd, "invalid key name\n");
644 return;
645 }
646
647 if (!next_token_nr(NULL, key_class, NULL, sizeof(key_class)))
648 {
649 memset(key_class, 0, sizeof(key_class));
650 }
651
652 /* set access permissions */
653 sam_access.mask = SEC_RIGHTS_READ;
654
655 /* open WINREG session. */
656 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
657
658 /* open registry receive a policy handle */
659 res = res ? do_reg_connect(smb_cli, parent_key, parent_name,
660 &info->dom.reg_pol_connect) : False;
661
662 if ((*parent_name) != 0)
663 {
664 /* open an entry */
665 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
666 parent_name, 0x02000000, &parent_pol) : False;
667 }
668 else
669 {
670 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
671 }
672
673 /* create an entry */
674 res4 = res3 ? do_reg_create_key(smb_cli, &parent_pol,
675 key_name, key_class, &sam_access, &key_pol) : False;
676
677 /* flush the modified key */
678 res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
679
680 /* close the key handle */
681 res4 = res4 ? do_reg_close(smb_cli, &key_pol) : False;
682
683 /* close the key handle */
684 if ((*parent_name) != 0)
685 {
686 res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
687 }
688
689 /* close the registry handles */
690 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
691
692 /* close the session */
693 cli_nt_session_close(smb_cli);
694
695 if (res && res3 && res4)
696 {
697 DEBUG(5,("cmd_reg_create_key: query succeeded\n"));
698 fprintf(out_hnd,"OK\n");
699 }
700 else
701 {
702 DEBUG(5,("cmd_reg_create_key: query failed\n"));
703 }
704 }
705
706 /****************************************************************************
707 nt registry security info
708 ****************************************************************************/
709 static void cmd_reg_test_key_sec(struct client_info *info)
710 {
711 BOOL res = True;
712 BOOL res3 = True;
713 BOOL res4 = True;
714
715 POLICY_HND key_pol;
716 fstring full_keyname;
717 fstring key_name;
718
719 /*
720 * security info
721 */
722
723 uint32 sec_buf_size;
724 SEC_DESC_BUF *psdb;
725
726 DEBUG(5, ("cmd_reg_get_key_sec: smb_cli->fd:%d\n", smb_cli->fd));
727
728 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
729 {
730 fprintf(out_hnd, "reggetsec <key_name>\n");
731 return;
732 }
733
734 /* open WINREG session. */
735 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
736
737 /* open registry receive a policy handle */
738 res = res ? do_reg_connect(smb_cli, full_keyname, key_name,
739 &info->dom.reg_pol_connect) : False;
740
741 if ((*key_name) != 0)
742 {
743 /* open an entry */
744 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
745 key_name, 0x02000000, &key_pol) : False;
746 }
747 else
748 {
749 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
750 }
751
752 /* open an entry */
753 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
754 key_name, 0x02000000, &key_pol) : False;
755
756 /* query key sec info. first call sets sec_buf_size. */
757
758 sec_buf_size = 0;
759 res4 = res3 ? do_reg_get_key_sec(smb_cli, &key_pol,
760 &sec_buf_size, &psdb) : False;
761
762 free_sec_desc_buf(&psdb);
763
764 res4 = res4 ? do_reg_get_key_sec(smb_cli, &key_pol,
765 &sec_buf_size, &psdb) : False;
766
767 if (res4 && psdb->len > 0 && psdb->sec != NULL)
768 {
769 display_sec_desc(out_hnd, ACTION_HEADER , psdb->sec);
770 display_sec_desc(out_hnd, ACTION_ENUMERATE, psdb->sec);
771 display_sec_desc(out_hnd, ACTION_FOOTER , psdb->sec);
772
773 res4 = res4 ? do_reg_set_key_sec(smb_cli, &key_pol, psdb) : False;
774 }
775
776 free_sec_desc_buf(&psdb);
777
778 /* close the key handle */
779 if ((*key_name) != 0)
780 {
781 res3 = res3 ? do_reg_close(smb_cli, &key_pol) : False;
782 }
783
784 /* close the registry handles */
785 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
786
787 /* close the session */
788 cli_nt_session_close(smb_cli);
789
790 if (res && res3 && res4)
791 {
792 DEBUG(5,("cmd_reg_test2: query succeeded\n"));
793 fprintf(out_hnd,"Registry Test2\n");
794 }
795 else
796 {
797 DEBUG(5,("cmd_reg_test2: query failed\n"));
798 }
799 }
800
801 /****************************************************************************
802 nt registry security info
803 ****************************************************************************/
804 static void cmd_reg_get_key_sec(struct client_info *info)
805 {
806 BOOL res = True;
807 BOOL res3 = True;
808 BOOL res4 = True;
809
810 POLICY_HND key_pol;
811 fstring full_keyname;
812 fstring key_name;
813
814 /*
815 * security info
816 */
817
818 uint32 sec_buf_size;
819 SEC_DESC_BUF *psdb;
820
821 DEBUG(5, ("cmd_reg_get_key_sec: smb_cli->fd:%d\n", smb_cli->fd));
822
823 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
824 {
825 fprintf(out_hnd, "reggetsec <key_name>\n");
826 return;
827 }
828
829 /* open WINREG session. */
830 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
831
832 /* open registry receive a policy handle */
833 res = res ? do_reg_connect(smb_cli, full_keyname, key_name,
834 &info->dom.reg_pol_connect) : False;
835
836 if ((*key_name) != 0)
837 {
838 /* open an entry */
839 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
840 key_name, 0x02000000, &key_pol) : False;
841 }
842 else
843 {
844 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
845 }
846
847 /* open an entry */
848 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
849 key_name, 0x02000000, &key_pol) : False;
850
851 /* Get the size. */
852 sec_buf_size = 0;
853 res4 = res3 ? do_reg_get_key_sec(smb_cli, &key_pol,
854 &sec_buf_size, &psdb) : False;
855
856 free_sec_desc_buf(&psdb);
857
858 res4 = res4 ? do_reg_get_key_sec(smb_cli, &key_pol,
859 &sec_buf_size, &psdb) : False;
860
861 if (res4 && psdb->len > 0 && psdb->sec != NULL)
862 {
863 display_sec_desc(out_hnd, ACTION_HEADER , psdb->sec);
864 display_sec_desc(out_hnd, ACTION_ENUMERATE, psdb->sec);
865 display_sec_desc(out_hnd, ACTION_FOOTER , psdb->sec);
866 }
867
868 free_sec_desc_buf(&psdb);
869
870 /* close the key handle */
871 if ((*key_name) != 0)
872 {
873 res3 = res3 ? do_reg_close(smb_cli, &key_pol) : False;
874 }
875
876 /* close the registry handles */
877 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
878
879 /* close the session */
880 cli_nt_session_close(smb_cli);
881
882 if (res && res3 && res4)
883 {
884 DEBUG(5,("cmd_reg_get_key_sec: query succeeded\n"));
885 }
886 else
887 {
888 DEBUG(5,("cmd_reg_get_key_sec: query failed\n"));
889 }
890 }
891
892 #endif /* 0 */
893
894 /****************************************************************************
895 nt registry shutdown
896 ****************************************************************************/
897 static NTSTATUS cmd_reg_shutdown(struct cli_state *cli, TALLOC_CTX *mem_ctx,
898 int argc, char **argv)
899 {
900 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
901 fstring msg;
902 uint32 timeout = 20;
903 uint16 flgs = 0;
904 int opt;
905
906 *msg = 0;
907 optind = 0; /* TODO: test if this hack works on other systems too --simo */
908
909 while ((opt = getopt(argc, argv, "m:t:rf")) != EOF)
910 {
911 fprintf (stderr, "[%s]\n", argv[argc-1]);
912
913 switch (opt)
914 {
915 case 'm':
916 {
917 safe_strcpy(msg, optarg, sizeof(msg)-1);
918 fprintf (stderr, "[%s|%s]\n", optarg, msg);
919 break;
920 }
921 case 't':
922 {
923 timeout = atoi(optarg);
924 fprintf (stderr, "[%s|%d]\n", optarg, timeout);
925 break;
926 }
927 case 'r':
928 {
929 flgs |= 0x100;
930 break;
931 }
932 case 'f':
933 {
934 flgs |= 0x001;
935 break;
936 }
937 }
938 }
939
940 /* create an entry */
941 result = cli_reg_shutdown(cli, mem_ctx, msg, timeout, flgs);
942
943 if (NT_STATUS_IS_OK(result))
944 DEBUG(5,("cmd_reg_shutdown: query succeeded\n"));
945 else
946 DEBUG(5,("cmd_reg_shutdown: query failed\n"));
947
948 return result;
949 }
950
951 /****************************************************************************
952 abort a shutdown
953 ****************************************************************************/
954 static NTSTATUS cmd_reg_abort_shutdown(struct cli_state *cli,
955 TALLOC_CTX *mem_ctx, int argc,
956 char **argv)
957 {
958 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
959
960 result = cli_reg_abort_shutdown(cli, mem_ctx);
961
962 if (NT_STATUS_IS_OK(result))
963 DEBUG(5,("cmd_reg_abort_shutdown: query succeeded\n"));
964 else
965 DEBUG(5,("cmd_reg_abort_shutdown: query failed\n"));
966
967 return result;
968 }
969
970
971 /* List of commands exported by this module */
972 struct cmd_set reg_commands[] = {
973
974 { "REG" },
975
976 { "shutdown", cmd_reg_shutdown, PIPE_WINREG, "Remote Shutdown",
977 "[-m message] [-t timeout] [-r] [-f] (-r == reboot, -f == force)" },
978
979 { "abortshutdown", cmd_reg_abort_shutdown, PIPE_WINREG, "Abort Shutdown",
980 "" },
981 /*
982 { "regenum", cmd_reg_enum, "Registry Enumeration",
983 "<keyname>" },
984
985 { "regdeletekey", cmd_reg_delete_key, "Registry Key Delete",
986 "<keyname>" },
987
988 { "regcreatekey", cmd_reg_create_key, "Registry Key Create",
989 "<keyname> [keyclass]" },
990
991 { "regqueryval", cmd_reg_query_info, "Registry Value Query",
992 "<valname>" },
993
994 { "regquerykey", cmd_reg_query_key, "Registry Key Query",
995 "<keyname>" },
996
997 { "regdeleteval", cmd_reg_delete_val, "Registry Value Delete",
998 "<valname>" },
999
1000 { "regcreateval", cmd_reg_create_val, "Registry Key Create",
1001 "<valname> <valtype> <value>" },
1002
1003 { "reggetsec", cmd_reg_get_key_sec, "Registry Key Security",
1004 "<keyname>" },
1005
1006 { "regtestsec", cmd_reg_test_key_sec, "Test Registry Key Security",
1007 "<keyname>" },
1008 */
1009 { NULL }
1010 };
Samba GIT mirror