source3/rpcclient/cmd_reg.c

   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, PI_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, PI_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, PI_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, PI_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, PI_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, PI_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, PI_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, PI_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, const char **argv)
 899 {
 900         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 901         fstring msg;
 902         uint32 timeout = 20;
 903         BOOL force = False;
 904         BOOL reboot = False;
 905         int opt;
 906
 907         *msg = 0;
 908         optind = 0; /* TODO: test if this hack works on other systems too --simo */
 909
 910         while ((opt = getopt(argc, argv, "m:t:rf")) != EOF)
 911         {
 912                 /*fprintf (stderr, "[%s]\n", argv[argc-1]);*/
 913
 914                 switch (opt)
 915                 {
 916                         case 'm':
 917                                 fstrcpy(msg, optarg);
 918                                 /*fprintf (stderr, "[%s|%s]\n", optarg, msg);*/
 919                                 break;
 920
 921                         case 't':
 922                                 timeout = atoi(optarg);
 923                                 /*fprintf (stderr, "[%s|%d]\n", optarg, timeout);*/
 924                                 break;
 925
 926                         case 'r':
 927                                 reboot = True;
 928                                 break;
 929
 930                         case 'f':
 931                                 force = True;
 932                                 break;
 933
 934                 }
 935         }
 936
 937         /* create an entry */
 938         result = cli_reg_shutdown(cli, mem_ctx, msg, timeout, reboot, force);
 939
 940         if (NT_STATUS_IS_OK(result))
 941                 DEBUG(5,("cmd_reg_shutdown: query succeeded\n"));
 942         else
 943                 DEBUG(5,("cmd_reg_shutdown: query failed\n"));
 944
 945         return result;
 946 }
 947
 948 /****************************************************************************
 949 abort a shutdown
 950 ****************************************************************************/
 951 static NTSTATUS cmd_reg_abort_shutdown(struct cli_state *cli,
 952                                        TALLOC_CTX *mem_ctx, int argc,
 953                                        const char **argv)
 954 {
 955         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 956
 957         result = cli_reg_abort_shutdown(cli, mem_ctx);
 958
 959         if (NT_STATUS_IS_OK(result))
 960                 DEBUG(5,("cmd_reg_abort_shutdown: query succeeded\n"));
 961         else
 962                 DEBUG(5,("cmd_reg_abort_shutdown: query failed\n"));
 963
 964         return result;
 965 }
 966
 967
 968 /* List of commands exported by this module */
 969 struct cmd_set reg_commands[] = {
 970
 971         { "REG"  },
 972
 973         { "shutdown", RPC_RTYPE_NTSTATUS, cmd_reg_shutdown, NULL, PI_WINREG, "Remote Shutdown",
 974                                 "syntax: shutdown [-m message] [-t timeout] [-r] [-h] [-f] (-r == reboot, -h == halt, -f == force)" },
 975
 976         { "abortshutdown", RPC_RTYPE_NTSTATUS, cmd_reg_abort_shutdown, NULL, PI_WINREG, "Abort Shutdown",
 977                                 "syntax: abortshutdown" },
 978 /*
 979         { "regenum",            cmd_reg_enum,                   "Registry Enumeration",
 980                                 "<keyname>" },
 981
 982         { "regdeletekey",       cmd_reg_delete_key,             "Registry Key Delete",
 983                                 "<keyname>" },
 984
 985         { "regcreatekey",       cmd_reg_create_key,             "Registry Key Create",
 986                                 "<keyname> [keyclass]" },
 987
 988         { "regqueryval",        cmd_reg_query_info,             "Registry Value Query",
 989                                 "<valname>" },
 990
 991         { "regquerykey",        cmd_reg_query_key,              "Registry Key Query",
 992                                 "<keyname>" },
 993
 994         { "regdeleteval",       cmd_reg_delete_val,             "Registry Value Delete",
 995                                 "<valname>" },
 996
 997         { "regcreateval",       cmd_reg_create_val,             "Registry Key Create",
 998                                 "<valname> <valtype> <value>" },
 999
1000         { "reggetsec",          cmd_reg_get_key_sec,            "Registry Key Security",
1001                                 "<keyname>" },
1002
1003         { "regtestsec",         cmd_reg_test_key_sec,           "Test Registry Key Security",
1004                                 "<keyname>" },
1005 */
1006         { NULL }
1007 };