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, cli->mem_ctx, MARSHALL);
  90         prs_init(&rbuf, 0, 4, cli->mem_ctx, 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, cli->mem_ctx, MARSHALL);
 151         prs_init(&rbuf, 0, 4, cli->mem_ctx, 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, cli->mem_ctx, MARSHALL);
 213         prs_init(&rbuf, 0, 4, cli->mem_ctx, 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, cli->mem_ctx, MARSHALL);
 275         prs_init(&rbuf, 0, 4, cli->mem_ctx, 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, cli->mem_ctx, MARSHALL);
 343         prs_init(&rbuf, 0, 4, cli->mem_ctx, 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, cli->mem_ctx, MARSHALL);
 403         prs_init(&rbuf, 0, 4, cli->mem_ctx, 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, cli->mem_ctx, MARSHALL);
 463         prs_init(&rbuf, 0, 4, cli->mem_ctx, 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, cli->mem_ctx, MARSHALL);
 519         prs_init(&rbuf, 0, 4, cli->mem_ctx, 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, cli->mem_ctx, MARSHALL);
 585         prs_init(&rbuf, 0, 4, cli->mem_ctx, 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, cli->mem_ctx, MARSHALL);
 642         prs_init(&rbuf, 0, 4, cli->mem_ctx, 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( cli->mem_ctx, 1, 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( cli->mem_ctx, (int)sec_len, sec)) == NULL) {
 719                 DEBUG(0,("make_sec_desc : malloc fail (1)\n"));
 720                 return False;
 721         }
 722
 723         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL);
 724         prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL);
 725
 726         init_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access, sec_buf);
 727
 728         /* turn parameters into data stream */
 729         if(!reg_io_q_create_key("", &q_o, &buf, 0)) {
 730                 prs_mem_free(&buf);
 731                 prs_mem_free(&rbuf);
 732                 return False;
 733         }
 734
 735         /* send the data on \PIPE\ */
 736         if (rpc_api_pipe_req(cli, REG_CREATE_KEY, &buf, &rbuf)) {
 737                 prs_mem_free(&buf);
 738                 prs_mem_free(&rbuf);
 739                 return False;
 740         }
 741
 742         prs_mem_free(&buf);
 743
 744         ZERO_STRUCT(r_o);
 745
 746         if(!reg_io_r_create_key("", &r_o, &rbuf, 0)) {
 747                 prs_mem_free(&rbuf);
 748                 return False;
 749         }
 750
 751         if (r_o.status != 0) {
 752                 /* report error code */
 753                 DEBUG(0,("REG_CREATE_KEY: %s\n", get_nt_error_msg(r_o.status)));
 754                 prs_mem_free(&rbuf);
 755                 return False;
 756         }
 757
 758         memcpy(key, r_o.key_pol.data, sizeof(key->data));
 759
 760         prs_mem_free(&rbuf);
 761
 762         return True;
 763 }
 764
 765 /****************************************************************************
 766 do a REG Enum Key
 767 ****************************************************************************/
 768 BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd,
 769                                 int key_index, char *key_name,
 770                                 uint32 *unk_1, uint32 *unk_2,
 771                                 time_t *mod_time)
 772 {
 773         prs_struct rbuf;
 774         prs_struct buf;
 775         REG_Q_ENUM_KEY q_o;
 776         REG_R_ENUM_KEY r_o;
 777
 778         if (hnd == NULL)
 779                 return False;
 780
 781         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL);
 782         prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL);
 783
 784         /* create and send a MSRPC command with api REG_ENUM_KEY */
 785
 786         DEBUG(4,("REG Enum Key\n"));
 787
 788         init_reg_q_enum_key(&q_o, hnd, key_index);
 789
 790         /* turn parameters into data stream */
 791         if(!reg_io_q_enum_key("", &q_o, &buf, 0)) {
 792                 prs_mem_free(&buf);
 793                 prs_mem_free(&rbuf);
 794                 return False;
 795         }
 796
 797         /* send the data on \PIPE\ */
 798         if (!rpc_api_pipe_req(cli, REG_ENUM_KEY, &buf, &rbuf)) {
 799                 prs_mem_free(&buf);
 800                 prs_mem_free(&rbuf);
 801                 return False;
 802         }
 803
 804         prs_mem_free(&buf);
 805
 806         ZERO_STRUCT(r_o);
 807
 808         if(!reg_io_r_enum_key("", &r_o, &rbuf, 0)) {
 809                 prs_mem_free(&rbuf);
 810                 return False;
 811         }
 812
 813         if (r_o.status != 0) {
 814                 /* report error code */
 815                 DEBUG(0,("REG_ENUM_KEY: %s\n", get_nt_error_msg(r_o.status)));
 816                 prs_mem_free(&rbuf);
 817                 return False;
 818         }
 819
 820         (*unk_1) = r_o.unknown_1;
 821         (*unk_2) = r_o.unknown_2;
 822         fstrcpy(key_name, dos_unistr2(r_o.key_name.str.buffer));
 823         (*mod_time) = nt_time_to_unix(&r_o.time);
 824
 825         prs_mem_free(&rbuf);
 826
 827         return True;
 828 }
 829
 830 /****************************************************************************
 831 do a REG Create Value
 832 ****************************************************************************/
 833 BOOL do_reg_create_val(struct cli_state *cli, POLICY_HND *hnd,
 834                                 char *val_name, uint32 type, BUFFER3 *data)
 835 {
 836         prs_struct rbuf;
 837         prs_struct buf;
 838         REG_Q_CREATE_VALUE q_o;
 839         REG_R_CREATE_VALUE r_o;
 840
 841         if (hnd == NULL)
 842                 return False;
 843
 844         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL);
 845         prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL);
 846
 847         /* create and send a MSRPC command with api REG_CREATE_VALUE */
 848
 849         DEBUG(4,("REG Create Value: %s\n", val_name));
 850
 851         init_reg_q_create_val(&q_o, hnd, val_name, type, data);
 852
 853         /* turn parameters into data stream */
 854         if(!reg_io_q_create_val("", &q_o, &buf, 0)) {
 855                 prs_mem_free(&buf);
 856                 prs_mem_free(&rbuf);
 857                 return False;
 858         }
 859
 860         /* send the data on \PIPE\ */
 861         if (!rpc_api_pipe_req(cli, REG_CREATE_VALUE, &buf, &rbuf)) {
 862                 prs_mem_free(&buf);
 863                 prs_mem_free(&rbuf);
 864                 return False;
 865         }
 866
 867         prs_mem_free(&buf);
 868
 869         ZERO_STRUCT(r_o);
 870
 871         if(!reg_io_r_create_val("", &r_o, &rbuf, 0)) {
 872                 prs_mem_free(&rbuf);
 873                 return False;
 874         }
 875
 876         if (r_o.status != 0) {
 877                 /* report error code */
 878                 DEBUG(0,("REG_CREATE_VALUE: %s\n", get_nt_error_msg(r_o.status)));
 879                 prs_mem_free(&rbuf);
 880                 return False;
 881         }
 882
 883         prs_mem_free(&rbuf);
 884
 885         return True;
 886 }
 887
 888 /****************************************************************************
 889 do a REG Enum Value
 890 ****************************************************************************/
 891 BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd,
 892                                 int val_index, int max_valnamelen, int max_valbufsize,
 893                                 fstring val_name,
 894                                 uint32 *val_type, BUFFER2 *value)
 895 {
 896         prs_struct rbuf;
 897         prs_struct buf;
 898         REG_Q_ENUM_VALUE q_o;
 899         REG_R_ENUM_VALUE r_o;
 900
 901         if (hnd == NULL)
 902                 return False;
 903
 904         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL);
 905         prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL);
 906
 907         /* create and send a MSRPC command with api REG_ENUM_VALUE */
 908
 909         DEBUG(4,("REG Enum Value\n"));
 910
 911         init_reg_q_enum_val(&q_o, hnd, val_index, max_valnamelen, max_valbufsize);
 912
 913         /* turn parameters into data stream */
 914         if(!reg_io_q_enum_val("", &q_o, &buf, 0)) {
 915                 prs_mem_free(&buf);
 916                 prs_mem_free(&rbuf);
 917                 return False;
 918         }
 919
 920         /* send the data on \PIPE\ */
 921         if (!rpc_api_pipe_req(cli, REG_ENUM_VALUE, &buf, &rbuf)) {
 922                 prs_mem_free(&buf);
 923                 prs_mem_free(&rbuf);
 924                 return False;
 925         }
 926
 927         prs_mem_free(&buf);
 928
 929         ZERO_STRUCT(r_o);
 930         r_o.buf_value = value;
 931
 932         if(!reg_io_r_enum_val("", &r_o, &rbuf, 0)) {
 933                 prs_mem_free(&rbuf);
 934                 return False;
 935         }
 936
 937         if (r_o.status != 0) {
 938                 /* report error code */
 939                 DEBUG(0,("REG_ENUM_VALUE: %s\n", get_nt_error_msg(r_o.status)));
 940                 prs_mem_free(&rbuf);
 941                 return False;
 942         }
 943
 944         (*val_type) = r_o.type;
 945         fstrcpy(val_name, dos_unistr2_to_str(&r_o.uni_name));
 946
 947         prs_mem_free(&rbuf);
 948
 949         return True;
 950 }
 951
 952 /****************************************************************************
 953 do a REG Open Key
 954 ****************************************************************************/
 955 BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd,
 956                                 char *key_name, uint32 unk_0,
 957                                 POLICY_HND *key_hnd)
 958 {
 959         prs_struct rbuf;
 960         prs_struct buf;
 961         REG_Q_OPEN_ENTRY q_o;
 962         REG_R_OPEN_ENTRY r_o;
 963
 964         if (hnd == NULL)
 965                 return False;
 966
 967         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL);
 968         prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL);
 969
 970         /* create and send a MSRPC command with api REG_OPEN_ENTRY */
 971
 972         DEBUG(4,("REG Open Entry\n"));
 973
 974         init_reg_q_open_entry(&q_o, hnd, key_name, unk_0);
 975
 976         /* turn parameters into data stream */
 977         if(!reg_io_q_open_entry("", &q_o, &buf, 0)) {
 978                 prs_mem_free(&buf);
 979                 prs_mem_free(&rbuf);
 980                 return False;
 981         }
 982
 983         /* send the data on \PIPE\ */
 984         if (!rpc_api_pipe_req(cli, REG_OPEN_ENTRY, &buf, &rbuf)) {
 985                 prs_mem_free(&buf);
 986                 prs_mem_free(&rbuf);
 987                 return False;
 988         }
 989
 990         prs_mem_free(&buf);
 991
 992         ZERO_STRUCT(r_o);
 993
 994         if(!reg_io_r_open_entry("", &r_o, &rbuf, 0)) {
 995                 prs_mem_free(&rbuf);
 996                 return False;
 997         }
 998
 999         if (r_o.status != 0) {
1000                 /* report error code */
1001                 DEBUG(0,("REG_OPEN_ENTRY: %s\n", get_nt_error_msg(r_o.status)));
1002                 prs_mem_free(&rbuf);
1003                 return False;
1004         }
1005
1006         memcpy(key_hnd, r_o.pol.data, sizeof(key_hnd->data));
1007
1008         prs_mem_free(&rbuf);
1009
1010         return True;
1011 }
1012
1013 /****************************************************************************
1014 do a REG Close
1015 ****************************************************************************/
1016 BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd)
1017 {
1018         prs_struct rbuf;
1019         prs_struct buf;
1020         REG_Q_CLOSE q_c;
1021         REG_R_CLOSE r_c;
1022         int i;
1023
1024         if (hnd == NULL)
1025                 return False;
1026
1027         /* create and send a MSRPC command with api REG_CLOSE */
1028
1029         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL);
1030         prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL);
1031
1032         DEBUG(4,("REG Close\n"));
1033
1034         /* store the parameters */
1035         init_reg_q_close(&q_c, hnd);
1036
1037         /* turn parameters into data stream */
1038         if(!reg_io_q_close("", &q_c, &buf, 0)) {
1039                 prs_mem_free(&buf);
1040                 prs_mem_free(&rbuf);
1041                 return False;
1042         }
1043
1044         /* send the data on \PIPE\ */
1045         if (!rpc_api_pipe_req(cli, REG_CLOSE, &buf, &rbuf)) {
1046                 prs_mem_free(&buf);
1047                 prs_mem_free(&rbuf);
1048                 return False;
1049         }
1050
1051         prs_mem_free(&buf);
1052
1053         ZERO_STRUCT(r_c);
1054
1055         if(!reg_io_r_close("", &r_c, &rbuf, 0)) {
1056                 prs_mem_free(&rbuf);
1057                 return False;
1058         }
1059
1060         if (r_c.status != 0) {
1061                 /* report error code */
1062                 DEBUG(0,("REG_CLOSE: %s\n", get_nt_error_msg(r_c.status)));
1063                 prs_mem_free(&rbuf);
1064                 return False;
1065         }
1066
1067         /* check that the returned policy handle is all zeros */
1068
1069         for (i = 0; i < sizeof(r_c.pol.data); i++) {
1070                 if (r_c.pol.data[i] != 0) {
1071                         prs_mem_free(&rbuf);
1072                         DEBUG(0,("REG_CLOSE: non-zero handle returned\n"));
1073                         return False;
1074                 }
1075         }
1076
1077         prs_mem_free(&rbuf);
1078
1079         return True;
1080 }