release/src/router/samba/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 *type, uint32 *unk_0, uint32 *unk_1)
 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", time(NULL), 4, 1);
 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(type, dos_buffer2_to_str(&r_o.uni_type));
 442         (*unk_0) = r_o.unknown_0;
 443         (*unk_1) = r_o.unknown_1;
 444
 445         prs_mem_free(&rbuf);
 446
 447         return True;
 448 }
 449
 450 /****************************************************************************
 451 do a REG Set Key Security
 452 ****************************************************************************/
 453 BOOL do_reg_set_key_sec(struct cli_state *cli, POLICY_HND *hnd, SEC_DESC_BUF *sec_desc_buf)
 454 {
 455         prs_struct rbuf;
 456         prs_struct buf;
 457         REG_Q_SET_KEY_SEC q_o;
 458         REG_R_SET_KEY_SEC r_o;
 459
 460         if (hnd == NULL)
 461                 return False;
 462
 463         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 464         prs_init(&rbuf, 0, 4, UNMARSHALL);
 465
 466         /* create and send a MSRPC command with api REG_SET_KEY_SEC */
 467
 468         DEBUG(4,("REG Set Key security.\n"));
 469
 470         init_reg_q_set_key_sec(&q_o, hnd, sec_desc_buf);
 471
 472         /* turn parameters into data stream */
 473         if(!reg_io_q_set_key_sec("", &q_o, &buf, 0)) {
 474                 prs_mem_free(&buf);
 475                 prs_mem_free(&rbuf);
 476                 return False;
 477         }
 478
 479         /* send the data on \PIPE\ */
 480         if (!rpc_api_pipe_req(cli, REG_SET_KEY_SEC, &buf, &rbuf)) {
 481                 prs_mem_free(&buf);
 482                 prs_mem_free(&rbuf);
 483                 return False;
 484         }
 485
 486         prs_mem_free(&buf);
 487
 488         ZERO_STRUCT(r_o);
 489
 490         if(!reg_io_r_set_key_sec("", &r_o, &rbuf, 0)) {
 491                 prs_mem_free(&rbuf);
 492                 return False;
 493         }
 494
 495         if (r_o.status != 0) {
 496                 prs_mem_free(&rbuf);
 497                 return False;
 498         }
 499
 500         prs_mem_free(&rbuf);
 501
 502         return True;
 503 }
 504
 505 /****************************************************************************
 506 do a REG Query Key Security
 507 ****************************************************************************/
 508
 509 BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, uint32 *sec_buf_size, SEC_DESC_BUF **ppsec_desc_buf)
 510 {
 511         prs_struct rbuf;
 512         prs_struct buf;
 513         REG_Q_GET_KEY_SEC q_o;
 514         REG_R_GET_KEY_SEC r_o;
 515
 516         if (hnd == NULL)
 517                 return False;
 518
 519         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 520         prs_init(&rbuf, 0, 4, UNMARSHALL);
 521
 522         /* create and send a MSRPC command with api REG_GET_KEY_SEC */
 523
 524         DEBUG(4,("REG query key security.  buf_size: %d\n", *sec_buf_size));
 525
 526         init_reg_q_get_key_sec(&q_o, hnd, *sec_buf_size, NULL);
 527
 528         /* turn parameters into data stream */
 529         if(!reg_io_q_get_key_sec("", &q_o, &buf, 0)) {
 530                 prs_mem_free(&buf);
 531                 prs_mem_free(&rbuf);
 532                 return False;
 533         }
 534
 535         /* send the data on \PIPE\ */
 536         if (!rpc_api_pipe_req(cli, REG_GET_KEY_SEC, &buf, &rbuf)) {
 537                 prs_mem_free(&buf);
 538                 prs_mem_free(&rbuf);
 539                 return False;
 540         }
 541
 542         prs_mem_free(&buf);
 543
 544         ZERO_STRUCT(r_o);
 545
 546         if(!reg_io_r_get_key_sec("", &r_o, &rbuf, 0)) {
 547                 prs_mem_free(&rbuf);
 548                 return False;
 549         }
 550
 551         if (r_o.status == 0x0000007a) {
 552                 /*
 553                  * get the maximum buffer size: it was too small
 554                  */
 555                 (*sec_buf_size) = r_o.hdr_sec.buf_max_len;
 556                 DEBUG(5,("sec_buf_size too small.  use %d\n", *sec_buf_size));
 557         } else if (r_o.status != 0) {
 558                 /* report error code */
 559                 DEBUG(0,("REG_GET_KEY_SEC: %s\n", get_nt_error_msg(r_o.status)));
 560                 prs_mem_free(&rbuf);
 561                 return False;
 562         } else {
 563                 (*sec_buf_size) = r_o.data->len;
 564                 *ppsec_desc_buf = r_o.data;
 565         }
 566
 567         prs_mem_free(&rbuf);
 568
 569         return True;
 570 }
 571
 572 /****************************************************************************
 573 do a REG Delete Value
 574 ****************************************************************************/
 575 BOOL do_reg_delete_val(struct cli_state *cli, POLICY_HND *hnd, char *val_name)
 576 {
 577         prs_struct rbuf;
 578         prs_struct buf;
 579         REG_Q_DELETE_VALUE q_o;
 580         REG_R_DELETE_VALUE r_o;
 581
 582         if (hnd == NULL)
 583                 return False;
 584
 585         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 586         prs_init(&rbuf, 0, 4, UNMARSHALL);
 587
 588         /* create and send a MSRPC command with api REG_DELETE_VALUE */
 589
 590         DEBUG(4,("REG Delete Value: %s\n", val_name));
 591
 592         init_reg_q_delete_val(&q_o, hnd, val_name);
 593
 594         /* turn parameters into data stream */
 595         if(!reg_io_q_delete_val("", &q_o, &buf, 0)) {
 596                 prs_mem_free(&buf);
 597                 prs_mem_free(&rbuf);
 598                 return False;
 599         }
 600
 601         /* send the data on \PIPE\ */
 602         if (rpc_api_pipe_req(cli, REG_DELETE_VALUE, &buf, &rbuf)) {
 603                 prs_mem_free(&buf);
 604                 prs_mem_free(&rbuf);
 605                 return False;
 606         }
 607
 608         prs_mem_free(&buf);
 609
 610         ZERO_STRUCT(r_o);
 611
 612         if(!reg_io_r_delete_val("", &r_o, &rbuf, 0)) {
 613                 prs_mem_free(&rbuf);
 614                 return False;
 615         }
 616
 617         if (r_o.status != 0) {
 618                 /* report error code */
 619                 DEBUG(0,("REG_DELETE_VALUE: %s\n", get_nt_error_msg(r_o.status)));
 620                 prs_mem_free(&rbuf);
 621                 return False;
 622         }
 623
 624         prs_mem_free(&rbuf);
 625
 626         return True;
 627 }
 628
 629 /****************************************************************************
 630 do a REG Delete Key
 631 ****************************************************************************/
 632 BOOL do_reg_delete_key(struct cli_state *cli, POLICY_HND *hnd, char *key_name)
 633 {
 634         prs_struct rbuf;
 635         prs_struct buf;
 636         REG_Q_DELETE_KEY q_o;
 637         REG_R_DELETE_KEY r_o;
 638
 639         if (hnd == NULL)
 640                 return False;
 641
 642         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 643         prs_init(&rbuf, 0, 4, UNMARSHALL);
 644
 645         /* create and send a MSRPC command with api REG_DELETE_KEY */
 646
 647         DEBUG(4,("REG Delete Key: %s\n", key_name));
 648
 649         init_reg_q_delete_key(&q_o, hnd, key_name);
 650
 651         /* turn parameters into data stream */
 652         if(!reg_io_q_delete_key("", &q_o, &buf, 0)) {
 653                 prs_mem_free(&buf);
 654                 prs_mem_free(&rbuf);
 655                 return False;
 656         }
 657
 658         /* send the data on \PIPE\ */
 659         if (!rpc_api_pipe_req(cli, REG_DELETE_KEY, &buf, &rbuf)) {
 660                 prs_mem_free(&buf);
 661                 prs_mem_free(&rbuf);
 662                 return False;
 663         }
 664
 665         prs_mem_free(&buf);
 666
 667         ZERO_STRUCT(r_o);
 668
 669         if(!reg_io_r_delete_key("", &r_o, &rbuf, 0)) {
 670                 prs_mem_free(&rbuf);
 671                 return False;
 672         }
 673
 674         if (r_o.status != 0) {
 675                 /* report error code */
 676                 DEBUG(0,("REG_DELETE_KEY: %s\n", get_nt_error_msg(r_o.status)));
 677                 prs_mem_free(&rbuf);
 678                 return False;
 679         }
 680
 681         prs_mem_free(&rbuf);
 682
 683         return True;
 684 }
 685
 686 /****************************************************************************
 687 do a REG Create Key
 688 ****************************************************************************/
 689 BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd,
 690                                 char *key_name, char *key_class,
 691                                 SEC_ACCESS *sam_access,
 692                                 POLICY_HND *key)
 693 {
 694         prs_struct rbuf;
 695         prs_struct buf;
 696         REG_Q_CREATE_KEY q_o;
 697         REG_R_CREATE_KEY r_o;
 698         SEC_DESC *sec = NULL;
 699         SEC_DESC_BUF *sec_buf = NULL;
 700         size_t sec_len;
 701
 702         ZERO_STRUCT(q_o);
 703
 704         if (hnd == NULL)
 705                 return False;
 706
 707         /* create and send a MSRPC command with api REG_CREATE_KEY */
 708
 709         DEBUG(4,("REG Create Key: %s %s 0x%08x\n", key_name, key_class,
 710                 sam_access != NULL ? sam_access->mask : 0));
 711
 712         if((sec = make_sec_desc( 1, SEC_DESC_SELF_RELATIVE, NULL, NULL, NULL, NULL, &sec_len)) == NULL) {
 713                 DEBUG(0,("make_sec_desc : malloc fail.\n"));
 714                 return False;
 715         }
 716
 717         DEBUG(10,("make_sec_desc: len = %d\n", (int)sec_len));
 718
 719         if((sec_buf = make_sec_desc_buf( (int)sec_len, sec)) == NULL) {
 720                 DEBUG(0,("make_sec_desc : malloc fail (1)\n"));
 721                 free_sec_desc(&sec);
 722                 return False;
 723         }
 724         free_sec_desc(&sec);
 725
 726         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL);
 727         prs_init(&rbuf, 0, 4, UNMARSHALL);
 728
 729         init_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access, sec_buf);
 730
 731         /* turn parameters into data stream */
 732         if(!reg_io_q_create_key("", &q_o, &buf, 0)) {
 733                 free_sec_desc_buf(&sec_buf);
 734                 prs_mem_free(&buf);
 735                 prs_mem_free(&rbuf);
 736                 return False;
 737         }
 738
 739         /* send the data on \PIPE\ */
 740         if (rpc_api_pipe_req(cli, REG_CREATE_KEY, &buf, &rbuf)) {
 741                 free_sec_desc_buf(&sec_buf);
 742                 prs_mem_free(&buf);
 743                 prs_mem_free(&rbuf);
 744                 return False;
 745         }
 746
 747         free_sec_desc_buf(&sec_buf);
 748         prs_mem_free(&buf);
 749
 750         ZERO_STRUCT(r_o);
 751
 752         if(!reg_io_r_create_key("", &r_o, &rbuf, 0)) {
 753                 prs_mem_free(&rbuf);
 754                 return False;
 755         }
 756
 757         if (r_o.status != 0) {
 758                 /* report error code */
 759                 DEBUG(0,("REG_CREATE_KEY: %s\n", get_nt_error_msg(r_o.status)));
 760                 prs_mem_free(&rbuf);
 761                 return False;
 762         }
 763
 764         memcpy(key, r_o.key_pol.data, sizeof(key->data));
 765
 766         prs_mem_free(&rbuf);
 767
 768         return True;
 769 }
 770
 771 /****************************************************************************
 772 do a REG Enum Key
 773 ****************************************************************************/
 774 BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd,
 775                                 int key_index, char *key_name,
 776                                 uint32 *unk_1, uint32 *unk_2,
 777                                 time_t *mod_time)
 778 {
 779         prs_struct rbuf;
 780         prs_struct buf;
 781         REG_Q_ENUM_KEY q_o;
 782         REG_R_ENUM_KEY r_o;
 783
 784         if (hnd == NULL)
 785                 return False;
 786
 787         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL);
 788         prs_init(&rbuf, 0, 4, UNMARSHALL);
 789
 790         /* create and send a MSRPC command with api REG_ENUM_KEY */
 791
 792         DEBUG(4,("REG Enum Key\n"));
 793
 794         init_reg_q_enum_key(&q_o, hnd, key_index);
 795
 796         /* turn parameters into data stream */
 797         if(!reg_io_q_enum_key("", &q_o, &buf, 0)) {
 798                 prs_mem_free(&buf);
 799                 prs_mem_free(&rbuf);
 800                 return False;
 801         }
 802
 803         /* send the data on \PIPE\ */
 804         if (!rpc_api_pipe_req(cli, REG_ENUM_KEY, &buf, &rbuf)) {
 805                 prs_mem_free(&buf);
 806                 prs_mem_free(&rbuf);
 807                 return False;
 808         }
 809
 810         prs_mem_free(&buf);
 811
 812         ZERO_STRUCT(r_o);
 813
 814         if(!reg_io_r_enum_key("", &r_o, &rbuf, 0)) {
 815                 prs_mem_free(&rbuf);
 816                 return False;
 817         }
 818
 819         if (r_o.status != 0) {
 820                 /* report error code */
 821                 DEBUG(0,("REG_ENUM_KEY: %s\n", get_nt_error_msg(r_o.status)));
 822                 prs_mem_free(&rbuf);
 823                 return False;
 824         }
 825
 826         (*unk_1) = r_o.unknown_1;
 827         (*unk_2) = r_o.unknown_2;
 828         fstrcpy(key_name, dos_unistr2(r_o.key_name.str.buffer));
 829         (*mod_time) = nt_time_to_unix(&r_o.time);
 830
 831         prs_mem_free(&rbuf);
 832
 833         return True;
 834 }
 835
 836 /****************************************************************************
 837 do a REG Create Value
 838 ****************************************************************************/
 839 BOOL do_reg_create_val(struct cli_state *cli, POLICY_HND *hnd,
 840                                 char *val_name, uint32 type, BUFFER3 *data)
 841 {
 842         prs_struct rbuf;
 843         prs_struct buf;
 844         REG_Q_CREATE_VALUE q_o;
 845         REG_R_CREATE_VALUE r_o;
 846
 847         if (hnd == NULL)
 848                 return False;
 849
 850         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL);
 851         prs_init(&rbuf, 0, 4, UNMARSHALL);
 852
 853         /* create and send a MSRPC command with api REG_CREATE_VALUE */
 854
 855         DEBUG(4,("REG Create Value: %s\n", val_name));
 856
 857         init_reg_q_create_val(&q_o, hnd, val_name, type, data);
 858
 859         /* turn parameters into data stream */
 860         if(!reg_io_q_create_val("", &q_o, &buf, 0)) {
 861                 prs_mem_free(&buf);
 862                 prs_mem_free(&rbuf);
 863                 return False;
 864         }
 865
 866         /* send the data on \PIPE\ */
 867         if (!rpc_api_pipe_req(cli, REG_CREATE_VALUE, &buf, &rbuf)) {
 868                 prs_mem_free(&buf);
 869                 prs_mem_free(&rbuf);
 870                 return False;
 871         }
 872
 873         prs_mem_free(&buf);
 874
 875         ZERO_STRUCT(r_o);
 876
 877         if(!reg_io_r_create_val("", &r_o, &rbuf, 0)) {
 878                 prs_mem_free(&rbuf);
 879                 return False;
 880         }
 881
 882         if (r_o.status != 0) {
 883                 /* report error code */
 884                 DEBUG(0,("REG_CREATE_VALUE: %s\n", get_nt_error_msg(r_o.status)));
 885                 prs_mem_free(&rbuf);
 886                 return False;
 887         }
 888
 889         prs_mem_free(&rbuf);
 890
 891         return True;
 892 }
 893
 894 /****************************************************************************
 895 do a REG Enum Value
 896 ****************************************************************************/
 897 BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd,
 898                                 int val_index, int max_valnamelen, int max_valbufsize,
 899                                 fstring val_name,
 900                                 uint32 *val_type, BUFFER2 *value)
 901 {
 902         prs_struct rbuf;
 903         prs_struct buf;
 904         REG_Q_ENUM_VALUE q_o;
 905         REG_R_ENUM_VALUE r_o;
 906
 907         if (hnd == NULL)
 908                 return False;
 909
 910         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL);
 911         prs_init(&rbuf, 0, 4, UNMARSHALL);
 912
 913         /* create and send a MSRPC command with api REG_ENUM_VALUE */
 914
 915         DEBUG(4,("REG Enum Value\n"));
 916
 917         init_reg_q_enum_val(&q_o, hnd, val_index, max_valnamelen, max_valbufsize);
 918
 919         /* turn parameters into data stream */
 920         if(!reg_io_q_enum_val("", &q_o, &buf, 0)) {
 921                 prs_mem_free(&buf);
 922                 prs_mem_free(&rbuf);
 923                 return False;
 924         }
 925
 926         /* send the data on \PIPE\ */
 927         if (!rpc_api_pipe_req(cli, REG_ENUM_VALUE, &buf, &rbuf)) {
 928                 prs_mem_free(&buf);
 929                 prs_mem_free(&rbuf);
 930                 return False;
 931         }
 932
 933         prs_mem_free(&buf);
 934
 935         ZERO_STRUCT(r_o);
 936         r_o.buf_value = value;
 937
 938         if(!reg_io_r_enum_val("", &r_o, &rbuf, 0)) {
 939                 prs_mem_free(&rbuf);
 940                 return False;
 941         }
 942
 943         if (r_o.status != 0) {
 944                 /* report error code */
 945                 DEBUG(0,("REG_ENUM_VALUE: %s\n", get_nt_error_msg(r_o.status)));
 946                 prs_mem_free(&rbuf);
 947                 return False;
 948         }
 949
 950         (*val_type) = r_o.type;
 951         fstrcpy(val_name, dos_unistr2_to_str(&r_o.uni_name));
 952
 953         prs_mem_free(&rbuf);
 954
 955         return True;
 956 }
 957
 958 /****************************************************************************
 959 do a REG Open Key
 960 ****************************************************************************/
 961 BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd,
 962                                 char *key_name, uint32 unk_0,
 963                                 POLICY_HND *key_hnd)
 964 {
 965         prs_struct rbuf;
 966         prs_struct buf;
 967         REG_Q_OPEN_ENTRY q_o;
 968         REG_R_OPEN_ENTRY r_o;
 969
 970         if (hnd == NULL)
 971                 return False;
 972
 973         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL);
 974         prs_init(&rbuf, 0, 4, UNMARSHALL);
 975
 976         /* create and send a MSRPC command with api REG_OPEN_ENTRY */
 977
 978         DEBUG(4,("REG Open Entry\n"));
 979
 980         init_reg_q_open_entry(&q_o, hnd, key_name, unk_0);
 981
 982         /* turn parameters into data stream */
 983         if(!reg_io_q_open_entry("", &q_o, &buf, 0)) {
 984                 prs_mem_free(&buf);
 985                 prs_mem_free(&rbuf);
 986                 return False;
 987         }
 988
 989         /* send the data on \PIPE\ */
 990         if (!rpc_api_pipe_req(cli, REG_OPEN_ENTRY, &buf, &rbuf)) {
 991                 prs_mem_free(&buf);
 992                 prs_mem_free(&rbuf);
 993                 return False;
 994         }
 995
 996         prs_mem_free(&buf);
 997
 998         ZERO_STRUCT(r_o);
 999
