?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
preparing for release of alpha.1.4
[Samba.git] / source / rpcclient / cmd_reg.c
blob559f6b9d894e1a641ebceac67e8669082cb5fbfe
1 /*
2 Unix SMB/Netbios implementation.
3 Version 1.9.
4 NT Domain Authentication SMB / MSRPC client
5 Copyright (C) Andrew Tridgell 1994-1999
6 Copyright (C) Luke Kenneth Casson Leighton 1996-1999
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
24
25 #ifdef SYSLOG
26 #undef SYSLOG
27 #endif
28
29 #include "includes.h"
30 #include "rpc_parse.h"
31
32 extern int DEBUGLEVEL;
33
34 extern FILE* out_hnd;
35
36 /*
37 * keys. of the form:
38 * ----
39 *
40 * [HKLM]|[HKU]|[HKCR]\[parent_keyname]\[subkey]|[value]
41 *
42 * reg_getsubkey() splits this down into:
43 * [HKLM]|[HKU]|[HKCR]\[parent_keyname_components] and [subkey]|[value]
44 *
45 * reg_connect() splits the left side down further into:
46 * [HKLM]|[HKU]|[HKCR] and [parent_keyname_components].
47 *
48 * HKLM is short for HKEY_LOCAL_MACHINE
49 * HKCR is short for HKEY_CLASSES_ROOT
50 * HKU is short for HKEY_USERS
51 *
52 * oh, and HKEY stands for "Hive Key".
53 *
54 */
55
56 static void reg_display_key(int val, const char *full_keyname, int num)
57 {
58 switch (val)
59 {
60 case 0:
61 {
62 /* initialsation */
63 report(out_hnd, "Key Name:\t%s\n", full_keyname);
64 break;
65 }
66 case 1:
67 {
68 /* subkeys initialisation */
69 if (num > 0)
70 {
71 report(out_hnd,"Subkeys\n");
72 report(out_hnd,"-------\n");
73 }
74 break;
75 }
76 case 2:
77 {
78 /* values initialisation */
79 if (num > 0)
80 {
81 report(out_hnd,"Key Values\n");
82 report(out_hnd,"----------\n");
83 }
84 break;
85 }
86 case 3:
87 {
88 /* clean-up */
89 break;
90 }
91 default:
92 {
93 break;
94 }
95 }
96 }
97
98 void split_server_keyname(char *srv_name, char *key, const char* arg)
99 {
100 pstrcpy(key, arg);
101
102 if (strnequal("\\\\", key, 2))
103 {
104 char *p = strchr(&key[2], '\\');
105 if (p == NULL)
106 {
107 key[0] = 0;
108 return;
109 }
110
111 *p = 0;
112
113 fstrcpy(srv_name, key);
114 pstrcpy(key, &arg[strlen(srv_name)+1]);
115 }
116 }
117
118 /****************************************************************************
119 nt registry enum
120 ****************************************************************************/
121 BOOL msrpc_reg_enum_key(const char* srv_name, const char* full_keyname,
122 REG_FN(reg_fn),
123 REG_KEY_FN(reg_key_fn),
124 REG_VAL_FN(reg_val_fn))
125 {
126 BOOL res = True;
127 BOOL res1 = True;
128 BOOL res2 = True;
129 int i;
130
131 POLICY_HND key_pol;
132 POLICY_HND pol_con;
133 fstring key_name;
134
135 /*
136 * query key info
137 */
138
139 fstring key_class;
140 uint32 max_class_len = 0;
141 uint32 num_subkeys;
142 uint32 max_subkeylen;
143 uint32 max_subkeysize;
144 uint32 num_values;
145 uint32 max_valnamelen;
146 uint32 max_valbufsize;
147 uint32 sec_desc;
148 NTTIME mod_time;
149
150 /*
151 * unknown 0x1a request
152 */
153
154 uint32 unk_1a_response;
155
156 DEBUG(5, ("reg_enum_key: %s\n", full_keyname));
157
158 /* open registry receive a policy handle */
159 res = res ? reg_connect(srv_name, full_keyname, key_name, 0x02000000,
160 &pol_con) : False;
161
162 if ((*key_name) != 0)
163 {
164 /* open an entry */
165 res1 = res ? reg_open_entry(&pol_con,
166 key_name, 0x02000000, &key_pol) : False;
167 }
168 else
169 {
170 memcpy(&key_pol, &pol_con, sizeof(key_pol));
171 }
172
173 res1 = res1 ? reg_query_key(&key_pol,
174 key_class, &max_class_len,
175 &num_subkeys, &max_subkeylen, &max_subkeysize,
176 &num_values, &max_valnamelen, &max_valbufsize,
177 &sec_desc, &mod_time) : False;
178
179 if (res1 && reg_fn != NULL)
180 {
181 reg_fn(0, full_keyname, 0);
182 reg_fn(1, full_keyname, num_subkeys);
183 }
184
185 for (i = 0; i < num_subkeys && reg_key_fn != NULL; i++)
186 {
187 /*
188 * enumerate key
189 */
190
191 fstring enum_name;
192 uint32 enum_unk1;
193 uint32 enum_unk2;
194 time_t key_mod_time;
195
196 /* unknown 1a it */
197 res2 = res1 ? reg_unknown_1a(&key_pol,
198 &unk_1a_response) : False;
199
200 if (res2 && unk_1a_response != 5)
201 {
202 report(out_hnd,"Unknown 1a response: %x\n", unk_1a_response);
203 }
204
205 /* enum key */
206 res2 = res2 ? reg_enum_key(&key_pol,
207 i, enum_name,
208 &enum_unk1, &enum_unk2,
209 &key_mod_time) : False;
210
211 if (res2)
212 {
213 reg_key_fn(full_keyname, enum_name, key_mod_time);
214 }
215
216 }
217
218 if (reg_fn != NULL)
219 {
220 reg_fn(2, full_keyname, num_values);
221 }
222
223 for (i = 0; i < num_values && reg_val_fn != NULL; i++)
224 {
225 /*
226 * enumerate key
227 */
228
229 uint32 val_type;
230 BUFFER2 value;
231 fstring val_name;
232
233 /* unknown 1a it */
234 res2 = res1 ? reg_unknown_1a(&key_pol,
235 &unk_1a_response) : False;
236
237 if (res2 && unk_1a_response != 5)
238 {
239 report(out_hnd,"Unknown 1a response: %x\n", unk_1a_response);
240 }
241
242 /* enum key */
243 res2 = res2 ? reg_enum_val(&key_pol,
244 i, max_valnamelen, max_valbufsize,
245 val_name, &val_type, &value) : False;
246
247 if (res2)
248 {
249 reg_val_fn(full_keyname, val_name, val_type, &value);
250 }
251 }
252
253 if (res1 && reg_fn != NULL)
254 {
255 reg_fn(3, full_keyname, 0);
256 }
257
258 /* close the handles */
259 if ((*key_name) != 0)
260 {
261 res1 = res1 ? reg_close(&key_pol) : False;
262 }
263 res = res ? reg_close(&pol_con) : False;
264
265 if (res && res1 && res2)
266 {
267 DEBUG(5,("msrpc_reg_enum_key: query succeeded\n"));
268 }
269 else
270 {
271 DEBUG(5,("msrpc_reg_enum_key: query failed\n"));
272 }
273
274 return res1;
275 }
276
277 static void reg_display_key_info(const char *full_name,
278 const char *name, time_t key_mod_time)
279 {
280 display_reg_key_info(out_hnd, ACTION_HEADER , name, key_mod_time);
281 display_reg_key_info(out_hnd, ACTION_ENUMERATE, name, key_mod_time);
282 display_reg_key_info(out_hnd, ACTION_FOOTER , name, key_mod_time);
283 }
284
285 static void reg_display_val_info(const char *full_name,
286 const char* name,
287 uint32 type,
288 const BUFFER2 *const value)
289 {
290 display_reg_value_info(out_hnd, ACTION_HEADER , name, type, value);
291 display_reg_value_info(out_hnd, ACTION_ENUMERATE, name, type, value);
292 display_reg_value_info(out_hnd, ACTION_FOOTER , name, type, value);
293 }
294
295 /****************************************************************************
296 nt registry enum
297 ****************************************************************************/
298 void cmd_reg_enum(struct client_info *info, int argc, char *argv[])
299 {
300 pstring full_keyname;
301
302 fstring srv_name;
303
304 fstrcpy(srv_name, "\\\\");
305 fstrcat(srv_name, info->dest_host);
306 strupper(srv_name);
307
308 if (argc < 2)
309 {
310 report(out_hnd, "regenum <key_name>\n");
311 return;
312 }
313
314 split_server_keyname(srv_name, full_keyname, argv[1]);
315
316 (void)(msrpc_reg_enum_key(srv_name, full_keyname,
317 reg_display_key,
318 reg_display_key_info,
319 reg_display_val_info));
320 }
321
322 /****************************************************************************
323 nt registry query value info
324 ****************************************************************************/
325 void cmd_reg_query_info(struct client_info *info, int argc, char *argv[])
326 {
327 BOOL res = True;
328 BOOL res1 = True;
329 BOOL res2 = True;
330
331 POLICY_HND key_pol;
332 POLICY_HND pol_con;
333 pstring full_keyname;
334 fstring key_name;
335 fstring keyname;
336 fstring val_name;
337
338 /*
339 * query value info
340 */
341
342 BUFFER2 buf;
343 uint32 type;
344
345 fstring srv_name;
346
347 fstrcpy(srv_name, "\\\\");
348 fstrcat(srv_name, info->dest_host);
349 strupper(srv_name);
350
351 if (argc < 2)
352 {
353 report(out_hnd, "regvalinfo value_name\n");
354 return;
355 }
356
357 split_server_keyname(srv_name, full_keyname, argv[1]);
358
359 reg_get_subkey(full_keyname, keyname, val_name);
360
361 if (keyname[0] == 0 || val_name[0] == 0)
362 {
363 report(out_hnd, "invalid value name\n");
364 return;
365 }
366
367 /* open registry receive a policy handle */
368 res = res ? reg_connect(srv_name, keyname, key_name, 0x02000000,
369 &pol_con) : False;
370
371 if ((*key_name) != 0)
372 {
373 /* open an entry */
374 res1 = res ? reg_open_entry(&pol_con,
375 key_name, 0x02000000, &key_pol) : False;
376 }
377 else
378 {
379 memcpy(&key_pol, &pol_con, sizeof(key_pol));
380 }
381
382 /* query it */
383 res2 = res1 ? reg_query_info(&key_pol,
384 val_name, &type, &buf) : False;
385
386 if (res2)
387 {
388 reg_display_val_info(full_keyname, val_name, type, &buf);
389 }
390
391 /* close the handles */
392 if ((*key_name) != 0)
393 {
394 res1 = res1 ? reg_close(&key_pol) : False;
395 }
396 res = res ? reg_close(&pol_con) : False;
397
398 if (res2)
399 {
400 DEBUG(5,("cmd_reg_query: query succeeded\n"));
401 }
402 else
403 {
404 DEBUG(5,("cmd_reg_query: query failed\n"));
405 }
406 }
407
408 /****************************************************************************
409 nt registry query key
410 ****************************************************************************/
411 void cmd_reg_query_key(struct client_info *info, int argc, char *argv[])
412 {
413 BOOL res = True;
414 BOOL res1 = True;
415
416 POLICY_HND key_pol;
417 POLICY_HND pol_con;
418 pstring full_keyname;
419 fstring key_name;
420
421 /*
422 * query key info
423 */
424
425 fstring key_class;
426 uint32 key_class_len = 0;
427 uint32 num_subkeys;
428 uint32 max_subkeylen;
429 uint32 max_subkeysize;
430 uint32 num_values;
431 uint32 max_valnamelen;
432 uint32 max_valbufsize;
433 uint32 sec_desc;
434 NTTIME mod_time;
435
436 fstring srv_name;
437
438 fstrcpy(srv_name, "\\\\");
439 fstrcat(srv_name, info->dest_host);
440 strupper(srv_name);
441
442 if (argc < 2)
443 {
444 report(out_hnd, "regquery key_name\n");
445 return;
446 }
447
448 split_server_keyname(srv_name, full_keyname, argv[1]);
449
450 /* open registry receive a policy handle */
451 res = res ? reg_connect(srv_name, full_keyname, key_name, 0x02000000,
452 &pol_con) : False;
453
454 if ((*key_name) != 0)
455 {
456 /* open an entry */
457 res1 = res ? reg_open_entry(&pol_con,
458 key_name, 0x02000000, &key_pol) : False;
459 }
460 else
461 {
462 memcpy(&key_pol, &pol_con, sizeof(key_pol));
463 }
464
465 res1 = res1 ? reg_query_key(&key_pol,
466 key_class, &key_class_len,
467 &num_subkeys, &max_subkeylen, &max_subkeysize,
468 &num_values, &max_valnamelen, &max_valbufsize,
469 &sec_desc, &mod_time) : False;
470
471 if (res1 && key_class_len != 0)
472 {
473 res1 = res1 ? reg_query_key(&key_pol,
474 key_class, &key_class_len,
475 &num_subkeys, &max_subkeylen, &max_subkeysize,
476 &num_values, &max_valnamelen, &max_valbufsize,
477 &sec_desc, &mod_time) : False;
478 }
479
480 if (res1)
481 {
482 report(out_hnd,"Registry Query Info Key\n");
483 report(out_hnd,"key class: %s\n", key_class);
484 report(out_hnd,"subkeys, max_len, max_size: %d %d %d\n", num_subkeys, max_subkeylen, max_subkeysize);
485 report(out_hnd,"vals, max_len, max_size: 0x%x 0x%x 0x%x\n", num_values, max_valnamelen, max_valbufsize);
486 report(out_hnd,"sec desc: 0x%x\n", sec_desc);
487 report(out_hnd,"mod time: %s\n", http_timestring(nt_time_to_unix(&mod_time)));
488 }
489
490 /* close the handles */
491 if ((*key_name) != 0)
492 {
493 res1 = res1 ? reg_close(&key_pol) : False;
494 }
495 res = res ? reg_close(&pol_con) : False;
496
497 if (res && res1)
498 {
499 DEBUG(5,("cmd_reg_query: query succeeded\n"));
500 }
501 else
502 {
503 DEBUG(5,("cmd_reg_query: query failed\n"));
504 }
505 }
506
507 /****************************************************************************
508 nt registry create value
509 ****************************************************************************/
510 void cmd_reg_create_val(struct client_info *info, int argc, char *argv[])
511 {
512 BOOL res = True;
513 BOOL res3 = True;
514 BOOL res4 = True;
515
516 POLICY_HND parent_pol;
517 POLICY_HND pol_con;
518 pstring full_keyname;
519 fstring keyname;
520 fstring parent_name;
521 fstring val_name;
522 uint32 val_type;
523 BUFFER3 value;
524
525 #if 0
526 uint32 unk_0;
527 uint32 unk_1;
528 /* query it */
529 res1 = res1 ? reg_query_info(&val_pol,
530 type, &unk_0, &unk_1) : False;
531 #endif
532
533 fstring srv_name;
534
535 fstrcpy(srv_name, "\\\\");
536 fstrcat(srv_name, info->dest_host);
537 strupper(srv_name);
538
539 if (argc < 4)
540 {
541 report(out_hnd, "regcreate <val_name> <val_type (1|3|4)> <val>\n");
542 report(out_hnd, "(val_type 1=UNISTR, 3=BYTES, 4=DWORD supported\n");
543 return;
544 }
545
546 split_server_keyname(srv_name, full_keyname, argv[1]);
547
548 reg_get_subkey(full_keyname, keyname, val_name);
549
550 argc--;
551 argv++;
552
553 if (keyname[0] == 0 || val_name[0] == 0)
554 {
555 report(out_hnd, "invalid key name\n");
556 return;
557 }
558
559 if (argc < 2)
560 {
561 return;
562 }
563
564 argc--;
565 argv++;
566
567 val_type = atoi(argv[0]);
568
569 if (val_type != 1 && val_type != 3 && val_type != 4)
570 {
571 report(out_hnd, "val_type 1=UNISTR, 3=BYTES, 4=DWORD supported\n");
572 return;
573 }
574
575 argc--;
576 argv++;
577
578 switch (val_type)
579 {
580 case 0x01: /* UNISTR */
581 {
582 make_buffer3_str(&value, argv[0], strlen(argv[0])+1);
583 break;
584 }
585 case 0x03: /* BYTES */
586 {
587 make_buffer3_hex(&value, argv[0]);
588 break;
589 }
590 case 0x04: /* DWORD */
591 {
592 make_buffer3_uint32(&value, get_number(argv[0]));
593 break;
594 }
595 default:
596 {
597 report(out_hnd, "i told you i only deal with UNISTR, DWORD and BYTES!\n");
598 return;
599 }
600 }
601
602 DEBUG(10,("key data:\n"));
603 dump_data(10, (char *)value.buffer, value.buf_len);
604
605 /* open registry receive a policy handle */
606 res = res ? reg_connect(srv_name, keyname, parent_name, 0x02000000,
607 &pol_con) : False;
608
609 if ((*val_name) != 0)
610 {
611 /* open an entry */
612 res3 = res ? reg_open_entry(&pol_con,
613 parent_name, 0x02000000, &parent_pol) : False;
614 }
615 else
616 {
617 memcpy(&parent_pol, &pol_con, sizeof(parent_pol));
618 }
619
620 /* create an entry */
621 res4 = res3 ? reg_create_val(&parent_pol,
622 val_name, val_type, &value) : False;
623
624 /* flush the modified key */
625 res4 = res4 ? reg_flush_key(&parent_pol) : False;
626
627 /* close the val handle */
628 if ((*val_name) != 0)
629 {
630 res3 = res3 ? reg_close(&parent_pol) : False;
631 }
632
633 /* close the registry handles */
634 res = res ? reg_close(&pol_con) : False;
635
636 if (res && res3 && res4)
637 {
638 DEBUG(5,("cmd_reg_create_val: query succeeded\n"));
639 report(out_hnd,"OK\n");
640 }
641 else
642 {
643 DEBUG(5,("cmd_reg_create_val: query failed\n"));
644 }
645 }
646
647 /****************************************************************************
648 nt registry delete value
649 ****************************************************************************/
650 void cmd_reg_delete_val(struct client_info *info, int argc, char *argv[])
651 {
652 BOOL res = True;
653 BOOL res3 = True;
654 BOOL res4 = True;
655
656 POLICY_HND parent_pol;
657 POLICY_HND pol_con;
658 pstring full_keyname;
659 fstring keyname;
660 fstring parent_name;
661 fstring val_name;
662
663 fstring srv_name;
664
665 fstrcpy(srv_name, "\\\\");
666 fstrcat(srv_name, info->dest_host);
667 strupper(srv_name);
668
669 if (argc < 2)
670 {
671 report(out_hnd, "regdelete <val_name>\n");
672 return;
673 }
674
675 split_server_keyname(srv_name, full_keyname, argv[1]);
676
677 reg_get_subkey(full_keyname, keyname, val_name);
678
679 if (keyname[0] == 0 || val_name[0] == 0)
680 {
681 report(out_hnd, "invalid key name\n");
682 return;
683 }
684
685 /* open registry receive a policy handle */
686 res = res ? reg_connect(srv_name, keyname, parent_name, 0x02000000,
687 &pol_con) : False;
688
689 if ((*val_name) != 0)
690 {
691 /* open an entry */
692 res3 = res ? reg_open_entry(&pol_con,
693 parent_name, 0x02000000, &parent_pol) : False;
694 }
695 else
696 {
697 memcpy(&parent_pol, &pol_con, sizeof(parent_pol));
698 }
699
700 /* delete an entry */
701 res4 = res3 ? reg_delete_val(&parent_pol, val_name) : False;
702
703 /* flush the modified key */
704 res4 = res4 ? reg_flush_key(&parent_pol) : False;
705
706 /* close the key handle */
707 res3 = res3 ? reg_close(&parent_pol) : False;
708
709 /* close the registry handles */
710 res = res ? reg_close(&pol_con) : False;
711
712 if (res && res3 && res4)
713 {
714 DEBUG(5,("cmd_reg_delete_val: query succeeded\n"));
715 report(out_hnd,"OK\n");
716 }
717 else
718 {
719 DEBUG(5,("cmd_reg_delete_val: query failed\n"));
720 }
721 }
722
723 /****************************************************************************
724 nt registry delete key
725 ****************************************************************************/
726 void cmd_reg_delete_key(struct client_info *info, int argc, char *argv[])
727 {
728 BOOL res = True;
729 BOOL res3 = True;
730 BOOL res4 = True;
731
732 POLICY_HND parent_pol;
733 POLICY_HND pol_con;
734 pstring full_keyname;
735 fstring parent_name;
736 fstring key_name;
737 fstring subkey_name;
738
739 fstring srv_name;
740
741 fstrcpy(srv_name, "\\\\");
742 fstrcat(srv_name, info->dest_host);
743 strupper(srv_name);
744
745 if (argc < 2)
746 {
747 report(out_hnd, "regdeletekey <key_name>\n");
748 return;
749 }
750
751 split_server_keyname(srv_name, full_keyname, argv[1]);
752
753 reg_get_subkey(full_keyname, parent_name, subkey_name);
754
755 if (parent_name[0] == 0 || subkey_name[0] == 0)
756 {
757 report(out_hnd, "invalid key name\n");
758 return;
759 }
760
761 /* open registry receive a policy handle */
762 res = res ? reg_connect(srv_name, parent_name, key_name, 0x02000000,
763 &pol_con) : False;
764
765 if ((*key_name) != 0)
766 {
767 /* open an entry */
768 res3 = res ? reg_open_entry(&pol_con,
769 key_name, 0x02000000, &parent_pol) : False;
770 }
771 else
772 {
773 memcpy(&parent_pol, &pol_con, sizeof(parent_pol));
774 }
775
776 /* create an entry */
777 res4 = res3 ? reg_delete_key(&parent_pol, subkey_name) : False;
778
779 /* flush the modified key */
780 res4 = res4 ? reg_flush_key(&parent_pol) : False;
781
782 /* close the key handle */
783 if ((*key_name) != 0)
784 {
785 res3 = res3 ? reg_close(&parent_pol) : False;
786 }
787
788 /* close the registry handles */
789 res = res ? reg_close(&pol_con) : False;
790
791 if (res && res3 && res4)
792 {
793 DEBUG(5,("cmd_reg_delete_key: query succeeded\n"));
794 report(out_hnd,"OK\n");
795 }
796 else
797 {
798 DEBUG(5,("cmd_reg_delete_key: query failed\n"));
799 }
800 }
801
802 /****************************************************************************
803 nt registry create key
804 ****************************************************************************/
805 void cmd_reg_create_key(struct client_info *info, int argc, char *argv[])
806 {
807 BOOL res = True;
808 BOOL res3 = True;
809 BOOL res4 = True;
810
811 POLICY_HND parent_pol;
812 POLICY_HND key_pol;
813 POLICY_HND pol_con;
814 pstring full_keyname;
815 fstring parent_key;
816 fstring parent_name;
817 fstring key_name;
818 fstring key_class;
819 SEC_ACCESS sam_access;
820
821 fstring srv_name;
822
823 fstrcpy(srv_name, "\\\\");
824 fstrcat(srv_name, info->dest_host);
825 strupper(srv_name);
826
827 if (argc < 2)
828 {
829 report(out_hnd, "regcreate <key_name> [key_class]\n");
830 return;
831 }
832
833 split_server_keyname(srv_name, full_keyname, argv[1]);
834
835 reg_get_subkey(full_keyname, parent_key, key_name);
836
837 if (parent_key[0] == 0 || key_name[0] == 0)
838 {
839 report(out_hnd, "invalid key name\n");
840 return;
841 }
842
843 if (argc > 2)
844 {
845 fstrcpy(key_class, argv[2]);
846 }
847 else
848 {
849 memset(key_class, 0, sizeof(key_class));
850 }
851
852 /* set access permissions */
853 sam_access.mask = SEC_RIGHTS_READ;
854
855 /* open registry receive a policy handle */
856 res = res ? reg_connect(srv_name, parent_key, parent_name, 0x02000000,
857 &pol_con) : False;
858
859 if ((*parent_name) != 0)
860 {
861 /* open an entry */
862 res3 = res ? reg_open_entry(&pol_con,
863 parent_name, 0x02000000, &parent_pol) : False;
864 }
865 else
866 {
867 memcpy(&parent_pol, &pol_con, sizeof(parent_pol));
868 }
869
870 /* create an entry */
871 res4 = res3 ? reg_create_key(&parent_pol,
872 key_name, key_class, &sam_access, &key_pol) : False;
873
874 /* flush the modified key */
875 res4 = res4 ? reg_flush_key(&parent_pol) : False;
876
877 /* close the key handle */
878 res4 = res4 ? reg_close(&key_pol) : False;
879
880 /* close the key handle */
881 if ((*parent_name) != 0)
882 {
883 res3 = res3 ? reg_close(&parent_pol) : False;
884 }
885
886 /* close the registry handles */
887 res = res ? reg_close(&pol_con) : False;
888
889 if (res && res3 && res4)
890 {
891 DEBUG(5,("cmd_reg_create_key: query succeeded\n"));
892 report(out_hnd,"OK\n");
893 }
894 else
895 {
896 DEBUG(5,("cmd_reg_create_key: query failed\n"));
897 }
898 }
899
900 /****************************************************************************
901 nt registry security info
902 ****************************************************************************/
903 void cmd_reg_test_key_sec(struct client_info *info, int argc, char *argv[])
904 {
905 BOOL res = True;
906 BOOL res3 = True;
907 BOOL res4 = True;
908
909 POLICY_HND key_pol;
910 POLICY_HND pol_con;
911 pstring full_keyname;
912 fstring key_name;
913
914 /*
915 * security info
916 */
917
918 uint32 sec_buf_size;
919 SEC_DESC_BUF sec_buf;
920 uint32 sec_info = 0x7;
921
922 fstring srv_name;
923
924 fstrcpy(srv_name, "\\\\");
925 fstrcat(srv_name, info->dest_host);
926 strupper(srv_name);
927
928 if (argc < 2)
929 {
930 report(out_hnd, "regtestkeysec <key_name>\n");
931 return;
932 }
933
934 split_server_keyname(srv_name, full_keyname, argv[1]);
935
936 /* open registry receive a policy handle */
937 res = res ? reg_connect(srv_name, full_keyname, key_name, 0x02000000,
938 &pol_con) : False;
939
940 if ((*key_name) != 0)
941 {
942 /* open an entry */
943 res3 = res ? reg_open_entry(&pol_con,
944 key_name, 0x02000000, &key_pol) : False;
945 }
946 else
947 {
948 memcpy(&key_pol, &pol_con, sizeof(key_pol));
949 }
950
951 /* open an entry */
952 res3 = res ? reg_open_entry(&pol_con,
953 key_name, 0x02000000, &key_pol) : False;
954
955 /* query key sec info. first call sets sec_buf_size. */
956 sec_buf_size = 0;
957 ZERO_STRUCT(sec_buf);
958
959 res4 = res3 ? reg_get_key_sec(&key_pol,
960 sec_info,
961 &sec_buf_size, &sec_buf) : False;
962
963 if (res4)
964 {
965 free_sec_desc_buf(&sec_buf);
966 }
967
968 res4 = res4 ? reg_get_key_sec(&key_pol,
969 sec_info,
970 &sec_buf_size, &sec_buf) : False;
971
972 if (res4 && sec_buf.len > 0 && sec_buf.sec != NULL)
973 {
974 display_sec_desc(out_hnd, ACTION_HEADER , sec_buf.sec);
975 display_sec_desc(out_hnd, ACTION_ENUMERATE, sec_buf.sec);
976 display_sec_desc(out_hnd, ACTION_FOOTER , sec_buf.sec);
977
978 res4 = res4 ? reg_set_key_sec(&key_pol,
979 sec_info, sec_buf_size, sec_buf.sec) : False;
980
981 free_sec_desc_buf(&sec_buf);
982 }
983
984 /* close the key handle */
985 if ((*key_name) != 0)
986 {
987 res3 = res3 ? reg_close(&key_pol) : False;
988 }
989
990 /* close the registry handles */
991 res = res ? reg_close(&pol_con) : False;
992
993 if (res && res3 && res4)
994 {
995 DEBUG(5,("cmd_reg_test2: query succeeded\n"));
996 report(out_hnd,"Registry Test2\n");
997 }
998 else
999 {
1000 DEBUG(5,("cmd_reg_test2: query failed\n"));
1001 }
1002 }
1003
1004 /****************************************************************************
1005 nt registry security info
1006 ****************************************************************************/
1007 void cmd_reg_get_key_sec(struct client_info *info, int argc, char *argv[])
1008 {
1009 BOOL res = True;
1010 BOOL res3 = True;
1011 BOOL res4 = True;
1012
1013 POLICY_HND key_pol;
1014 POLICY_HND pol_con;
1015 pstring full_keyname;
1016 fstring key_name;
1017
1018 /*
1019 * security info
1020 */
1021
1022 uint32 sec_buf_size;
1023 SEC_DESC_BUF sec_buf;
1024 uint32 sec_info = 0x7;
1025
1026 fstring srv_name;
1027
1028 fstrcpy(srv_name, "\\\\");
1029 fstrcat(srv_name, info->dest_host);
1030 strupper(srv_name);
1031
1032 if (argc < 2)
1033 {
1034 report(out_hnd, "reggetsec <key_name>\n");
1035 return;
1036 }
1037
1038 split_server_keyname(srv_name, full_keyname, argv[1]);
1039
1040 /* open registry receive a policy handle */
1041 res = res ? reg_connect(srv_name, full_keyname, key_name, 0x02000000,
1042 &pol_con) : False;
1043
1044 if ((*key_name) != 0)
1045 {
1046 /* open an entry */
1047 res3 = res ? reg_open_entry(&pol_con,
1048 key_name, 0x02000000, &key_pol) : False;
1049 }
1050 else
1051 {
1052 memcpy(&key_pol, &pol_con, sizeof(key_pol));
1053 }
1054
1055 /* open an entry */
1056 res3 = res ? reg_open_entry(&pol_con,
1057 key_name, 0x02000000, &key_pol) : False;
1058
1059 /* query key sec info. first call sets sec_buf_size. */
1060 sec_buf_size = 0;
1061 ZERO_STRUCT(sec_buf);
1062
1063 res4 = res3 ? reg_get_key_sec(&key_pol,
1064 sec_info,
1065 &sec_buf_size, &sec_buf) : False;
1066
1067 if (res4)
1068 {
1069 free_sec_desc_buf(&sec_buf);
1070 }
1071
1072 res4 = res4 ? reg_get_key_sec(&key_pol,
1073 sec_info,
1074 &sec_buf_size, &sec_buf) : False;
1075
1076 if (res4 && sec_buf.len > 0 && sec_buf.sec != NULL)
1077 {
1078 display_sec_desc(out_hnd, ACTION_HEADER , sec_buf.sec);
1079 display_sec_desc(out_hnd, ACTION_ENUMERATE, sec_buf.sec);
1080 display_sec_desc(out_hnd, ACTION_FOOTER , sec_buf.sec);
1081
1082 free(sec_buf.sec);
1083 }
1084
1085 /* close the key handle */
1086 if ((*key_name) != 0)
1087 {
1088 res3 = res3 ? reg_close(&key_pol) : False;
1089 }
1090
1091 /* close the registry handles */
1092 res = res ? reg_close(&pol_con) : False;
1093
1094 if (res && res3 && res4)
1095 {
1096 DEBUG(5,("cmd_reg_get_key_sec: query succeeded\n"));
1097 }
1098 else
1099 {
1100 DEBUG(5,("cmd_reg_get_key_sec: query failed\n"));
1101 }
1102 }
1103
1104 /****************************************************************************
1105 nt registry shutdown
1106 ****************************************************************************/
1107 void cmd_reg_shutdown(struct client_info *info, int argc, char *argv[])
1108 {
1109 BOOL res = True;
1110
1111 fstring msg;
1112 uint32 timeout = 20;
1113 uint16 flgs = 0;
1114 int opt;
1115
1116 fstring srv_name;
1117
1118 fstrcpy(srv_name, "\\\\");
1119 fstrcat(srv_name, info->dest_host);
1120 strupper(srv_name);
1121
1122 while ((opt = getopt(argc, argv,"fim:t:r-")) != EOF)
1123 {
1124 switch (opt)
1125 {
1126 case 'm':
1127 {
1128 safe_strcpy(msg, optarg, sizeof(msg)-1);
1129 break;
1130 }
1131 case 't':
1132 {
1133 timeout = atoi(optarg);
1134 break;
1135 }
1136 case 'r':
1137 {
1138 flgs |= 0x100;
1139 break;
1140 }
1141 case 'f':
1142 {
1143 flgs |= 0x001;
1144 break;
1145 }
1146 case '-':
1147 {
1148 if (strequal(optarg, "-reboot"))
1149 {
1150 flgs |= 0x100;
1151 }
1152 if (strequal(optarg, "-force-close"))
1153 {
1154 flgs |= 0x001;
1155 }
1156 break;
1157 }
1158 }
1159 }
1160
1161 /* create an entry */
1162 res = res ? reg_shutdown(srv_name, msg, timeout, flgs) : False;
1163
1164 if (res)
1165 {
1166 DEBUG(5,("cmd_reg_shutdown: query succeeded\n"));
1167 report(out_hnd,"OK\n");
1168 }
1169 else
1170 {
1171 DEBUG(5,("cmd_reg_shutdown: query failed\n"));
1172 report(out_hnd,"Failed\n");
1173 }
1174 }
Samba GIT mirror