source/rpc_client/cli_reg.c

   1
   2 /*
   3  *  Unix SMB/Netbios implementation.
   4  *  Version 1.9.
   5  *  RPC Pipe client / server routines
   6  *  Copyright (C) Andrew Tridgell              1992-1998,
   7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
   8  *  Copyright (C) Paul Ashton                  1997-1998.
   9  *  Copyright (C) Jeremy Allison                    1999.
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26
  27 #ifdef SYSLOG
  28 #undef SYSLOG
  29 #endif
  30
  31 #include "includes.h"
  32
  33 extern int DEBUGLEVEL;
  34
  35 /****************************************************************************
  36 do a REG Open Policy
  37 ****************************************************************************/
  38 BOOL do_reg_connect(struct cli_state *cli, char *full_keyname, char *key_name,
  39                                 POLICY_HND *reg_hnd)
  40 {
  41         BOOL res = True;
  42         uint32 reg_type = 0;
  43
  44         if (full_keyname == NULL)
  45                 return False;
  46
  47         ZERO_STRUCTP(reg_hnd);
  48
  49         /*
  50          * open registry receive a policy handle
  51          */
  52
  53         if (!reg_split_key(full_keyname, &reg_type, key_name)) {
  54                 DEBUG(0,("do_reg_connect: unrecognised key name %s\n", full_keyname));
  55                 return False;
  56         }
  57
  58         switch (reg_type) {
  59         case HKEY_LOCAL_MACHINE:
  60                 res = res ? do_reg_open_hklm(cli, 0x84E0, 0x02000000, reg_hnd) : False;
  61                 break;
  62
  63         case HKEY_USERS:
  64                 res = res ? do_reg_open_hku(cli, 0x84E0, 0x02000000, reg_hnd) : False;
  65                 break;
  66
  67         default:
  68                 DEBUG(0,("do_reg_connect: unrecognised hive key\n"));
  69                 return False;
  70         }
  71
  72         return res;
  73 }
  74
  75 /****************************************************************************
  76 do a REG Open Policy
  77 ****************************************************************************/
  78 BOOL do_reg_open_hklm(struct cli_state *cli, uint16 unknown_0, uint32 level,
  79                                 POLICY_HND *hnd)
  80 {
  81         prs_struct rbuf;
  82         prs_struct buf;
  83         REG_Q_OPEN_HKLM q_o;
  84         REG_R_OPEN_HKLM r_o;
  85
  86         if (hnd == NULL)
  87                 return False;
  88
  89         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL);
  90         prs_init(&rbuf, 0, 4, UNMARSHALL);
  91
  92         /* create and send a MSRPC command with api REG_OPEN_HKLM */
  93
  94         DEBUG(4,("REG Open HKLM\n"));
  95
  96         init_reg_q_open_hklm(&q_o, unknown_0, level);
  97
  98         /* turn parameters into data stream */
  99         if(!reg_io_q_open_hklm("", &q_o, &buf, 0)) {
 100                 prs_mem_free(&buf);
 101                 prs_mem_free(&rbuf);
 102                 return False;
 103         }
 104
 105         /* send the data on \PIPE\ */
 106         if (!rpc_api_pipe_req(cli, REG_OPEN_HKLM, &buf, &rbuf)) {
 107                 prs_mem_free(&buf);
 108                 prs_mem_free(&rbuf);
 109                 return False;
 110         }
 111
 112         prs_mem_free(&buf);
 113
 114         ZERO_STRUCT(r_o);
 115
 116         if(!reg_io_r_open_hklm("", &r_o, &rbuf, 0)) {
 117                 prs_mem_free(&rbuf);
 118                 return False;
 119         }
 120
 121         if (r_o.status != 0) {
 122                 /* report error code */
 123                 DEBUG(0,("REG_OPEN_HKLM: %s\n", get_nt_error_msg(r_o.status)));
 124                 prs_mem_free(&rbuf);
 125                 return False;
 126         }
 127
 128         /* ok, at last: we're happy. return the policy handle */
 129         memcpy(hnd, r_o.pol.data, sizeof(hnd->data));
 130
 131         prs_mem_free(&rbuf);
 132
 133         return True;
 134 }
 135
 136 /****************************************************************************
 137 do a REG Open HKU
 138 ****************************************************************************/
 139 BOOL do_reg_open_hku(struct cli_state *cli, uint16 unknown_0, uint32 level,
 140                                 POLICY_HND *hnd)
 141 {
 142         prs_struct rbuf;
 143         prs_struct buf;
 144         REG_Q_OPEN_HKU q_o;
 145         REG_R_OPEN_HKU r_o;
 146
 147         if (hnd == NULL)
 148                 return False;
 149
 150         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 151         prs_init(&rbuf, 0, 4, UNMARSHALL);
 152
 153         /* create and send a MSRPC command with api REG_OPEN_HKU */
 154
 155         DEBUG(4,("REG Open HKU\n"));
 156
 157         init_reg_q_open_hku(&q_o, unknown_0, level);
 158
 159         /* turn parameters into data stream */
 160         if(!reg_io_q_open_hku("", &q_o, &buf, 0)) {
 161                 prs_mem_free(&buf);
 162                 prs_mem_free(&rbuf);
 163                 return False;
 164         }
 165
 166         /* send the data on \PIPE\ */
 167         if (rpc_api_pipe_req(cli, REG_OPEN_HKU, &buf, &rbuf)) {
 168                 prs_mem_free(&buf);
 169                 prs_mem_free(&rbuf);
 170                 return False;
 171         }
 172
 173         prs_mem_free(&buf);
 174
 175         ZERO_STRUCT(r_o);
 176
 177         if(!reg_io_r_open_hku("", &r_o, &rbuf, 0)) {
 178                 prs_mem_free(&rbuf);
 179                 return False;
 180         }
 181
 182         if (r_o.status != 0) {
 183                 /* report error code */
 184                 DEBUG(0,("REG_OPEN_HKU: %s\n", get_nt_error_msg(r_o.status)));
 185                 prs_mem_free(&rbuf);
 186                 return False;
 187         }
 188
 189         /* ok, at last: we're happy. return the policy handle */
 190         memcpy(hnd, r_o.pol.data, sizeof(hnd->data));
 191
 192         prs_mem_free(&rbuf);
 193
 194         return True;
 195 }
 196
 197 /****************************************************************************
 198 do a REG Unknown 0xB command.  sent after a create key or create value.
 199 this might be some sort of "sync" or "refresh" command, sent after
 200 modification of the registry...
 201 ****************************************************************************/
 202 BOOL do_reg_flush_key(struct cli_state *cli, POLICY_HND *hnd)
 203 {
 204         prs_struct rbuf;
 205         prs_struct buf;
 206         REG_Q_FLUSH_KEY q_o;
 207         REG_R_FLUSH_KEY r_o;
 208
 209         if (hnd == NULL)
 210                 return False;
 211
 212         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 213         prs_init(&rbuf, 0, 4, UNMARSHALL);
 214
 215         /* create and send a MSRPC command with api REG_FLUSH_KEY */
 216
 217         DEBUG(4,("REG Unknown 0xB\n"));
 218
 219         init_reg_q_flush_key(&q_o, hnd);
 220
 221         /* turn parameters into data stream */
 222         if(!reg_io_q_flush_key("", &q_o, &buf, 0)) {
 223                 prs_mem_free(&buf);
 224                 prs_mem_free(&rbuf);
 225                 return False;
 226         }
 227
 228         /* send the data on \PIPE\ */
 229         if (!rpc_api_pipe_req(cli, REG_FLUSH_KEY, &buf, &rbuf)) {
 230                 prs_mem_free(&buf);
 231                 prs_mem_free(&rbuf);
 232                 return False;
 233         }
 234
 235         prs_mem_free(&buf);
 236
 237         ZERO_STRUCT(r_o);
 238
 239         if(!reg_io_r_flush_key("", &r_o, &rbuf, 0)) {
 240                 prs_mem_free(&rbuf);
 241                 return False;
 242         }
 243
 244         if (r_o.status != 0) {
 245                 /* report error code */
 246                 DEBUG(0,("REG_FLUSH_KEY: %s\n", get_nt_error_msg(r_o.status)));
 247                 prs_mem_free(&rbuf);
 248                 return False;
 249         }
 250
 251         prs_mem_free(&rbuf);
 252
 253         return True;
 254 }
 255
 256 /****************************************************************************
 257 do a REG Query Key
 258 ****************************************************************************/
 259 BOOL do_reg_query_key(struct cli_state *cli, POLICY_HND *hnd,
 260                                 char *class, uint32 *class_len,
 261                                 uint32 *num_subkeys, uint32 *max_subkeylen,
 262                                 uint32 *max_subkeysize, uint32 *num_values,
 263                                 uint32 *max_valnamelen, uint32 *max_valbufsize,
 264                                 uint32 *sec_desc, NTTIME *mod_time)
 265 {
 266         prs_struct rbuf;
 267         prs_struct buf;
 268         REG_Q_QUERY_KEY q_o;
 269         REG_R_QUERY_KEY r_o;
 270
 271         if (hnd == NULL)
 272                 return False;
 273
 274         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 275         prs_init(&rbuf, 0, 4, UNMARSHALL);
 276
 277         /* create and send a MSRPC command with api REG_QUERY_KEY */
 278
 279         DEBUG(4,("REG Query Key\n"));
 280
 281         init_reg_q_query_key(&q_o, hnd, *class_len);
 282
 283         /* turn parameters into data stream */
 284         if(!reg_io_q_query_key("", &q_o, &buf, 0)) {
 285                 prs_mem_free(&buf);
 286                 prs_mem_free(&rbuf);
 287                 return False;
 288         }
 289
 290         /* send the data on \PIPE\ */
 291         if (!rpc_api_pipe_req(cli, REG_QUERY_KEY, &buf, &rbuf)) {
 292                 prs_mem_free(&buf);
 293                 prs_mem_free(&rbuf);
 294                 return False;
 295         }
 296
 297         prs_mem_free(&buf);
 298
 299         ZERO_STRUCT(r_o);
 300
 301         if(!reg_io_r_query_key("", &r_o, &rbuf, 0)) {
 302                 prs_mem_free(&rbuf);
 303                 return False;
 304         }
 305
 306         if (r_o.status != 0) {
 307                 /* report error code */
 308                 DEBUG(0,("REG_QUERY_KEY: %s\n", get_nt_error_msg(r_o.status)));
 309                 prs_mem_free(&rbuf);
 310                 return False;
 311         }
 312
 313         *class_len      = r_o.hdr_class.uni_max_len;
 314         fstrcpy(class, dos_unistr2_to_str(&r_o.uni_class));
 315         *num_subkeys    = r_o.num_subkeys   ;
 316         *max_subkeylen  = r_o.max_subkeylen ;
 317         *max_subkeysize = r_o.max_subkeysize;
 318         *num_values     = r_o.num_values    ;
 319         *max_valnamelen = r_o.max_valnamelen;
 320         *max_valbufsize = r_o.max_valbufsize;
 321         *sec_desc       = r_o.sec_desc      ;
 322         *mod_time       = r_o.mod_time      ;
 323
 324         prs_mem_free(&rbuf);
 325
 326         return True;
 327 }
 328
 329 /****************************************************************************
 330 do a REG Unknown 1A
 331 ****************************************************************************/
 332 BOOL do_reg_unknown_1a(struct cli_state *cli, POLICY_HND *hnd, uint32 *unk)
 333 {
 334         prs_struct rbuf;
 335         prs_struct buf;
 336         REG_Q_UNK_1A q_o;
 337         REG_R_UNK_1A r_o;
 338
 339         if (hnd == NULL)
 340                 return False;
 341
 342         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 343         prs_init(&rbuf, 0, 4, UNMARSHALL);
 344
 345         /* create and send a MSRPC command with api REG_UNKNOWN_1A */
 346
 347         DEBUG(4,("REG Unknown 1a\n"));
 348
 349         init_reg_q_unk_1a(&q_o, hnd);
 350
 351         /* turn parameters into data stream */
 352         if(!reg_io_q_unk_1a("", &q_o, &buf, 0)) {
 353                 prs_mem_free(&buf);
 354                 prs_mem_free(&rbuf);
 355                 return False;
 356         }
 357
 358         /* send the data on \PIPE\ */
 359         if (rpc_api_pipe_req(cli, REG_UNK_1A, &buf, &rbuf)) {
 360                 prs_mem_free(&buf);
 361                 prs_mem_free(&rbuf);
 362                 return False;
 363         }
 364
 365         prs_mem_free(&buf);
 366
 367         ZERO_STRUCT(r_o);
 368
 369         if(!reg_io_r_unk_1a("", &r_o, &rbuf, 0)) {
 370                 prs_mem_free(&rbuf);
 371                 return False;
 372         }
 373
 374         if (r_o.status != 0) {
 375                 /* report error code */
 376                 DEBUG(0,("REG_UNK_1A: %s\n", get_nt_error_msg(r_o.status)));
 377                 prs_mem_free(&rbuf);
 378                 return False;
 379         }
 380
 381         (*unk) = r_o.unknown;
 382
 383         prs_mem_free(&rbuf);
 384
 385         return True;
 386 }
 387
 388 /****************************************************************************
 389 do a REG Query Info
 390 ****************************************************************************/
 391 BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd,
 392                                 char *key_value, uint32* key_type)
 393 {
 394         prs_struct rbuf;
 395         prs_struct buf;
 396         REG_Q_INFO q_o;
 397         REG_R_INFO r_o;
 398
 399         if (hnd == NULL)
 400                 return False;
 401
 402         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 403         prs_init(&rbuf, 0, 4, UNMARSHALL);
 404
 405         /* create and send a MSRPC command with api REG_INFO */
 406
 407         DEBUG(4,("REG Query Info\n"));
 408
 409         init_reg_q_info(&q_o, hnd, "ProductType");
 410
 411         /* turn parameters into data stream */
 412         if(!reg_io_q_info("", &q_o, &buf, 0)) {
 413                 prs_mem_free(&buf);
 414                 prs_mem_free(&rbuf);
 415                 return False;
 416         }
 417
 418         /* send the data on \PIPE\ */
 419         if (!rpc_api_pipe_req(cli, REG_INFO, &buf, &rbuf)) {
 420                 prs_mem_free(&buf);
 421                 prs_mem_free(&rbuf);
 422                 return False;
 423         }
 424
 425         prs_mem_free(&buf);
 426
 427         ZERO_STRUCT(r_o);
 428
 429         if(!reg_io_r_info("", &r_o, &rbuf, 0)) {
 430                 prs_mem_free(&rbuf);
 431                 return False;
 432         }
 433
 434         if ( r_o.status != 0) {
 435                 /* report error code */
 436                 DEBUG(0,("REG_INFO: %s\n", get_nt_error_msg(r_o.status)));
 437                 prs_mem_free(&rbuf);
 438                 return False;
 439         }
 440
 441         fstrcpy(key_value, dos_buffer2_to_str(r_o.uni_val));
 442         *key_type = r_o.type;
 443
 444         prs_mem_free(&rbuf);
 445
 446         return True;
 447 }
 448
 449 /****************************************************************************
 450 do a REG Set Key Security
 451 ****************************************************************************/
 452 BOOL do_reg_set_key_sec(struct cli_state *cli, POLICY_HND *hnd, SEC_DESC_BUF *sec_desc_buf)
 453 {
 454         prs_struct rbuf;
 455         prs_struct buf;
 456         REG_Q_SET_KEY_SEC q_o;
 457         REG_R_SET_KEY_SEC r_o;
 458
 459         if (hnd == NULL)
 460                 return False;
 461
 462         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 463         prs_init(&rbuf, 0, 4, UNMARSHALL);
 464
 465         /* create and send a MSRPC command with api REG_SET_KEY_SEC */
 466
 467         DEBUG(4,("REG Set Key security.\n"));
 468
 469         init_reg_q_set_key_sec(&q_o, hnd, sec_desc_buf);
 470
 471         /* turn parameters into data stream */
 472         if(!reg_io_q_set_key_sec("", &q_o, &buf, 0)) {
 473                 prs_mem_free(&buf);
 474                 prs_mem_free(&rbuf);
 475                 return False;
 476         }
 477
 478         /* send the data on \PIPE\ */
 479         if (!rpc_api_pipe_req(cli, REG_SET_KEY_SEC, &buf, &rbuf)) {
 480                 prs_mem_free(&buf);
 481                 prs_mem_free(&rbuf);
 482                 return False;
 483         }
 484
 485         prs_mem_free(&buf);
 486
 487         ZERO_STRUCT(r_o);
 488
 489         if(!reg_io_r_set_key_sec("", &r_o, &rbuf, 0)) {
 490                 prs_mem_free(&rbuf);
 491                 return False;
 492         }
 493
 494         if (r_o.status != 0) {
 495                 prs_mem_free(&rbuf);
 496                 return False;
 497         }
 498
 499         prs_mem_free(&rbuf);
 500
 501         return True;
 502 }
 503
 504 /****************************************************************************
 505 do a REG Query Key Security
 506 ****************************************************************************/
 507
 508 BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, uint32 *sec_buf_size, SEC_DESC_BUF **ppsec_desc_buf)
 509 {
 510         prs_struct rbuf;
 511         prs_struct buf;
 512         REG_Q_GET_KEY_SEC q_o;
 513         REG_R_GET_KEY_SEC r_o;
 514
 515         if (hnd == NULL)
 516                 return False;
 517
 518         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 519         prs_init(&rbuf, 0, 4, UNMARSHALL);
 520
 521         /* create and send a MSRPC command with api REG_GET_KEY_SEC */
 522
 523         DEBUG(4,("REG query key security.  buf_size: %d\n", *sec_buf_size));
 524
 525         init_reg_q_get_key_sec(&q_o, hnd, *sec_buf_size, NULL);
 526
 527         /* turn parameters into data stream */
 528         if(!reg_io_q_get_key_sec("", &q_o, &buf, 0)) {
 529                 prs_mem_free(&buf);
 530                 prs_mem_free(&rbuf);
 531                 return False;
 532         }
 533
 534         /* send the data on \PIPE\ */
 535         if (!rpc_api_pipe_req(cli, REG_GET_KEY_SEC, &buf, &rbuf)) {
 536                 prs_mem_free(&buf);
 537                 prs_mem_free(&rbuf);
 538                 return False;
 539         }
 540
 541         prs_mem_free(&buf);
 542
 543         ZERO_STRUCT(r_o);
 544
 545         if(!reg_io_r_get_key_sec("", &r_o, &rbuf, 0)) {
 546                 prs_mem_free(&rbuf);
 547                 return False;
 548         }
 549
 550         if (r_o.status == 0x0000007a) {
 551                 /*
 552                  * get the maximum buffer size: it was too small
 553                  */
 554                 (*sec_buf_size) = r_o.hdr_sec.buf_max_len;
 555                 DEBUG(5,("sec_buf_size too small.  use %d\n", *sec_buf_size));
 556         } else if (r_o.status != 0) {
 557                 /* report error code */
 558                 DEBUG(0,("REG_GET_KEY_SEC: %s\n", get_nt_error_msg(r_o.status)));
 559                 prs_mem_free(&rbuf);
 560                 return False;
 561         } else {
 562                 (*sec_buf_size) = r_o.data->len;
 563                 *ppsec_desc_buf = r_o.data;
 564         }
 565
 566         prs_mem_free(&rbuf);
 567
 568         return True;
 569 }
 570
 571 /****************************************************************************
 572 do a REG Delete Value
 573 ****************************************************************************/
 574 BOOL do_reg_delete_val(struct cli_state *cli, POLICY_HND *hnd, char *val_name)
 575 {
 576         prs_struct rbuf;
 577         prs_struct buf;
 578         REG_Q_DELETE_VALUE q_o;
 579         REG_R_DELETE_VALUE r_o;
 580
 581         if (hnd == NULL)
 582                 return False;
 583
 584         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 585         prs_init(&rbuf, 0, 4, UNMARSHALL);
 586
 587         /* create and send a MSRPC command with api REG_DELETE_VALUE */
 588
 589         DEBUG(4,("REG Delete Value: %s\n", val_name));
 590
 591         init_reg_q_delete_val(&q_o, hnd, val_name);
 592
 593         /* turn parameters into data stream */
 594         if(!reg_io_q_delete_val("", &q_o, &buf, 0)) {
 595                 prs_mem_free(&buf);
 596                 prs_mem_free(&rbuf);
 597                 return False;
 598         }
 599
 600         /* send the data on \PIPE\ */
 601         if (rpc_api_pipe_req(cli, REG_DELETE_VALUE, &buf, &rbuf)) {
 602                 prs_mem_free(&buf);
 603                 prs_mem_free(&rbuf);
 604                 return False;
 605         }
 606
 607         prs_mem_free(&buf);
 608
 609         ZERO_STRUCT(r_o);
 610
 611         if(!reg_io_r_delete_val("", &r_o, &rbuf, 0)) {
 612                 prs_mem_free(&rbuf);
 613                 return False;
 614         }
 615
 616         if (r_o.status != 0) {
 617                 /* report error code */
 618                 DEBUG(0,("REG_DELETE_VALUE: %s\n", get_nt_error_msg(r_o.status)));
 619                 prs_mem_free(&rbuf);
 620                 return False;
 621         }
 622
 623         prs_mem_free(&rbuf);
 624
 625         return True;
 626 }
 627
 628 /****************************************************************************
 629 do a REG Delete Key
 630 ****************************************************************************/
 631 BOOL do_reg_delete_key(struct cli_state *cli, POLICY_HND *hnd, char *key_name)
 632 {
 633         prs_struct rbuf;
 634         prs_struct buf;
 635         REG_Q_DELETE_KEY q_o;
 636         REG_R_DELETE_KEY r_o;
 637
 638         if (hnd == NULL)
 639                 return False;
 640
 641         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 642         prs_init(&rbuf, 0, 4, UNMARSHALL);
 643
 644         /* create and send a MSRPC command with api REG_DELETE_KEY */
 645
 646         DEBUG(4,("REG Delete Key: %s\n", key_name));
 647
 648         init_reg_q_delete_key(&q_o, hnd, key_name);
 649
 650         /* turn parameters into data stream */
 651         if(!reg_io_q_delete_key("", &q_o, &buf, 0)) {
 652                 prs_mem_free(&buf);
 653                 prs_mem_free(&rbuf);
 654                 return False;
 655         }
 656
 657         /* send the data on \PIPE\ */
 658         if (!rpc_api_pipe_req(cli, REG_DELETE_KEY, &buf, &rbuf)) {
 659                 prs_mem_free(&buf);
 660                 prs_mem_free(&rbuf);
 661                 return False;
 662         }
 663
 664         prs_mem_free(&buf);
 665
 666         ZERO_STRUCT(r_o);
 667
 668         if(!reg_io_r_delete_key("", &r_o, &rbuf, 0)) {
 669                 prs_mem_free(&rbuf);
 670                 return False;
 671         }
 672
 673         if (r_o.status != 0) {
 674                 /* report error code */
 675                 DEBUG(0,("REG_DELETE_KEY: %s\n", get_nt_error_msg(r_o.status)));
 676                 prs_mem_free(&rbuf);
 677                 return False;
 678         }
 679
 680         prs_mem_free(&rbuf);
 681
 682         return True;
 683 }
 684
 685 /****************************************************************************
 686 do a REG Create Key
 687 ****************************************************************************/
 688 BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd,
 689                                 char *key_name, char *key_class,
 690                                 SEC_ACCESS *sam_access,
 691                                 POLICY_HND *key)
 692 {
 693         prs_struct rbuf;
 694         prs_struct buf;
 695         REG_Q_CREATE_KEY q_o;
 696         REG_R_CREATE_KEY r_o;
 697         SEC_DESC *sec = NULL;
 698         SEC_DESC_BUF *sec_buf = NULL;
 699         size_t sec_len;
 700
 701         ZERO_STRUCT(q_o);
 702
 703         if (hnd == NULL)
 704                 return False;
 705
 706         /* create and send a MSRPC command with api REG_CREATE_KEY */
 707
 708         DEBUG(4,("REG Create Key: %s %s 0x%08x\n", key_name, key_class,
 709                 sam_access != NULL ? sam_access->mask : 0));
 710
 711         if((sec = make_sec_desc( 1, SEC_DESC_SELF_RELATIVE, NULL, NULL, NULL, NULL, &sec_len)) == NULL) {
 712                 DEBUG(0,("make_sec_desc : malloc fail.\n"));
 713                 return False;
 714         }
 715
 716         DEBUG(10,("make_sec_desc: len = %d\n", (int)sec_len));
 717
 718         if((sec_buf = make_sec_desc_buf( (int)sec_len, sec)) == NULL) {
 719                 DEBUG(0,("make_sec_desc : malloc fail (1)\n"));
 720                 free_sec_desc(&sec);
 721                 return False;
 722         }
 723         free_sec_desc(&sec);
 724
 725         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL);
 726         prs_init(&rbuf, 0, 4, UNMARSHALL);
 727
 728         init_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access, sec_buf);
 729
 730         /* turn parameters into data stream */
 731         if(!reg_io_q_create_key("", &q_o, &buf, 0)) {
 732                 free_sec_desc_buf(&sec_buf);
 733                 prs_mem_free(&buf);
 734                 prs_mem_free(&rbuf);
 735                 return False;
 736         }
 737
 738         /* send the data on \PIPE\ */
 739         if (rpc_api_pipe_req(cli, REG_CREATE_KEY, &buf, &rbuf)) {
 740                 free_sec_desc_buf(&sec_buf);
 741                 prs_mem_free(&buf);
 742                 prs_mem_free(&rbuf);
 743                 return False;
 744         }
 745
 746         free_sec_desc_buf(&sec_buf);
 747         prs_mem_free(&buf);
 748
 749         ZERO_STRUCT(r_o);
 750
 751         if(!reg_io_r_create_key("", &r_o, &rbuf, 0)) {
 752                 prs_mem_free(&rbuf);
 753                 return False;
 754         }
 755
 756         if (r_o.status != 0) {
 757                 /* report error code */
 758                 DEBUG(0,("REG_CREATE_KEY: %s\n", get_nt_error_msg(r_o.status)));
 759                 prs_mem_free(&rbuf);
 760                 return False;
 761         }
 762
 763         memcpy(key, r_o.key_pol.data, sizeof(key->data));
 764
 765         prs_mem_free(&rbuf);
 766
 767         return True;
 768 }
 769
 770 /****************************************************************************
 771 do a REG Enum Key
 772 ****************************************************************************/
 773 BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd,
 774                                 int key_index, char *key_name,
 775                                 uint32 *unk_1, uint32 *unk_2,
 776                                 time_t *mod_time)
 777 {
 778         prs_struct rbuf;
 779         prs_struct buf;
 780         REG_Q_ENUM_KEY q_o;
 781         REG_R_ENUM_KEY r_o;
 782
 783         if (hnd == NULL)
 784                 return False;
 785
 786         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL);
 787         prs_init(&rbuf, 0, 4, UNMARSHALL);
 788
 789         /* create and send a MSRPC command with api REG_ENUM_KEY */
 790
 791         DEBUG(4,("REG Enum Key\n"));
 792
 793         init_reg_q_enum_key(&q_o, hnd, key_index);
 794
 795         /* turn parameters into data stream */
 796         if(!reg_io_q_enum_key("", &q_o, &buf, 0)) {
 797                 prs_mem_free(&buf);
 798                 prs_mem_free(&rbuf);
 799                 return False;
 800         }
 801
 802         /* send the data on \PIPE\ */
 803         if (!rpc_api_pipe_req(cli, REG_ENUM_KEY, &buf, &rbuf)) {
 804                 prs_mem_free(&buf);
 805                 prs_mem_free(&rbuf);
 806                 return False;
 807         }
 808
 809         prs_mem_free(&buf);
 810
 811         ZERO_STRUCT(r_o);
 812
 813         if(!reg_io_r_enum_key("", &r_o, &rbuf, 0)) {
 814                 prs_mem_free(&rbuf);
 815                 return False;
 816         }
 817
 818         if (r_o.status != 0) {
 819                 /* report error code */
 820                 DEBUG(0,("REG_ENUM_KEY: %s\n", get_nt_error_msg(r_o.status)));
 821                 prs_mem_free(&rbuf);
 822                 return False;
 823         }
 824
 825         (*unk_1) = r_o.unknown_1;
 826         (*unk_2) = r_o.unknown_2;
 827         fstrcpy(key_name, dos_unistr2(r_o.key_name.str.buffer));
 828         (*mod_time) = nt_time_to_unix(&r_o.time);
 829
 830         prs_mem_free(&rbuf);
 831
 832         return True;
 833 }
 834
 835 /****************************************************************************
 836 do a REG Create Value
 837 ****************************************************************************/
 838 BOOL do_reg_create_val(struct cli_state *cli, POLICY_HND *hnd,
 839                                 char *val_name, uint32 type, BUFFER3 *data)
 840 {
 841         prs_struct rbuf;
 842         prs_struct buf;
 843         REG_Q_CREATE_VALUE q_o;
 844         REG_R_CREATE_VALUE r_o;
 845
 846         if (hnd == NULL)
 847                 return False;
 848
 849         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL);
 850         prs_init(&rbuf, 0, 4, UNMARSHALL);
 851
 852         /* create and send a MSRPC command with api REG_CREATE_VALUE */
 853
 854         DEBUG(4,("REG Create Value: %s\n", val_name));
 855
 856         init_reg_q_create_val(&q_o, hnd, val_name, type, data);
 857
 858         /* turn parameters into data stream */
 859         if(!reg_io_q_create_val("", &q_o, &buf, 0)) {
 860                 prs_mem_free(&buf);
 861                 prs_mem_free(&rbuf);
 862                 return False;
 863         }
 864
 865         /* send the data on \PIPE\ */
 866         if (!rpc_api_pipe_req(cli, REG_CREATE_VALUE, &buf, &rbuf)) {
 867                 prs_mem_free(&buf);
 868                 prs_mem_free(&rbuf);
 869                 return False;
 870         }
 871
 872         prs_mem_free(&buf);
 873
 874         ZERO_STRUCT(r_o);
 875
 876         if(!reg_io_r_create_val("", &r_o, &rbuf, 0)) {
 877                 prs_mem_free(&rbuf);
 878                 return False;
 879         }
 880
 881         if (r_o.status != 0) {
 882                 /* report error code */
 883                 DEBUG(0,("REG_CREATE_VALUE: %s\n", get_nt_error_msg(r_o.status)));
 884                 prs_mem_free(&rbuf);
 885                 return False;
 886         }
 887
 888         prs_mem_free(&rbuf);
 889
 890         return True;
 891 }
 892
 893 /****************************************************************************
 894 do a REG Enum Value
 895 ****************************************************************************/
 896 BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd,
 897                                 int val_index, int max_valnamelen, int max_valbufsize,
 898                                 fstring val_name,
 899                                 uint32 *val_type, BUFFER2 *value)
 900 {
 901         prs_struct rbuf;
 902         prs_struct buf;
 903         REG_Q_ENUM_VALUE q_o;
 904         REG_R_ENUM_VALUE r_o;
 905
 906         if (hnd == NULL)
 907                 return False;
 908
 909         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL);
 910         prs_init(&rbuf, 0, 4, UNMARSHALL);
 911
 912         /* create and send a MSRPC command with api REG_ENUM_VALUE */
 913
 914         DEBUG(4,("REG Enum Value\n"));
 915
 916         init_reg_q_enum_val(&q_o, hnd, val_index, max_valnamelen, max_valbufsize);
 917
 918         /* turn parameters into data stream */
 919         if(!reg_io_q_enum_val("", &q_o, &buf, 0)) {
 920                 prs_mem_free(&buf);
 921                 prs_mem_free(&rbuf);
 922                 return False;
 923         }
 924
 925         /* send the data on \PIPE\ */
 926         if (!rpc_api_pipe_req(cli, REG_ENUM_VALUE, &buf, &rbuf)) {
 927                 prs_mem_free(&buf);
 928                 prs_mem_free(&rbuf);
 929                 return False;
 930         }
 931
 932         prs_mem_free(&buf);
 933
 934         ZERO_STRUCT(r_o);
 935         r_o.buf_value = value;
 936
 937         if(!reg_io_r_enum_val("", &r_o, &rbuf, 0)) {
 938                 prs_mem_free(&rbuf);
 939                 return False;
 940         }
 941
 942         if (r_o.status != 0) {
 943                 /* report error code */
 944                 DEBUG(0,("REG_ENUM_VALUE: %s\n", get_nt_error_msg(r_o.status)));
 945                 prs_mem_free(&rbuf);
 946                 return False;
 947         }
 948
 949         (*val_type) = r_o.type;
 950         fstrcpy(val_name, dos_unistr2_to_str(&r_o.uni_name));
 951
 952         prs_mem_free(&rbuf);
 953
 954         return True;
 955 }
 956
 957 /****************************************************************************
 958 do a REG Open Key
 959 ****************************************************************************/
 960 BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd,
 961                                 char *key_name, uint32 unk_0,
 962                                 POLICY_HND *key_hnd)
 963 {
 964         prs_struct rbuf;
 965         prs_struct buf;
 966         REG_Q_OPEN_ENTRY q_o;
 967         REG_R_OPEN_ENTRY r_o;
 968
 969         if (hnd == NULL)
 970                 return False;
 971
 972         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL);
 973         prs_init(&rbuf, 0, 4, UNMARSHALL);
 974
 975         /* create and send a MSRPC command with api REG_OPEN_ENTRY */
 976
 977         DEBUG(4,("REG Open Entry\n"));
 978
 979         init_reg_q_open_entry(&q_o, hnd, key_name, unk_0);
 980
 981         /* turn parameters into data stream */
 982         if(!reg_io_q_open_entry("", &q_o, &buf, 0)) {
 983                 prs_mem_free(&buf);
 984                 prs_mem_free(&rbuf);
 985                 return False;
 986         }
 987
 988         /* send the data on \PIPE\ */
 989         if (!rpc_api_pipe_req(cli, REG_OPEN_ENTRY, &buf, &rbuf)) {
 990                 prs_mem_free(&buf);
 991                 prs_mem_free(&rbuf);
 992                 return False;
 993         }
 994
 995         prs_mem_free(&buf);
 996
 997         ZERO_STRUCT(r_o);
 998
 999         if(!reg_io_r_open_entry("", &r_o, &rbuf, 0)) {
1000                 prs_mem_free(&rbuf);
1001                 return False;
1002         }
1003
1004         if (r_o.status != 0) {
1005                 /* report error code */
1006                 DEBUG(0,("REG_OPEN_ENTRY: %s\n", get_nt_error_msg(r_o.status)));
1007                 prs_mem_free(&rbuf);
1008                 return False;
1009         }
1010
1011         memcpy(key_hnd, r_o.pol.data, sizeof(key_hnd->data));
1012
1013         prs_mem_free(&rbuf);
1014
1015         return True;
1016 }
1017
1018 /****************************************************************************
1019 do a REG Close
1020 ****************************************************************************/
1021 BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd)
1022 {
1023         prs_struct rbuf;
1024         prs_struct buf;
1025         REG_Q_CLOSE q_c;
1026         REG_R_CLOSE r_c;
1027         int i;
1028
1029         if (hnd == NULL)
1030                 return False;
1031
1032         /* create and send a MSRPC command with api REG_CLOSE */
1033
1034         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL);
1035         prs_init(&rbuf, 0, 4, UNMARSHALL);
1036
1037         DEBUG(4,("REG Close\n"));
1038
1039         /* store the parameters */
1040         init_reg_q_close(&q_c, hnd);
1041
1042         /* turn parameters into data stream */
1043         if(!reg_io_q_close("", &q_c, &buf, 0)) {
1044                 prs_mem_free(&buf);
1045                 prs_mem_free(&rbuf);
1046                 return False;
1047         }
1048
1049         /* send the data on \PIPE\ */
1050         if (!rpc_api_pipe_req(cli, REG_CLOSE, &buf, &rbuf)) {
1051                 prs_mem_free(&buf);
1052                 prs_mem_free(&rbuf);
1053                 return False;
1054         }
1055
1056         prs_mem_free(&buf);
1057
1058         ZERO_STRUCT(r_c);
1059
1060         if(!reg_io_r_close("", &r_c, &rbuf, 0)) {
1061                 prs_mem_free(&rbuf);
1062                 return False;
1063         }
1064
1065         if (r_c.status != 0) {
1066                 /* report error code */
1067                 DEBUG(0,("REG_CLOSE: %s\n", get_nt_error_msg(r_c.status)));
1068                 prs_mem_free(&rbuf);
1069                 return False;
1070         }
1071
1072         /* check that the returned policy handle is all zeros */
1073
1074         for (i = 0; i < sizeof(r_c.pol.data); i++) {
1075                 if (r_c.pol.data[i] != 0) {
1076                         prs_mem_free(&rbuf);
1077                         DEBUG(0,("REG_CLOSE: non-zero handle returned\n"));
1078                         return False;
1079                 }
1080         }
1081
1082         prs_mem_free(&rbuf);
1083
1084         return True;
1085 }