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