2 Unix SMB/Netbios implementation.
4 NT Domain Authentication SMB / MSRPC client
5 Copyright (C) Andrew Tridgell 1994-1997
6 Copyright (C) Luke Kenneth Casson Leighton 1996-1997
7 Copyright (C) Simo Sorce 2001
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include "rpcclient.h"
31 * [HKLM]|[HKU]\[parent_keyname_components]\[subkey]|[value]
33 * reg_getsubkey() splits this down into:
34 * [HKLM]|[HKU]\[parent_keyname_components] and [subkey]|[value]
36 * do_reg_connect() splits the left side down further into:
37 * [HKLM]|[HKU] and [parent_keyname_components].
39 * HKLM is short for HKEY_LOCAL_MACHINE
40 * HKU is short for HKEY_USERS
42 * oh, and HKEY stands for "Hive Key".
46 #if 0 /* Simo: reg functions need to be updated to the new cmd interface */
48 /****************************************************************************
50 ****************************************************************************/
51 static void cmd_reg_enum(struct client_info *info)
67 uint32 max_class_len = 0;
70 uint32 max_subkeysize;
72 uint32 max_valnamelen;
73 uint32 max_valbufsize;
78 * unknown 0x1a request
81 uint32 unk_1a_response;
83 DEBUG(5, ("cmd_reg_enum: smb_cli->fd:%d\n", smb_cli->fd));
85 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
87 fprintf(out_hnd, "regenum <key_name>\n");
91 /* open WINREG session. */
92 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
94 /* open registry receive a policy handle */
95 res = res ? do_reg_connect(smb_cli, full_keyname, key_name,
96 &info->dom.reg_pol_connect) : False;
101 res1 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
102 key_name, 0x02000000, &key_pol) : False;
106 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
109 res1 = res1 ? do_reg_query_key(smb_cli,
111 key_class, &max_class_len,
112 &num_subkeys, &max_subkeylen, &max_subkeysize,
113 &num_values, &max_valnamelen, &max_valbufsize,
114 &sec_desc, &mod_time) : False;
116 if (res1 && num_subkeys > 0)
118 fprintf(out_hnd,"Subkeys\n");
119 fprintf(out_hnd,"-------\n");
122 for (i = 0; i < num_subkeys; i++)
134 res2 = res1 ? do_reg_unknown_1a(smb_cli, &key_pol,
135 &unk_1a_response) : False;
137 if (res2 && unk_1a_response != 5)
139 fprintf(out_hnd,"Unknown 1a response: %x\n", unk_1a_response);
143 res2 = res2 ? do_reg_enum_key(smb_cli, &key_pol,
145 &enum_unk1, &enum_unk2,
146 &key_mod_time) : False;
150 display_reg_key_info(out_hnd, ACTION_HEADER , enum_name, key_mod_time);
151 display_reg_key_info(out_hnd, ACTION_ENUMERATE, enum_name, key_mod_time);
152 display_reg_key_info(out_hnd, ACTION_FOOTER , enum_name, key_mod_time);
159 fprintf(out_hnd,"Key Values\n");
160 fprintf(out_hnd,"----------\n");
163 for (i = 0; i < num_values; i++)
174 res2 = res1 ? do_reg_unknown_1a(smb_cli, &key_pol,
175 &unk_1a_response) : False;
177 if (res2 && unk_1a_response != 5)
179 fprintf(out_hnd,"Unknown 1a response: %x\n", unk_1a_response);
183 res2 = res2 ? do_reg_enum_val(smb_cli, &key_pol,
184 i, max_valnamelen, max_valbufsize,
185 val_name, &val_type, &value) : False;
189 display_reg_value_info(out_hnd, ACTION_HEADER , val_name, val_type, &value);
190 display_reg_value_info(out_hnd, ACTION_ENUMERATE, val_name, val_type, &value);
191 display_reg_value_info(out_hnd, ACTION_FOOTER , val_name, val_type, &value);
195 /* close the handles */
196 if ((*key_name) != 0)
198 res1 = res1 ? do_reg_close(smb_cli, &key_pol) : False;
200 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
202 /* close the session */
203 cli_nt_session_close(smb_cli);
205 if (res && res1 && res2)
207 DEBUG(5,("cmd_reg_enum: query succeeded\n"));
211 DEBUG(5,("cmd_reg_enum: query failed\n"));
215 /****************************************************************************
216 nt registry query key
217 ****************************************************************************/
218 static void cmd_reg_query_key(struct client_info *info)
224 fstring full_keyname;
232 uint32 key_class_len = 0;
234 uint32 max_subkeylen;
235 uint32 max_subkeysize;
237 uint32 max_valnamelen;
238 uint32 max_valbufsize;
242 DEBUG(5, ("cmd_reg_enum: smb_cli->fd:%d\n", smb_cli->fd));
244 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
246 fprintf(out_hnd, "regquery key_name\n");
250 /* open WINREG session. */
251 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
253 /* open registry receive a policy handle */
254 res = res ? do_reg_connect(smb_cli, full_keyname, key_name,
255 &info->dom.reg_pol_connect) : False;
257 if ((*key_name) != 0)
260 res1 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
261 key_name, 0x02000000, &key_pol) : False;
265 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
268 res1 = res1 ? do_reg_query_key(smb_cli,
270 key_class, &key_class_len,
271 &num_subkeys, &max_subkeylen, &max_subkeysize,
272 &num_values, &max_valnamelen, &max_valbufsize,
273 &sec_desc, &mod_time) : False;
275 if (res1 && key_class_len != 0)
277 res1 = res1 ? do_reg_query_key(smb_cli,
279 key_class, &key_class_len,
280 &num_subkeys, &max_subkeylen, &max_subkeysize,
281 &num_values, &max_valnamelen, &max_valbufsize,
282 &sec_desc, &mod_time) : False;
287 fprintf(out_hnd,"Registry Query Info Key\n");
288 fprintf(out_hnd,"key class: %s\n", key_class);
289 fprintf(out_hnd,"subkeys, max_len, max_size: %d %d %d\n", num_subkeys, max_subkeylen, max_subkeysize);
290 fprintf(out_hnd,"vals, max_len, max_size: 0x%x 0x%x 0x%x\n", num_values, max_valnamelen, max_valbufsize);
291 fprintf(out_hnd,"sec desc: 0x%x\n", sec_desc);
292 fprintf(out_hnd,"mod time: %s\n", http_timestring(nt_time_to_unix(&mod_time)));
295 /* close the handles */
296 if ((*key_name) != 0)
298 res1 = res1 ? do_reg_close(smb_cli, &key_pol) : False;
300 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
302 /* close the session */
303 cli_nt_session_close(smb_cli);
307 DEBUG(5,("cmd_reg_query: query succeeded\n"));
311 DEBUG(5,("cmd_reg_query: query failed\n"));
315 /****************************************************************************
316 nt registry create value
317 ****************************************************************************/
318 static void cmd_reg_create_val(struct client_info *info)
324 POLICY_HND parent_pol;
325 fstring full_keyname;
337 res1 = res1 ? do_reg_query_info(smb_cli, &val_pol,
338 val_name, *val_type) : False;
341 DEBUG(5, ("cmd_reg_create_val: smb_cli->fd:%d\n", smb_cli->fd));
343 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
345 fprintf(out_hnd, "regcreate <val_name> <val_type> <val>\n");
349 reg_get_subkey(full_keyname, keyname, val_name);
351 if (keyname[0] == 0 || val_name[0] == 0)
353 fprintf(out_hnd, "invalid key name\n");
357 if (!next_token_nr(NULL, tmp, NULL, sizeof(tmp)))
359 fprintf(out_hnd, "regcreate <val_name> <val_type (1|4)> <val>\n");
363 val_type = atoi(tmp);
365 if (val_type != 1 && val_type != 3 && val_type != 4)
367 fprintf(out_hnd, "val_type 1=UNISTR, 3=BYTES, 4=DWORD supported\n");
371 if (!next_token_nr(NULL, tmp, NULL, sizeof(tmp)))
373 fprintf(out_hnd, "regcreate <val_name> <val_type (1|4)> <val>\n");
379 case 0x01: /* UNISTR */
381 init_buffer3_str(&value, tmp, strlen(tmp)+1);
384 case 0x03: /* BYTES */
386 init_buffer3_hex(&value, tmp);
389 case 0x04: /* DWORD */
392 if (strnequal(tmp, "0x", 2))
394 tmp_val = strtol(tmp, (char**)NULL, 16);
398 tmp_val = strtol(tmp, (char**)NULL, 10);
400 init_buffer3_uint32(&value, tmp_val);
405 fprintf(out_hnd, "i told you i only deal with UNISTR, DWORD and BYTES!\n");
410 DEBUG(10,("key data:\n"));
411 dump_data(10, (char *)value.buffer, value.buf_len);
413 /* open WINREG session. */
414 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
416 /* open registry receive a policy handle */
417 res = res ? do_reg_connect(smb_cli, keyname, parent_name,
418 &info->dom.reg_pol_connect) : False;
420 if ((*val_name) != 0)
423 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
424 parent_name, 0x02000000, &parent_pol) : False;
428 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
431 /* create an entry */
432 res4 = res3 ? do_reg_create_val(smb_cli, &parent_pol,
433 val_name, val_type, &value) : False;
435 /* flush the modified key */
436 res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
438 /* close the val handle */
439 if ((*val_name) != 0)
441 res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
444 /* close the registry handles */
445 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
447 /* close the session */
448 cli_nt_session_close(smb_cli);
450 if (res && res3 && res4)
452 DEBUG(5,("cmd_reg_create_val: query succeeded\n"));
453 fprintf(out_hnd,"OK\n");
457 DEBUG(5,("cmd_reg_create_val: query failed\n"));
461 /****************************************************************************
462 nt registry delete value
463 ****************************************************************************/
464 static void cmd_reg_delete_val(struct client_info *info)
470 POLICY_HND parent_pol;
471 fstring full_keyname;
476 DEBUG(5, ("cmd_reg_delete_val: smb_cli->fd:%d\n", smb_cli->fd));
478 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
480 fprintf(out_hnd, "regdelete <val_name>\n");
484 reg_get_subkey(full_keyname, keyname, val_name);
486 if (keyname[0] == 0 || val_name[0] == 0)
488 fprintf(out_hnd, "invalid key name\n");
492 /* open WINREG session. */
493 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
495 /* open registry receive a policy handle */
496 res = res ? do_reg_connect(smb_cli, keyname, parent_name,
497 &info->dom.reg_pol_connect) : False;
499 if ((*val_name) != 0)
502 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
503 parent_name, 0x02000000, &parent_pol) : False;
507 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
510 /* delete an entry */
511 res4 = res3 ? do_reg_delete_val(smb_cli, &parent_pol, val_name) : False;
513 /* flush the modified key */
514 res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
516 /* close the key handle */
517 res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
519 /* close the registry handles */
520 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
522 /* close the session */
523 cli_nt_session_close(smb_cli);
525 if (res && res3 && res4)
527 DEBUG(5,("cmd_reg_delete_val: query succeeded\n"));
528 fprintf(out_hnd,"OK\n");
532 DEBUG(5,("cmd_reg_delete_val: query failed\n"));
536 /****************************************************************************
537 nt registry delete key
538 ****************************************************************************/
539 static void cmd_reg_delete_key(struct client_info *info)
545 POLICY_HND parent_pol;
546 fstring full_keyname;
551 DEBUG(5, ("cmd_reg_delete_key: smb_cli->fd:%d\n", smb_cli->fd));
553 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
555 fprintf(out_hnd, "regdeletekey <key_name>\n");
559 reg_get_subkey(full_keyname, parent_name, subkey_name);
561 if (parent_name[0] == 0 || subkey_name[0] == 0)
563 fprintf(out_hnd, "invalid key name\n");
567 /* open WINREG session. */
568 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
570 /* open registry receive a policy handle */
571 res = res ? do_reg_connect(smb_cli, parent_name, key_name,
572 &info->dom.reg_pol_connect) : False;
574 if ((*key_name) != 0)
577 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
578 key_name, 0x02000000, &parent_pol) : False;
582 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
585 /* create an entry */
586 res4 = res3 ? do_reg_delete_key(smb_cli, &parent_pol, subkey_name) : False;
588 /* flush the modified key */
589 res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
591 /* close the key handle */
592 if ((*key_name) != 0)
594 res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
597 /* close the registry handles */
598 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
600 /* close the session */
601 cli_nt_session_close(smb_cli);
603 if (res && res3 && res4)
605 DEBUG(5,("cmd_reg_delete_key: query succeeded\n"));
606 fprintf(out_hnd,"OK\n");
610 DEBUG(5,("cmd_reg_delete_key: query failed\n"));
614 /****************************************************************************
615 nt registry create key
616 ****************************************************************************/
617 static void cmd_reg_create_key(struct client_info *info)
623 POLICY_HND parent_pol;
625 fstring full_keyname;
630 SEC_ACCESS sam_access;
632 DEBUG(5, ("cmd_reg_create_key: smb_cli->fd:%d\n", smb_cli->fd));
634 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
636 fprintf(out_hnd, "regcreate <key_name> [key_class]\n");
640 reg_get_subkey(full_keyname, parent_key, key_name);
642 if (parent_key[0] == 0 || key_name[0] == 0)
644 fprintf(out_hnd, "invalid key name\n");
648 if (!next_token_nr(NULL, key_class, NULL, sizeof(key_class)))
650 memset(key_class, 0, sizeof(key_class));
653 /* set access permissions */
654 sam_access.mask = SEC_RIGHTS_READ;
656 /* open WINREG session. */
657 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
659 /* open registry receive a policy handle */
660 res = res ? do_reg_connect(smb_cli, parent_key, parent_name,
661 &info->dom.reg_pol_connect) : False;
663 if ((*parent_name) != 0)
666 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
667 parent_name, 0x02000000, &parent_pol) : False;
671 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
674 /* create an entry */
675 res4 = res3 ? do_reg_create_key(smb_cli, &parent_pol,
676 key_name, key_class, &sam_access, &key_pol) : False;
678 /* flush the modified key */
679 res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
681 /* close the key handle */
682 res4 = res4 ? do_reg_close(smb_cli, &key_pol) : False;
684 /* close the key handle */
685 if ((*parent_name) != 0)
687 res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
690 /* close the registry handles */
691 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
693 /* close the session */
694 cli_nt_session_close(smb_cli);
696 if (res && res3 && res4)
698 DEBUG(5,("cmd_reg_create_key: query succeeded\n"));
699 fprintf(out_hnd,"OK\n");
703 DEBUG(5,("cmd_reg_create_key: query failed\n"));
707 /****************************************************************************
708 nt registry security info
709 ****************************************************************************/
710 static void cmd_reg_test_key_sec(struct client_info *info)
717 fstring full_keyname;
727 DEBUG(5, ("cmd_reg_get_key_sec: smb_cli->fd:%d\n", smb_cli->fd));
729 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
731 fprintf(out_hnd, "reggetsec <key_name>\n");
735 /* open WINREG session. */
736 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
738 /* open registry receive a policy handle */
739 res = res ? do_reg_connect(smb_cli, full_keyname, key_name,
740 &info->dom.reg_pol_connect) : False;
742 if ((*key_name) != 0)
745 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
746 key_name, 0x02000000, &key_pol) : False;
750 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
754 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
755 key_name, 0x02000000, &key_pol) : False;
757 /* query key sec info. first call sets sec_buf_size. */
760 res4 = res3 ? do_reg_get_key_sec(smb_cli, &key_pol,
761 &sec_buf_size, &psdb) : False;
763 free_sec_desc_buf(&psdb);
765 res4 = res4 ? do_reg_get_key_sec(smb_cli, &key_pol,
766 &sec_buf_size, &psdb) : False;
768 if (res4 && psdb->len > 0 && psdb->sec != NULL)
770 display_sec_desc(out_hnd, ACTION_HEADER , psdb->sec);
771 display_sec_desc(out_hnd, ACTION_ENUMERATE, psdb->sec);
772 display_sec_desc(out_hnd, ACTION_FOOTER , psdb->sec);
774 res4 = res4 ? do_reg_set_key_sec(smb_cli, &key_pol, psdb) : False;
777 free_sec_desc_buf(&psdb);
779 /* close the key handle */
780 if ((*key_name) != 0)
782 res3 = res3 ? do_reg_close(smb_cli, &key_pol) : False;
785 /* close the registry handles */
786 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
788 /* close the session */
789 cli_nt_session_close(smb_cli);
791 if (res && res3 && res4)
793 DEBUG(5,("cmd_reg_test2: query succeeded\n"));
794 fprintf(out_hnd,"Registry Test2\n");
798 DEBUG(5,("cmd_reg_test2: query failed\n"));
802 /****************************************************************************
803 nt registry security info
804 ****************************************************************************/
805 static void cmd_reg_get_key_sec(struct client_info *info)
812 fstring full_keyname;
822 DEBUG(5, ("cmd_reg_get_key_sec: smb_cli->fd:%d\n", smb_cli->fd));
824 if (!next_token_nr(NULL, full_keyname, NULL, sizeof(full_keyname)))
826 fprintf(out_hnd, "reggetsec <key_name>\n");
830 /* open WINREG session. */
831 res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
833 /* open registry receive a policy handle */
834 res = res ? do_reg_connect(smb_cli, full_keyname, key_name,
835 &info->dom.reg_pol_connect) : False;
837 if ((*key_name) != 0)
840 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
841 key_name, 0x02000000, &key_pol) : False;
845 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
849 res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
850 key_name, 0x02000000, &key_pol) : False;
854 res4 = res3 ? do_reg_get_key_sec(smb_cli, &key_pol,
855 &sec_buf_size, &psdb) : False;
857 free_sec_desc_buf(&psdb);
859 res4 = res4 ? do_reg_get_key_sec(smb_cli, &key_pol,
860 &sec_buf_size, &psdb) : False;
862 if (res4 && psdb->len > 0 && psdb->sec != NULL)
864 display_sec_desc(out_hnd, ACTION_HEADER , psdb->sec);
865 display_sec_desc(out_hnd, ACTION_ENUMERATE, psdb->sec);
866 display_sec_desc(out_hnd, ACTION_FOOTER , psdb->sec);
869 free_sec_desc_buf(&psdb);
871 /* close the key handle */
872 if ((*key_name) != 0)
874 res3 = res3 ? do_reg_close(smb_cli, &key_pol) : False;
877 /* close the registry handles */
878 res = res ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
880 /* close the session */
881 cli_nt_session_close(smb_cli);
883 if (res && res3 && res4)
885 DEBUG(5,("cmd_reg_get_key_sec: query succeeded\n"));
889 DEBUG(5,("cmd_reg_get_key_sec: query failed\n"));
895 /****************************************************************************
897 ****************************************************************************/
898 static NTSTATUS cmd_reg_shutdown(struct cli_state *cli, TALLOC_CTX *mem_ctx,
899 int argc, char **argv)
901 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
909 ret = asprintf (&srv_name, "\\\\%s", cli->desthost);
911 DEBUG(0,("cmd_reg_shutdown: Not enough memory!\n"));
912 return NT_STATUS_UNSUCCESSFUL;
917 optind = 0; /* TODO: test if this hack works on other systems too --simo */
919 while ((opt = getopt(argc, argv, "m:t:rf")) != EOF)
921 fprintf (stderr, "[%s]\n", argv[argc-1]);
927 safe_strcpy(msg, optarg, sizeof(msg)-1);
928 fprintf (stderr, "[%s|%s]\n", optarg, msg);
933 timeout = atoi(optarg);
934 fprintf (stderr, "[%s|%d]\n", optarg, timeout);
950 /* create an entry */
951 result = cli_reg_shutdown(cli, mem_ctx, srv_name, msg, timeout, flgs);
953 if (NT_STATUS_IS_OK(result))
954 DEBUG(5,("cmd_reg_shutdown: query succeeded\n"));
956 DEBUG(5,("cmd_reg_shutdown: query failed\n"));
961 /****************************************************************************
963 ****************************************************************************/
964 static NTSTATUS cmd_reg_abort_shutdown(struct cli_state *cli,
965 TALLOC_CTX *mem_ctx, int argc,
968 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
972 ret = asprintf(&srv_name, "\\\\%s", cli->desthost);
974 DEBUG(0,("cmd_reg_shutdown: Not enough memory!\n"));
975 return NT_STATUS_UNSUCCESSFUL;
979 result = cli_reg_abort_shutdown(cli, mem_ctx, srv_name);
981 if (NT_STATUS_IS_OK(result))
982 DEBUG(5,("cmd_reg_abort_shutdown: query succeeded\n"));
984 DEBUG(5,("cmd_reg_abort_shutdown: query failed\n"));
990 /* List of commands exported by this module */
991 struct cmd_set reg_commands[] = {
995 { "shutdown", cmd_reg_shutdown, PIPE_WINREG, "Remote Shutdown",
996 "[-m message] [-t timeout] [-r] [-f] (-r == reboot, -f == force)" },
998 { "abortshutdown", cmd_reg_abort_shutdown, PIPE_WINREG, "Abort Shutdown",
1001 { "regenum", cmd_reg_enum, "Registry Enumeration",
1004 { "regdeletekey", cmd_reg_delete_key, "Registry Key Delete",
1007 { "regcreatekey", cmd_reg_create_key, "Registry Key Create",
1008 "<keyname> [keyclass]" },
1010 { "regqueryval", cmd_reg_query_info, "Registry Value Query",
1013 { "regquerykey", cmd_reg_query_key, "Registry Key Query",
1016 { "regdeleteval", cmd_reg_delete_val, "Registry Value Delete",
1019 { "regcreateval", cmd_reg_create_val, "Registry Key Create",
1020 "<valname> <valtype> <value>" },
1022 { "reggetsec", cmd_reg_get_key_sec, "Registry Key Security",
1025 { "regtestsec", cmd_reg_test_key_sec, "Test Registry Key Security",