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