vcs.maemo.org Git - samba/blob - source/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 /* This whole file need to be rewritten for the cirrent 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 };