1000         if(!reg_io_r_open_entry("", &r_o, &rbuf, 0)) {
1001                 prs_mem_free(&rbuf);
1002                 return False;
1003         }
1004
1005         if (r_o.status != 0) {
1006                 /* report error code */
1007                 DEBUG(0,("REG_OPEN_ENTRY: %s\n", get_nt_error_msg(r_o.status)));
1008                 prs_mem_free(&rbuf);
1009                 return False;
1010         }
1011
1012         memcpy(key_hnd, r_o.pol.data, sizeof(key_hnd->data));
1013
1014         prs_mem_free(&rbuf);
1015
1016         return True;
1017 }
1018
1019 /****************************************************************************
1020 do a REG Close
1021 ****************************************************************************/
1022 BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd)
1023 {
1024         prs_struct rbuf;
1025         prs_struct buf;
1026         REG_Q_CLOSE q_c;
1027         REG_R_CLOSE r_c;
1028         int i;
1029
1030         if (hnd == NULL)
1031                 return False;
1032
1033         /* create and send a MSRPC command with api REG_CLOSE */
1034
1035         prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL);
1036         prs_init(&rbuf, 0, 4, UNMARSHALL);
1037
1038         DEBUG(4,("REG Close\n"));
1039
1040         /* store the parameters */
1041         init_reg_q_close(&q_c, hnd);
1042
1043         /* turn parameters into data stream */
1044         if(!reg_io_q_close("", &q_c, &buf, 0)) {
1045                 prs_mem_free(&buf);
1046                 prs_mem_free(&rbuf);
1047                 return False;
1048         }
1049
1050         /* send the data on \PIPE\ */
1051         if (!rpc_api_pipe_req(cli, REG_CLOSE, &buf, &rbuf)) {
1052                 prs_mem_free(&buf);
1053                 prs_mem_free(&rbuf);
1054                 return False;
1055         }
1056
1057         prs_mem_free(&buf);
1058
1059         ZERO_STRUCT(r_c);
1060
1061         if(!reg_io_r_close("", &r_c, &rbuf, 0)) {
1062                 prs_mem_free(&rbuf);
1063                 return False;
1064         }
1065
1066         if (r_c.status != 0) {
1067                 /* report error code */
1068                 DEBUG(0,("REG_CLOSE: %s\n", get_nt_error_msg(r_c.status)));
1069                 prs_mem_free(&rbuf);
1070                 return False;
1071         }
1072
1073         /* check that the returned policy handle is all zeros */
1074
1075         for (i = 0; i < sizeof(r_c.pol.data); i++) {
1076                 if (r_c.pol.data[i] != 0) {
1077                         prs_mem_free(&rbuf);
1078                         DEBUG(0,("REG_CLOSE: non-zero handle returned\n"));
1079                         return False;
1080                 }
1081         }
1082
1083         prs_mem_free(&rbuf);
1084
1085         return True;
1086 }