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