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