source3/rpcclient/cmd_reg.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    NT Domain Authentication SMB / MSRPC client
   5    Copyright (C) Andrew Tridgell 1994-1997
   6    Copyright (C) Luke Kenneth Casson Leighton 1996-1997
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23
  24
  25 #ifdef SYSLOG
  26 #undef SYSLOG
  27 #endif
  28
  29 #include "includes.h"
  30 #include "nterr.h"
  31
  32 extern int DEBUGLEVEL;
  33
  34 extern struct cli_state *smb_cli;
  35 extern int smb_tidx;
  36
  37 extern FILE* out_hnd;
  38
  39 /*
  40  * keys.  of the form:
  41  * ----
  42  *
  43  * [HKLM]|[HKU]\[parent_keyname_components]\[subkey]|[value]
  44  *
  45  * reg_getsubkey() splits this down into:
  46  * [HKLM]|[HKU]\[parent_keyname_components] and [subkey]|[value]
  47  *
  48  * do_reg_connect() splits the left side down further into:
  49  * [HKLM]|[HKU] and [parent_keyname_components].
  50  *
  51  * HKLM is short for HKEY_LOCAL_MACHINE
  52  * HKU  is short for HKEY_USERS
  53  *
  54  * oh, and HKEY stands for "Hive Key".
  55  *
  56  */
  57
  58 /****************************************************************************
  59 nt registry enum
  60 ****************************************************************************/
  61 void cmd_reg_enum(struct client_info *info)
  62 {
  63         BOOL res = True;
  64         BOOL res1 = True;
  65         BOOL res2 = True;
  66         int i;
  67
  68         POLICY_HND key_pol;
  69         fstring full_keyname;
  70         fstring key_name;
  71
  72         /*
  73          * query key info
  74          */
  75
  76         fstring key_class;
  77         uint32 max_class_len = 0;
  78         uint32 num_subkeys;
  79         uint32 max_subkeylen;
  80         uint32 max_subkeysize;
  81         uint32 num_values;
  82         uint32 max_valnamelen;
  83         uint32 max_valbufsize;
  84         uint32 sec_desc;
  85         NTTIME mod_time;
  86
  87         /*
  88          * unknown 0x1a request
  89          */
  90
  91         uint32 unk_1a_response;
  92
  93         DEBUG(5, ("cmd_reg_enum: smb_cli->fd:%d\n", smb_cli->fd));
  94
  95         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
  96         {
  97                 fprintf(out_hnd, "regenum <key_name>\n");
  98                 return;
  99         }
 100
 101         /* open WINREG session. */
 102         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
 103
 104         /* open registry receive a policy handle */
 105         res = res ? do_reg_connect(smb_cli, full_keyname, key_name,
 106                                 &info->dom.reg_pol_connect) : False;
 107
 108         if ((*key_name) != 0)
 109         {
 110                 /* open an entry */
 111                 res1 = res  ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
 112                                          key_name, 0x02000000, &key_pol) : False;
 113         }
 114         else
 115         {
 116                 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
 117         }
 118
 119         res1 = res1 ? do_reg_query_key(smb_cli,
 120                                 &key_pol,
 121                                 key_class, &max_class_len,
 122                                 &num_subkeys, &max_subkeylen, &max_subkeysize,
 123                                 &num_values, &max_valnamelen, &max_valbufsize,
 124                                 &sec_desc, &mod_time) : False;
 125
 126         if (res1 && num_subkeys > 0)
 127         {
 128                 fprintf(out_hnd,"Subkeys\n");
 129                 fprintf(out_hnd,"-------\n");
 130         }
 131
 132         for (i = 0; i < num_subkeys; i++)
 133         {
 134                 /*
 135                  * enumerate key
 136                  */
 137
 138                 fstring enum_name;
 139                 uint32 enum_unk1;
 140                 uint32 enum_unk2;
 141                 time_t key_mod_time;
 142
 143                 /* unknown 1a it */
 144                 res2 = res1 ? do_reg_unknown_1a(smb_cli, &key_pol,
 145                                         &unk_1a_response) : False;
 146
 147                 if (res2 && unk_1a_response != 5)
 148                 {
 149                         fprintf(out_hnd,"Unknown 1a response: %x\n", unk_1a_response);
 150                 }
 151
 152                 /* enum key */
 153                 res2 = res2 ? do_reg_enum_key(smb_cli, &key_pol,
 154                                         i, enum_name,
 155                                         &enum_unk1, &enum_unk2,
 156                                         &key_mod_time) : False;
 157
 158                 if (res2)
 159                 {
 160                         display_reg_key_info(out_hnd, ACTION_HEADER   , enum_name, key_mod_time);
 161                         display_reg_key_info(out_hnd, ACTION_ENUMERATE, enum_name, key_mod_time);
 162                         display_reg_key_info(out_hnd, ACTION_FOOTER   , enum_name, key_mod_time);
 163                 }
 164
 165         }
 166
 167         if (num_values > 0)
 168         {
 169                 fprintf(out_hnd,"Key Values\n");
 170                 fprintf(out_hnd,"----------\n");
 171         }
 172
 173         for (i = 0; i < num_values; i++)
 174         {
 175                 /*
 176                  * enumerate key
 177                  */
 178
 179                 uint32 val_type;
 180                 BUFFER2 value;
 181                 fstring val_name;
 182
 183                 /* unknown 1a it */
 184                 res2 = res1 ? do_reg_unknown_1a(smb_cli, &key_pol,
 185                                         &unk_1a_response) : False;
 186
 187                 if (res2 && unk_1a_response != 5)
 188                 {
 189                         fprintf(out_hnd,"Unknown 1a response: %x\n", unk_1a_response);
 190                 }
 191
 192                 /* enum key */
 193                 res2 = res2 ? do_reg_enum_val(smb_cli, &key_pol,
 194                                         i, max_valnamelen, max_valbufsize,
 195                                         val_name, &val_type, &value) : False;
 196
 197                 if (res2)
 198                 {
 199                         display_reg_value_info(out_hnd, ACTION_HEADER   , val_name, val_type, &value);
 200                         display_reg_value_info(out_hnd, ACTION_ENUMERATE, val_name, val_type, &value);
 201                         display_reg_value_info(out_hnd, ACTION_FOOTER   , val_name, val_type, &value);
 202                 }
 203         }
 204
 205         /* close the handles */
 206         if ((*key_name) != 0)
 207         {
 208                 res1 = res1 ? do_reg_close(smb_cli, &key_pol) : False;
 209         }
 210         res  = res  ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
 211
 212         /* close the session */
 213         cli_nt_session_close(smb_cli);
 214
 215         if (res && res1 && res2)
 216         {
 217                 DEBUG(5,("cmd_reg_enum: query succeeded\n"));
 218         }
 219         else
 220         {
 221                 DEBUG(5,("cmd_reg_enum: query failed\n"));
 222         }
 223 }
 224
 225 /****************************************************************************
 226 nt registry query key
 227 ****************************************************************************/
 228 void cmd_reg_query_key(struct client_info *info)
 229 {
 230         BOOL res = True;
 231         BOOL res1 = True;
 232
 233         POLICY_HND key_pol;
 234         fstring full_keyname;
 235         fstring key_name;
 236
 237         /*
 238          * query key info
 239          */
 240
 241         fstring key_class;
 242         uint32 key_class_len = 0;
 243         uint32 num_subkeys;
 244         uint32 max_subkeylen;
 245         uint32 max_subkeysize;
 246         uint32 num_values;
 247         uint32 max_valnamelen;
 248         uint32 max_valbufsize;
 249         uint32 sec_desc;
 250         NTTIME mod_time;
 251
 252         DEBUG(5, ("cmd_reg_enum: smb_cli->fd:%d\n", smb_cli->fd));
 253
 254         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
 255         {
 256                 fprintf(out_hnd, "regquery key_name\n");
 257                 return;
 258         }
 259
 260         /* open WINREG session. */
 261         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
 262
 263         /* open registry receive a policy handle */
 264         res = res ? do_reg_connect(smb_cli, full_keyname, key_name,
 265                                 &info->dom.reg_pol_connect) : False;
 266
 267         if ((*key_name) != 0)
 268         {
 269                 /* open an entry */
 270                 res1 = res  ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
 271                                          key_name, 0x02000000, &key_pol) : False;
 272         }
 273         else
 274         {
 275                 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
 276         }
 277
 278         res1 = res1 ? do_reg_query_key(smb_cli,
 279                                 &key_pol,
 280                                 key_class, &key_class_len,
 281                                 &num_subkeys, &max_subkeylen, &max_subkeysize,
 282                                 &num_values, &max_valnamelen, &max_valbufsize,
 283                                 &sec_desc, &mod_time) : False;
 284
 285         if (res1 && key_class_len != 0)
 286         {
 287                 res1 = res1 ? do_reg_query_key(smb_cli,
 288                                 &key_pol,
 289                                 key_class, &key_class_len,
 290                                 &num_subkeys, &max_subkeylen, &max_subkeysize,
 291                                 &num_values, &max_valnamelen, &max_valbufsize,
 292                                 &sec_desc, &mod_time) : False;
 293         }
 294
 295         if (res1)
 296         {
 297                 fprintf(out_hnd,"Registry Query Info Key\n");
 298                 fprintf(out_hnd,"key class: %s\n", key_class);
 299                 fprintf(out_hnd,"subkeys, max_len, max_size: %d %d %d\n", num_subkeys, max_subkeylen, max_subkeysize);
 300                 fprintf(out_hnd,"vals, max_len, max_size: 0x%x 0x%x 0x%x\n", num_values, max_valnamelen, max_valbufsize);
 301                 fprintf(out_hnd,"sec desc: 0x%x\n", sec_desc);
 302                 fprintf(out_hnd,"mod time: %s\n", http_timestring(nt_time_to_unix(&mod_time)));
 303         }
 304
 305         /* close the handles */
 306         if ((*key_name) != 0)
 307         {
 308                 res1 = res1 ? do_reg_close(smb_cli, &key_pol) : False;
 309         }
 310         res  = res  ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
 311
 312         /* close the session */
 313         cli_nt_session_close(smb_cli);
 314
 315         if (res && res1)
 316         {
 317                 DEBUG(5,("cmd_reg_query: query succeeded\n"));
 318         }
 319         else
 320         {
 321                 DEBUG(5,("cmd_reg_query: query failed\n"));
 322         }
 323 }
 324
 325 /****************************************************************************
 326 nt registry create value
 327 ****************************************************************************/
 328 void cmd_reg_create_val(struct client_info *info)
 329 {
 330         BOOL res = True;
 331         BOOL res3 = True;
 332         BOOL res4 = True;
 333
 334         POLICY_HND parent_pol;
 335         fstring full_keyname;
 336         fstring keyname;
 337         fstring parent_name;
 338         fstring val_name;
 339         fstring tmp;
 340         uint32 val_type;
 341         BUFFER3 value;
 342
 343 #if 0
 344         uint32 unk_0;
 345         uint32 unk_1;
 346         /* query it */
 347         res1 = res1 ? do_reg_query_info(smb_cli, &val_pol,
 348                                 type, &unk_0, &unk_1) : False;
 349 #endif
 350
 351         DEBUG(5, ("cmd_reg_create_val: smb_cli->fd:%d\n", smb_cli->fd));
 352
 353         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
 354         {
 355                 fprintf(out_hnd, "regcreate <val_name> <val_type> <val>\n");
 356                 return;
 357         }
 358
 359         reg_get_subkey(full_keyname, keyname, val_name);
 360
 361         if (keyname[0] == 0 || val_name[0] == 0)
 362         {
 363                 fprintf(out_hnd, "invalid key name\n");
 364                 return;
 365         }
 366
 367         if (!next_token(NULL, tmp, NULL, sizeof(tmp)))
 368         {
 369                 fprintf(out_hnd, "regcreate <val_name> <val_type (1|4)> <val>\n");
 370                 return;
 371         }
 372
 373         val_type = atoi(tmp);
 374
 375         if (val_type != 1 && val_type != 3 && val_type != 4)
 376         {
 377                 fprintf(out_hnd, "val_type 1=UNISTR, 3=BYTES, 4=DWORD supported\n");
 378                 return;
 379         }
 380
 381         if (!next_token(NULL, tmp, NULL, sizeof(tmp)))
 382         {
 383                 fprintf(out_hnd, "regcreate <val_name> <val_type (1|4)> <val>\n");
 384                 return;
 385         }
 386
 387         switch (val_type)
 388         {
 389                 case 0x01: /* UNISTR */
 390                 {
 391                         init_buffer3_str(&value, tmp, strlen(tmp)+1);
 392                         break;
 393                 }
 394                 case 0x03: /* BYTES */
 395                 {
 396                         init_buffer3_hex(&value, tmp);
 397                         break;
 398                 }
 399                 case 0x04: /* DWORD */
 400                 {
 401                         uint32 tmp_val;
 402                         if (strnequal(tmp, "0x", 2))
 403                         {
 404                                 tmp_val = strtol(tmp, (char**)NULL, 16);
 405                         }
 406                         else
 407                         {
 408                                 tmp_val = strtol(tmp, (char**)NULL, 10);
 409                         }
 410                         init_buffer3_uint32(&value, tmp_val);
 411                         break;
 412                 }
 413                 default:
 414                 {
 415                         fprintf(out_hnd, "i told you i only deal with UNISTR, DWORD and BYTES!\n");
 416                         return;
 417                 }
 418         }
 419
 420         DEBUG(10,("key data:\n"));
 421         dump_data(10, (char *)value.buffer, value.buf_len);
 422
 423         /* open WINREG session. */
 424         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
 425
 426         /* open registry receive a policy handle */
 427         res = res ? do_reg_connect(smb_cli, keyname, parent_name,
 428                                 &info->dom.reg_pol_connect) : False;
 429
 430         if ((*val_name) != 0)
 431         {
 432                 /* open an entry */
 433                 res3 = res  ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
 434                                          parent_name, 0x02000000, &parent_pol) : False;
 435         }
 436         else
 437         {
 438                 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
 439         }
 440
 441         /* create an entry */
 442         res4 = res3 ? do_reg_create_val(smb_cli, &parent_pol,
 443                                  val_name, val_type, &value) : False;
 444
 445         /* flush the modified key */
 446         res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
 447
 448         /* close the val handle */
 449         if ((*val_name) != 0)
 450         {
 451                 res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
 452         }
 453
 454         /* close the registry handles */
 455         res  = res  ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
 456
 457         /* close the session */
 458         cli_nt_session_close(smb_cli);
 459
 460         if (res && res3 && res4)
 461         {
 462                 DEBUG(5,("cmd_reg_create_val: query succeeded\n"));
 463                 fprintf(out_hnd,"OK\n");
 464         }
 465         else
 466         {
 467                 DEBUG(5,("cmd_reg_create_val: query failed\n"));
 468         }
 469 }
 470
 471 /****************************************************************************
 472 nt registry delete value
 473 ****************************************************************************/
 474 void cmd_reg_delete_val(struct client_info *info)
 475 {
 476         BOOL res = True;
 477         BOOL res3 = True;
 478         BOOL res4 = True;
 479
 480         POLICY_HND parent_pol;
 481         fstring full_keyname;
 482         fstring keyname;
 483         fstring parent_name;
 484         fstring val_name;
 485
 486         DEBUG(5, ("cmd_reg_delete_val: smb_cli->fd:%d\n", smb_cli->fd));
 487
 488         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
 489         {
 490                 fprintf(out_hnd, "regdelete <val_name>\n");
 491                 return;
 492         }
 493
 494         reg_get_subkey(full_keyname, keyname, val_name);
 495
 496         if (keyname[0] == 0 || val_name[0] == 0)
 497         {
 498                 fprintf(out_hnd, "invalid key name\n");
 499                 return;
 500         }
 501
 502         /* open WINREG session. */
 503         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
 504
 505         /* open registry receive a policy handle */
 506         res = res ? do_reg_connect(smb_cli, keyname, parent_name,
 507                                 &info->dom.reg_pol_connect) : False;
 508
 509         if ((*val_name) != 0)
 510         {
 511                 /* open an entry */
 512                 res3 = res  ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
 513                                          parent_name, 0x02000000, &parent_pol) : False;
 514         }
 515         else
 516         {
 517                 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
 518         }
 519
 520         /* delete an entry */
 521         res4 = res3 ? do_reg_delete_val(smb_cli, &parent_pol, val_name) : False;
 522
 523         /* flush the modified key */
 524         res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
 525
 526         /* close the key handle */
 527         res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
 528
 529         /* close the registry handles */
 530         res  = res  ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
 531
 532         /* close the session */
 533         cli_nt_session_close(smb_cli);
 534
 535         if (res && res3 && res4)
 536         {
 537                 DEBUG(5,("cmd_reg_delete_val: query succeeded\n"));
 538                 fprintf(out_hnd,"OK\n");
 539         }
 540         else
 541         {
 542                 DEBUG(5,("cmd_reg_delete_val: query failed\n"));
 543         }
 544 }
 545
 546 /****************************************************************************
 547 nt registry delete key
 548 ****************************************************************************/
 549 void cmd_reg_delete_key(struct client_info *info)
 550 {
 551         BOOL res = True;
 552         BOOL res3 = True;
 553         BOOL res4 = True;
 554
 555         POLICY_HND parent_pol;
 556         fstring full_keyname;
 557         fstring parent_name;
 558         fstring key_name;
 559         fstring subkey_name;
 560
 561         DEBUG(5, ("cmd_reg_delete_key: smb_cli->fd:%d\n", smb_cli->fd));
 562
 563         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
 564         {
 565                 fprintf(out_hnd, "regdeletekey <key_name>\n");
 566                 return;
 567         }
 568
 569         reg_get_subkey(full_keyname, parent_name, subkey_name);
 570
 571         if (parent_name[0] == 0 || subkey_name[0] == 0)
 572         {
 573                 fprintf(out_hnd, "invalid key name\n");
 574                 return;
 575         }
 576
 577         /* open WINREG session. */
 578         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
 579
 580         /* open registry receive a policy handle */
 581         res = res ? do_reg_connect(smb_cli, parent_name, key_name,
 582                                 &info->dom.reg_pol_connect) : False;
 583
 584         if ((*key_name) != 0)
 585         {
 586                 /* open an entry */
 587                 res3 = res  ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
 588                                          key_name, 0x02000000, &parent_pol) : False;
 589         }
 590         else
 591         {
 592                 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
 593         }
 594
 595         /* create an entry */
 596         res4 = res3 ? do_reg_delete_key(smb_cli, &parent_pol, subkey_name) : False;
 597
 598         /* flush the modified key */
 599         res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
 600
 601         /* close the key handle */
 602         if ((*key_name) != 0)
 603         {
 604                 res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
 605         }
 606
 607         /* close the registry handles */
 608         res  = res  ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
 609
 610         /* close the session */
 611         cli_nt_session_close(smb_cli);
 612
 613         if (res && res3 && res4)
 614         {
 615                 DEBUG(5,("cmd_reg_delete_key: query succeeded\n"));
 616                 fprintf(out_hnd,"OK\n");
 617         }
 618         else
 619         {
 620                 DEBUG(5,("cmd_reg_delete_key: query failed\n"));
 621         }
 622 }
 623
 624 /****************************************************************************
 625 nt registry create key
 626 ****************************************************************************/
 627 void cmd_reg_create_key(struct client_info *info)
 628 {
 629         BOOL res = True;
 630         BOOL res3 = True;
 631         BOOL res4 = True;
 632
 633         POLICY_HND parent_pol;
 634         POLICY_HND key_pol;
 635         fstring full_keyname;
 636         fstring parent_key;
 637         fstring parent_name;
 638         fstring key_name;
 639         fstring key_class;
 640         SEC_ACCESS sam_access;
 641
 642         DEBUG(5, ("cmd_reg_create_key: smb_cli->fd:%d\n", smb_cli->fd));
 643
 644         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
 645         {
 646                 fprintf(out_hnd, "regcreate <key_name> [key_class]\n");
 647                 return;
 648         }
 649
 650         reg_get_subkey(full_keyname, parent_key, key_name);
 651
 652         if (parent_key[0] == 0 || key_name[0] == 0)
 653         {
 654                 fprintf(out_hnd, "invalid key name\n");
 655                 return;
 656         }
 657
 658         if (!next_token(NULL, key_class, NULL, sizeof(key_class)))
 659         {
 660                 memset(key_class, 0, sizeof(key_class));
 661         }
 662
 663         /* set access permissions */
 664         sam_access.mask = SEC_RIGHTS_READ;
 665
 666         /* open WINREG session. */
 667         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
 668
 669         /* open registry receive a policy handle */
 670         res = res ? do_reg_connect(smb_cli, parent_key, parent_name,
 671                                 &info->dom.reg_pol_connect) : False;
 672
 673         if ((*parent_name) != 0)
 674         {
 675                 /* open an entry */
 676                 res3 = res  ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
 677                                          parent_name, 0x02000000, &parent_pol) : False;
 678         }
 679         else
 680         {
 681                 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
 682         }
 683
 684         /* create an entry */
 685         res4 = res3 ? do_reg_create_key(smb_cli, &parent_pol,
 686                                  key_name, key_class, &sam_access, &key_pol) : False;
 687
 688         /* flush the modified key */
 689         res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
 690
 691         /* close the key handle */
 692         res4 = res4 ? do_reg_close(smb_cli, &key_pol) : False;
 693
 694         /* close the key handle */
 695         if ((*parent_name) != 0)
 696         {
 697                 res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
 698         }
 699
 700         /* close the registry handles */
 701         res  = res  ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
 702
 703         /* close the session */
 704         cli_nt_session_close(smb_cli);
 705
 706         if (res && res3 && res4)
 707         {
 708                 DEBUG(5,("cmd_reg_create_key: query succeeded\n"));
 709                 fprintf(out_hnd,"OK\n");
 710         }
 711         else
 712         {
 713                 DEBUG(5,("cmd_reg_create_key: query failed\n"));
 714         }
 715 }
 716
 717 /****************************************************************************
 718 nt registry security info
 719 ****************************************************************************/
 720 void cmd_reg_test_key_sec(struct client_info *info)
 721 {
 722         BOOL res = True;
 723         BOOL res3 = True;
 724         BOOL res4 = True;
 725
 726         POLICY_HND key_pol;
 727         fstring full_keyname;
 728         fstring key_name;
 729
 730         /*
 731          * security info
 732          */
 733
 734         uint32 sec_buf_size;
 735         SEC_DESC_BUF *psdb;
 736
 737         DEBUG(5, ("cmd_reg_get_key_sec: smb_cli->fd:%d\n", smb_cli->fd));
 738
 739         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
 740         {
 741                 fprintf(out_hnd, "reggetsec <key_name>\n");
 742                 return;
 743         }
 744
 745         /* open WINREG session. */
 746         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
 747
 748         /* open registry receive a policy handle */
 749         res = res ? do_reg_connect(smb_cli, full_keyname, key_name,
 750                                 &info->dom.reg_pol_connect) : False;
 751
 752         if ((*key_name) != 0)
 753         {
 754                 /* open an entry */
 755                 res3 = res  ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
 756                                          key_name, 0x02000000, &key_pol) : False;
 757         }
 758         else
 759         {
 760                 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
 761         }
 762
 763         /* open an entry */
 764         res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
 765                                  key_name, 0x02000000, &key_pol) : False;
 766
 767         /* query key sec info.  first call sets sec_buf_size. */
 768
 769         sec_buf_size = 0;
 770         res4 = res3 ? do_reg_get_key_sec(smb_cli, &key_pol,
 771                                 &sec_buf_size, &psdb) : False;
 772
 773         free_sec_desc_buf(&psdb);
 774
 775         res4 = res4 ? do_reg_get_key_sec(smb_cli, &key_pol,
 776                                 &sec_buf_size, &psdb) : False;
 777
 778         if (res4 && psdb->len > 0 && psdb->sec != NULL)
 779         {
 780                 display_sec_desc(out_hnd, ACTION_HEADER   , psdb->sec);
 781                 display_sec_desc(out_hnd, ACTION_ENUMERATE, psdb->sec);
 782                 display_sec_desc(out_hnd, ACTION_FOOTER   , psdb->sec);
 783
 784                 res4 = res4 ? do_reg_set_key_sec(smb_cli, &key_pol, psdb) : False;
 785         }
 786
 787         free_sec_desc_buf(&psdb);
 788
 789         /* close the key handle */
 790         if ((*key_name) != 0)
 791         {
 792                 res3 = res3 ? do_reg_close(smb_cli, &key_pol) : False;
 793         }
 794
 795         /* close the registry handles */
 796         res  = res  ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
 797
 798         /* close the session */
 799         cli_nt_session_close(smb_cli);
 800
 801         if (res && res3 && res4)
 802         {
 803                 DEBUG(5,("cmd_reg_test2: query succeeded\n"));
 804                 fprintf(out_hnd,"Registry Test2\n");
 805         }
 806         else
 807         {
 808                 DEBUG(5,("cmd_reg_test2: query failed\n"));
 809         }
 810 }
 811
 812 /****************************************************************************
 813 nt registry security info
 814 ****************************************************************************/
 815 void cmd_reg_get_key_sec(struct client_info *info)
 816 {
 817         BOOL res = True;
 818         BOOL res3 = True;
 819         BOOL res4 = True;
 820
 821         POLICY_HND key_pol;
 822         fstring full_keyname;
 823         fstring key_name;
 824
 825         /*
 826          * security info
 827          */
 828
 829         uint32 sec_buf_size;
 830         SEC_DESC_BUF *psdb;
 831
 832         DEBUG(5, ("cmd_reg_get_key_sec: smb_cli->fd:%d\n", smb_cli->fd));
 833
 834         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
 835         {
 836                 fprintf(out_hnd, "reggetsec <key_name>\n");
 837                 return;
 838         }
 839
 840         /* open WINREG session. */
 841         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
 842
 843         /* open registry receive a policy handle */
 844         res = res ? do_reg_connect(smb_cli, full_keyname, key_name,
 845                                 &info->dom.reg_pol_connect) : False;
 846
 847         if ((*key_name) != 0)
 848         {
 849                 /* open an entry */
 850                 res3 = res  ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
 851                                          key_name, 0x02000000, &key_pol) : False;
 852         }
 853         else
 854         {
 855                 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
 856         }
 857
 858         /* open an entry */
 859         res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
 860                                  key_name, 0x02000000, &key_pol) : False;
 861
 862         /* Get the size. */
 863         sec_buf_size = 0;
 864         res4 = res3 ? do_reg_get_key_sec(smb_cli, &key_pol,
 865                                 &sec_buf_size, &psdb) : False;
 866
 867         free_sec_desc_buf(&psdb);
 868
 869         res4 = res4 ? do_reg_get_key_sec(smb_cli, &key_pol,
 870                                 &sec_buf_size, &psdb) : False;
 871
 872         if (res4 && psdb->len > 0 && psdb->sec != NULL)
 873         {
 874                 display_sec_desc(out_hnd, ACTION_HEADER   , psdb->sec);
 875                 display_sec_desc(out_hnd, ACTION_ENUMERATE, psdb->sec);
 876                 display_sec_desc(out_hnd, ACTION_FOOTER   , psdb->sec);
 877         }
 878
 879         free_sec_desc_buf(&psdb);
 880
 881         /* close the key handle */
 882         if ((*key_name) != 0)
 883         {
 884                 res3 = res3 ? do_reg_close(smb_cli, &key_pol) : False;
 885         }
 886
 887         /* close the registry handles */
 888         res  = res  ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
 889
 890         /* close the session */
 891         cli_nt_session_close(smb_cli);
 892
 893         if (res && res3 && res4)
 894         {
 895                 DEBUG(5,("cmd_reg_get_key_sec: query succeeded\n"));
 896         }
 897         else
 898         {
 899                 DEBUG(5,("cmd_reg_get_key_sec: query failed\n"));
 900         }
 901 }