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-1997,
   7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   8  *  Copyright (C) Paul Ashton                       1997.
   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 /****************************************************************************
  36 do a REG Open Policy
  37 ****************************************************************************/
  38 BOOL do_reg_open_policy(struct cli_state *cli, uint16 unknown_0, uint32 level,
  39                                 POLICY_HND *hnd)
  40 {
  41         prs_struct rbuf;
  42         prs_struct buf;
  43         REG_Q_OPEN_POLICY q_o;
  44         BOOL valid_pol = False;
  45
  46         if (hnd == NULL) return False;
  47
  48         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
  49         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
  50
  51         /* create and send a MSRPC command with api REG_OPEN_POLICY */
  52
  53         DEBUG(4,("REG Open Policy\n"));
  54
  55         make_reg_q_open_pol(&q_o, unknown_0, level);
  56
  57         /* turn parameters into data stream */
  58         reg_io_q_open_policy("", &q_o, &buf, 0);
  59
  60         /* send the data on \PIPE\ */
  61         if (rpc_api_pipe_req(cli, REG_OPEN_POLICY, &buf, &rbuf))
  62         {
  63                 REG_R_OPEN_POLICY r_o;
  64                 BOOL p;
  65
  66                 ZERO_STRUCT(r_o);
  67
  68                 reg_io_r_open_policy("", &r_o, &rbuf, 0);
  69                 p = rbuf.offset != 0;
  70
  71                 if (p && r_o.status != 0)
  72                 {
  73                         /* report error code */
  74                         DEBUG(0,("REG_OPEN_POLICY: %s\n", get_nt_error_msg(r_o.status)));
  75                         p = False;
  76                 }
  77
  78                 if (p)
  79                 {
  80                         /* ok, at last: we're happy. return the policy handle */
  81                         memcpy(hnd, r_o.pol.data, sizeof(hnd->data));
  82                         valid_pol = True;
  83                 }
  84         }
  85
  86         prs_mem_free(&rbuf);
  87         prs_mem_free(&buf );
  88
  89         return valid_pol;
  90 }
  91
  92 /****************************************************************************
  93 do a REG Open Unknown 4
  94 ****************************************************************************/
  95 BOOL do_reg_open_unk_4(struct cli_state *cli, uint16 unknown_0, uint32 level,
  96                                 POLICY_HND *hnd)
  97 {
  98         prs_struct rbuf;
  99         prs_struct buf;
 100         REG_Q_OPEN_UNK_4 q_o;
 101         BOOL valid_pol = False;
 102
 103         if (hnd == NULL) return False;
 104
 105         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 106         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 107
 108         /* create and send a MSRPC command with api REG_OPEN_UNK_4 */
 109
 110         DEBUG(4,("REG Open Unknown4\n"));
 111
 112         make_reg_q_open_unk_4(&q_o, unknown_0, level);
 113
 114         /* turn parameters into data stream */
 115         reg_io_q_open_unk_4("", &q_o, &buf, 0);
 116
 117         /* send the data on \PIPE\ */
 118         if (rpc_api_pipe_req(cli, REG_OPEN_UNK_4, &buf, &rbuf))
 119         {
 120                 REG_R_OPEN_UNK_4 r_o;
 121                 BOOL p;
 122
 123                 ZERO_STRUCT(r_o);
 124
 125                 reg_io_r_open_unk_4("", &r_o, &rbuf, 0);
 126                 p = rbuf.offset != 0;
 127
 128                 if (p && r_o.status != 0)
 129                 {
 130                         /* report error code */
 131                         DEBUG(0,("REG_OPEN_UNK_4: %s\n", get_nt_error_msg(r_o.status)));
 132                         p = False;
 133                 }
 134
 135                 if (p)
 136                 {
 137                         /* ok, at last: we're happy. return the policy handle */
 138                         memcpy(hnd, r_o.pol.data, sizeof(hnd->data));
 139                         valid_pol = True;
 140                 }
 141         }
 142
 143         prs_mem_free(&rbuf);
 144         prs_mem_free(&buf );
 145
 146         return valid_pol;
 147 }
 148
 149 /****************************************************************************
 150 do a REG Unknown 0xB command.  sent after a create key or create value.
 151 this might be some sort of "sync" or "refresh" command, sent after
 152 modification of the registry...
 153 ****************************************************************************/
 154 BOOL do_reg_unk_b(struct cli_state *cli, POLICY_HND *hnd)
 155 {
 156         prs_struct rbuf;
 157         prs_struct buf;
 158         REG_Q_UNK_B q_o;
 159         BOOL valid_query = False;
 160
 161         if (hnd == NULL) return False;
 162
 163         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 164         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 165
 166         /* create and send a MSRPC command with api REG_UNK_B */
 167
 168         DEBUG(4,("REG Unknown 0xB\n"));
 169
 170         make_reg_q_unk_b(&q_o, hnd);
 171
 172         /* turn parameters into data stream */
 173         reg_io_q_unk_b("", &q_o, &buf, 0);
 174
 175         /* send the data on \PIPE\ */
 176         if (rpc_api_pipe_req(cli, REG_UNK_B, &buf, &rbuf))
 177         {
 178                 REG_R_UNK_B r_o;
 179                 BOOL p;
 180
 181                 ZERO_STRUCT(r_o);
 182
 183                 reg_io_r_unk_b("", &r_o, &rbuf, 0);
 184                 p = rbuf.offset != 0;
 185
 186                 if (p && r_o.status != 0)
 187                 {
 188                         /* report error code */
 189                         DEBUG(0,("REG_UNK_B: %s\n", get_nt_error_msg(r_o.status)));
 190                         p = False;
 191                 }
 192
 193                 if (p)
 194                 {
 195                         valid_query = True;
 196                 }
 197         }
 198
 199         prs_mem_free(&rbuf);
 200         prs_mem_free(&buf );
 201
 202         return valid_query;
 203 }
 204
 205 /****************************************************************************
 206 do a REG Query Key
 207 ****************************************************************************/
 208 BOOL do_reg_query_key(struct cli_state *cli, POLICY_HND *hnd,
 209                                 char *class, uint32 *class_len,
 210                                 uint32 *num_subkeys, uint32 *max_subkeylen,
 211                                 uint32 *max_subkeysize, uint32 *num_values,
 212                                 uint32 *max_valnamelen, uint32 *max_valbufsize,
 213                                 uint32 *sec_desc, NTTIME *mod_time)
 214 {
 215         prs_struct rbuf;
 216         prs_struct buf;
 217         REG_Q_QUERY_KEY q_o;
 218         BOOL valid_query = False;
 219
 220         if (hnd == NULL) return False;
 221
 222         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 223         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 224
 225         /* create and send a MSRPC command with api REG_QUERY_KEY */
 226
 227         DEBUG(4,("REG Query Key\n"));
 228
 229         make_reg_q_query_key(&q_o, hnd, *class_len);
 230
 231         /* turn parameters into data stream */
 232         reg_io_q_query_key("", &q_o, &buf, 0);
 233
 234         /* send the data on \PIPE\ */
 235         if (rpc_api_pipe_req(cli, REG_QUERY_KEY, &buf, &rbuf))
 236         {
 237                 REG_R_QUERY_KEY r_o;
 238                 BOOL p;
 239
 240                 ZERO_STRUCT(r_o);
 241
 242                 reg_io_r_query_key("", &r_o, &rbuf, 0);
 243                 p = rbuf.offset != 0;
 244
 245                 if (p && r_o.status != 0)
 246                 {
 247                         /* report error code */
 248                         DEBUG(0,("REG_QUERY_KEY: %s\n", get_nt_error_msg(r_o.status)));
 249                         p = False;
 250                 }
 251
 252                 if (p)
 253                 {
 254                         valid_query = True;
 255
 256                         *class_len      = r_o.hdr_class.uni_max_len;
 257                         fstrcpy(class, unistr2_to_str(&r_o.uni_class));
 258                         *num_subkeys    = r_o.num_subkeys   ;
 259                         *max_subkeylen  = r_o.max_subkeylen ;
 260                         *max_subkeysize = r_o.max_subkeysize;
 261                         *num_values     = r_o.num_values    ;
 262                         *max_valnamelen = r_o.max_valnamelen;
 263                         *max_valbufsize = r_o.max_valbufsize;
 264                         *sec_desc       = r_o.sec_desc      ;
 265                         *mod_time       = r_o.mod_time      ;
 266                 }
 267         }
 268
 269         prs_mem_free(&rbuf);
 270         prs_mem_free(&buf );
 271
 272         return valid_query;
 273 }
 274
 275 /****************************************************************************
 276 do a REG Unknown 1A
 277 ****************************************************************************/
 278 BOOL do_reg_unknown_1a(struct cli_state *cli, POLICY_HND *hnd, uint32 *unk)
 279 {
 280         prs_struct rbuf;
 281         prs_struct buf;
 282         REG_Q_UNK_1A q_o;
 283         BOOL valid_query = False;
 284
 285         if (hnd == NULL) return False;
 286
 287         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 288         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 289
 290         /* create and send a MSRPC command with api REG_UNKNOWN_1A */
 291
 292         DEBUG(4,("REG Unknown 1a\n"));
 293
 294         make_reg_q_unk_1a(&q_o, hnd);
 295
 296         /* turn parameters into data stream */
 297         reg_io_q_unk_1a("", &q_o, &buf, 0);
 298
 299         /* send the data on \PIPE\ */
 300         if (rpc_api_pipe_req(cli, REG_UNK_1A, &buf, &rbuf))
 301         {
 302                 REG_R_UNK_1A r_o;
 303                 BOOL p;
 304
 305                 ZERO_STRUCT(r_o);
 306
 307                 reg_io_r_unk_1a("", &r_o, &rbuf, 0);
 308                 p = rbuf.offset != 0;
 309
 310                 if (p && r_o.status != 0)
 311                 {
 312                         /* report error code */
 313                         DEBUG(0,("REG_UNK_1A: %s\n", get_nt_error_msg(r_o.status)));
 314                         p = False;
 315                 }
 316
 317                 if (p)
 318                 {
 319                         valid_query = True;
 320                         (*unk) = r_o.unknown;
 321                 }
 322         }
 323
 324         prs_mem_free(&rbuf);
 325         prs_mem_free(&buf );
 326
 327         return valid_query;
 328 }
 329
 330 /****************************************************************************
 331 do a REG Query Info
 332 ****************************************************************************/
 333 BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd,
 334                                 char *type, uint32 *unk_0, uint32 *unk_1)
 335 {
 336         prs_struct rbuf;
 337         prs_struct buf;
 338         REG_Q_INFO q_o;
 339         BOOL valid_query = False;
 340
 341         if (hnd == NULL) return False;
 342
 343         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 344         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 345
 346         /* create and send a MSRPC command with api REG_INFO */
 347
 348         DEBUG(4,("REG Query Info\n"));
 349
 350         make_reg_q_info(&q_o, hnd, "ProductType", time(NULL), 4, 1);
 351
 352         /* turn parameters into data stream */
 353         reg_io_q_info("", &q_o, &buf, 0);
 354
 355         /* send the data on \PIPE\ */
 356         if (rpc_api_pipe_req(cli, REG_INFO, &buf, &rbuf))
 357         {
 358                 REG_R_INFO r_o;
 359                 BOOL p;
 360
 361                 ZERO_STRUCT(r_o);
 362
 363                 reg_io_r_info("", &r_o, &rbuf, 0);
 364                 p = rbuf.offset != 0;
 365
 366                 if (p && r_o.status != 0)
 367                 {
 368                         /* report error code */
 369                         DEBUG(0,("REG_INFO: %s\n", get_nt_error_msg(r_o.status)));
 370                         p = False;
 371                 }
 372
 373                 if (p)
 374                 {
 375                         valid_query = True;
 376                         fstrcpy(type, buffer2_to_str(&r_o.uni_type));
 377                         (*unk_0) = r_o.unknown_0;
 378                         (*unk_1) = r_o.unknown_1;
 379                 }
 380         }
 381
 382         prs_mem_free(&rbuf);
 383         prs_mem_free(&buf );
 384
 385         return valid_query;
 386 }
 387
 388 /****************************************************************************
 389 do a REG Query Key Security
 390 ****************************************************************************/
 391 BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd,
 392                                 uint32 *sec_buf_size, SEC_DESC_BUF *sec_buf)
 393 {
 394         prs_struct rbuf;
 395         prs_struct buf;
 396         REG_Q_GET_KEY_SEC q_o;
 397         BOOL valid_query = False;
 398
 399         if (hnd == NULL) return False;
 400
 401         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 402         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 403
 404         /* create and send a MSRPC command with api REG_GET_KEY_SEC */
 405
 406         DEBUG(4,("REG query key security.  buf_size: %d\n", *sec_buf_size));
 407
 408         make_reg_q_get_key_sec(&q_o, hnd, *sec_buf_size, sec_buf);
 409
 410         /* turn parameters into data stream */
 411         reg_io_q_get_key_sec("", &q_o, &buf, 0);
 412
 413         /* send the data on \PIPE\ */
 414         if (rpc_api_pipe_req(cli, REG_GET_KEY_SEC, &buf, &rbuf))
 415         {
 416                 REG_R_GET_KEY_SEC r_o;
 417                 BOOL p;
 418
 419                 ZERO_STRUCT(r_o);
 420
 421                 r_o.data = sec_buf;
 422                 reg_io_r_get_key_sec("", &r_o, &rbuf, 0);
 423                 p = rbuf.offset != 0;
 424
 425                 if (p && r_o.status == 0x0000007a)
 426                 {
 427                         /*
 428                          * get the maximum buffer size: it was too small
 429                          */
 430                         (*sec_buf_size) = r_o.hdr_sec.buf_max_len;
 431                         DEBUG(5,("sec_buf_size too small.  use %d\n", *sec_buf_size));
 432                         valid_query = True;
 433                 }
 434                 else if (p && r_o.status != 0)
 435                 {
 436                         /* report error code */
 437                         DEBUG(0,("REG_GET_KEY_SEC: %s\n", get_nt_error_msg(r_o.status)));
 438                         p = False;
 439                 }
 440                 else
 441                 {
 442                         valid_query = True;
 443                         (*sec_buf_size) = r_o.data->len;
 444                 }
 445         }
 446
 447         prs_mem_free(&rbuf);
 448         prs_mem_free(&buf );
 449
 450         return valid_query;
 451 }
 452
 453 /****************************************************************************
 454 do a REG Create Key
 455 ****************************************************************************/
 456 BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd,
 457                                 char *key_name, char *key_class,
 458                                 SEC_INFO *sam_access,
 459                                 POLICY_HND *key)
 460 {
 461         prs_struct rbuf;
 462         prs_struct buf;
 463         REG_Q_CREATE_KEY q_o;
 464         BOOL valid_create = False;
 465
 466         if (hnd == NULL) return False;
 467
 468         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 469         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 470
 471         /* create and send a MSRPC command with api REG_CREATE_KEY */
 472
 473         DEBUG(4,("REG Create Key: %s %s 0x%08x\n", key_name, key_class,
 474                 sam_access != NULL ? sam_access->perms : 0));
 475
 476         make_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access);
 477
 478         /* turn parameters into data stream */
 479         reg_io_q_create_key("", &q_o, &buf, 0);
 480
 481         /* send the data on \PIPE\ */
 482         if (rpc_api_pipe_req(cli, REG_CREATE_KEY, &buf, &rbuf))
 483         {
 484                 REG_R_CREATE_KEY r_o;
 485                 BOOL p;
 486
 487                 ZERO_STRUCT(r_o);
 488
 489                 reg_io_r_create_key("", &r_o, &rbuf, 0);
 490                 p = rbuf.offset != 0;
 491
 492                 if (p && r_o.status != 0)
 493                 {
 494                         /* report error code */
 495                         DEBUG(0,("REG_CREATE_KEY: %s\n", get_nt_error_msg(r_o.status)));
 496                         p = False;
 497                 }
 498
 499                 if (p)
 500                 {
 501                         valid_create = True;
 502                         memcpy(key, r_o.key_pol.data, sizeof(key->data));
 503                 }
 504         }
 505
 506         prs_mem_free(&rbuf);
 507         prs_mem_free(&buf );
 508
 509         return valid_create;
 510 }
 511
 512 /****************************************************************************
 513 do a REG Enum Key
 514 ****************************************************************************/
 515 BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd,
 516                                 int key_index, char *key_name,
 517                                 uint32 *unk_1, uint32 *unk_2,
 518                                 time_t *mod_time)
 519 {
 520         prs_struct rbuf;
 521         prs_struct buf;
 522         REG_Q_ENUM_KEY q_o;
 523         BOOL valid_query = False;
 524
 525         if (hnd == NULL) return False;
 526
 527         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 528         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 529
 530         /* create and send a MSRPC command with api REG_ENUM_KEY */
 531
 532         DEBUG(4,("REG Enum Key\n"));
 533
 534         make_reg_q_enum_key(&q_o, hnd, key_index);
 535
 536         /* turn parameters into data stream */
 537         reg_io_q_enum_key("", &q_o, &buf, 0);
 538
 539         /* send the data on \PIPE\ */
 540         if (rpc_api_pipe_req(cli, REG_ENUM_KEY, &buf, &rbuf))
 541         {
 542                 REG_R_ENUM_KEY r_o;
 543                 BOOL p;
 544
 545                 ZERO_STRUCT(r_o);
 546
 547                 reg_io_r_enum_key("", &r_o, &rbuf, 0);
 548                 p = rbuf.offset != 0;
 549
 550                 if (p && r_o.status != 0)
 551                 {
 552                         /* report error code */
 553                         DEBUG(0,("REG_ENUM_KEY: %s\n", get_nt_error_msg(r_o.status)));
 554                         p = False;
 555                 }
 556
 557                 if (p)
 558                 {
 559                         valid_query = True;
 560                         (*unk_1) = r_o.unknown_1;
 561                         (*unk_2) = r_o.unknown_2;
 562                         fstrcpy(key_name, unistr2(r_o.key_name.str.buffer));
 563                         (*mod_time) = nt_time_to_unix(&r_o.time);
 564                 }
 565         }
 566
 567         prs_mem_free(&rbuf);
 568         prs_mem_free(&buf );
 569
 570         return valid_query;
 571 }
 572
 573 /****************************************************************************
 574 do a REG Create Value
 575 ****************************************************************************/
 576 BOOL do_reg_create_val(struct cli_state *cli, POLICY_HND *hnd,
 577                                 char *val_name, uint32 type, BUFFER3 *data)
 578 {
 579         prs_struct rbuf;
 580         prs_struct buf;
 581         REG_Q_CREATE_VALUE q_o;
 582         BOOL valid_create = False;
 583
 584         if (hnd == NULL) return False;
 585
 586         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 587         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 588
 589         /* create and send a MSRPC command with api REG_CREATE_VALUE */
 590
 591         DEBUG(4,("REG Create Value: %s\n", val_name));
 592
 593         make_reg_q_create_val(&q_o, hnd, val_name, type, data);
 594
 595         /* turn parameters into data stream */
 596         reg_io_q_create_val("", &q_o, &buf, 0);
 597
 598         /* send the data on \PIPE\ */
 599         if (rpc_api_pipe_req(cli, REG_CREATE_VALUE, &buf, &rbuf))
 600         {
 601                 REG_R_CREATE_VALUE r_o;
 602                 BOOL p;
 603
 604                 ZERO_STRUCT(r_o);
 605
 606                 reg_io_r_create_val("", &r_o, &rbuf, 0);
 607                 p = rbuf.offset != 0;
 608
 609                 if (p && r_o.status != 0)
 610                 {
 611                         /* report error code */
 612                         DEBUG(0,("REG_CREATE_VALUE: %s\n", get_nt_error_msg(r_o.status)));
 613                         p = False;
 614                 }
 615
 616                 if (p)
 617                 {
 618                         valid_create = True;
 619                 }
 620         }
 621
 622         prs_mem_free(&rbuf);
 623         prs_mem_free(&buf );
 624
 625         return valid_create;
 626 }
 627
 628 /****************************************************************************
 629 do a REG Enum Value
 630 ****************************************************************************/
 631 BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd,
 632                                 int val_index, int max_valnamelen, int max_valbufsize,
 633                                 fstring val_name,
 634                                 uint32 *val_type, BUFFER2 *value)
 635 {
 636         prs_struct rbuf;
 637         prs_struct buf;
 638         REG_Q_ENUM_VALUE q_o;
 639         BOOL valid_query = False;
 640
 641         if (hnd == NULL) return False;
 642
 643         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 644         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 645
 646         /* create and send a MSRPC command with api REG_ENUM_VALUE */
 647
 648         DEBUG(4,("REG Enum Value\n"));
 649
 650         make_reg_q_enum_val(&q_o, hnd, val_index, max_valnamelen, max_valbufsize);
 651
 652         /* turn parameters into data stream */
 653         reg_io_q_enum_val("", &q_o, &buf, 0);
 654
 655         /* send the data on \PIPE\ */
 656         if (rpc_api_pipe_req(cli, REG_ENUM_VALUE, &buf, &rbuf))
 657         {
 658                 REG_R_ENUM_VALUE r_o;
 659                 BOOL p;
 660
 661                 ZERO_STRUCT(r_o);
 662                 r_o.buf_value = value;
 663
 664                 reg_io_r_enum_val("", &r_o, &rbuf, 0);
 665                 p = rbuf.offset != 0;
 666
 667                 if (p && r_o.status != 0)
 668                 {
 669                         /* report error code */
 670                         DEBUG(0,("REG_ENUM_VALUE: %s\n", get_nt_error_msg(r_o.status)));
 671                         p = False;
 672                 }
 673
 674                 if (p)
 675                 {
 676                         valid_query = True;
 677                         (*val_type) = r_o.type;
 678                         fstrcpy(val_name, unistr2_to_str(&r_o.uni_name));
 679                 }
 680         }
 681
 682         prs_mem_free(&rbuf);
 683         prs_mem_free(&buf );
 684
 685         return valid_query;
 686 }
 687
 688 /****************************************************************************
 689 do a REG Open Key
 690 ****************************************************************************/
 691 BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd,
 692                                 char *key_name, uint32 unk_0,
 693                                 POLICY_HND *key_hnd)
 694 {
 695         prs_struct rbuf;
 696         prs_struct buf;
 697         REG_Q_OPEN_ENTRY q_o;
 698         BOOL valid_pol = False;
 699
 700         if (hnd == NULL) return False;
 701
 702         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 703         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 704
 705         /* create and send a MSRPC command with api REG_OPEN_ENTRY */
 706
 707         DEBUG(4,("REG Open Entry\n"));
 708
 709         make_reg_q_open_entry(&q_o, hnd, key_name, unk_0);
 710
 711         /* turn parameters into data stream */
 712         reg_io_q_open_entry("", &q_o, &buf, 0);
 713
 714         /* send the data on \PIPE\ */
 715         if (rpc_api_pipe_req(cli, REG_OPEN_ENTRY, &buf, &rbuf))
 716         {
 717                 REG_R_OPEN_ENTRY r_o;
 718                 BOOL p;
 719
 720                 ZERO_STRUCT(r_o);
 721
 722                 reg_io_r_open_entry("", &r_o, &rbuf, 0);
 723                 p = rbuf.offset != 0;
 724
 725                 if (p && r_o.status != 0)
 726                 {
 727                         /* report error code */
 728                         DEBUG(0,("REG_OPEN_ENTRY: %s\n", get_nt_error_msg(r_o.status)));
 729                         p = False;
 730                 }
 731
 732                 if (p)
 733                 {
 734                         valid_pol = True;
 735                         memcpy(key_hnd, r_o.pol.data, sizeof(key_hnd->data));
 736                 }
 737         }
 738
 739         prs_mem_free(&rbuf);
 740         prs_mem_free(&buf );
 741
 742         return valid_pol;
 743 }
 744
 745 /****************************************************************************
 746 do a REG Close
 747 ****************************************************************************/
 748 BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd)
 749 {
 750         prs_struct rbuf;
 751         prs_struct buf;
 752         REG_Q_CLOSE q_c;
 753         BOOL valid_close = False;
 754
 755         if (hnd == NULL) return False;
 756
 757         /* create and send a MSRPC command with api REG_CLOSE */
 758
 759         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 760         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 761
 762         DEBUG(4,("REG Close\n"));
 763
 764         /* store the parameters */
 765         make_reg_q_close(&q_c, hnd);
 766
 767         /* turn parameters into data stream */
 768         reg_io_q_close("", &q_c, &buf, 0);
 769
 770         /* send the data on \PIPE\ */
 771         if (rpc_api_pipe_req(cli, REG_CLOSE, &buf, &rbuf))
 772         {
 773                 REG_R_CLOSE r_c;
 774                 BOOL p;
 775
 776                 ZERO_STRUCT(r_c);
 777
 778                 reg_io_r_close("", &r_c, &rbuf, 0);
 779                 p = rbuf.offset != 0;
 780
 781                 if (p && r_c.status != 0)
 782                 {
 783                         /* report error code */
 784                         DEBUG(0,("REG_CLOSE: %s\n", get_nt_error_msg(r_c.status)));
 785                         p = False;
 786                 }
 787
 788                 if (p)
 789                 {
 790                         /* check that the returned policy handle is all zeros */
 791                         int i;
 792                         valid_close = True;
 793
 794                         for (i = 0; i < sizeof(r_c.pol.data); i++)
 795                         {
 796                                 if (r_c.pol.data[i] != 0)
 797                                 {
 798                                         valid_close = False;
 799                                         break;
 800                                 }
 801                         }
 802                         if (!valid_close)
 803                         {
 804                                 DEBUG(0,("REG_CLOSE: non-zero handle returned\n"));
 805                         }
 806                 }
 807         }
 808
 809         prs_mem_free(&rbuf);
 810         prs_mem_free(&buf );
 811
 812         return valid_close;
 813 }
 814
 815