source/rpc_parse/parse_reg.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-1997,
   5  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   6  *  Copyright (C) Paul Ashton                       1997.
   7  *  Copyright (C) Marc Jacobsen                     1999.
   8  *  Copyright (C) Simo Sorce                        2000.
   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 #include "includes.h"
  26
  27 #undef DBGC_CLASS
  28 #define DBGC_CLASS DBGC_RPC_PARSE
  29
  30 /*******************************************************************
  31  Inits a structure.
  32 ********************************************************************/
  33
  34 void init_reg_q_open_hkcr(REG_Q_OPEN_HKCR *q_o,
  35                                 uint16 unknown_0, uint32 level)
  36 {
  37         q_o->ptr = 1;
  38         q_o->unknown_0 = unknown_0;
  39         q_o->unknown_1 = 0x0; /* random - changes */
  40         q_o->level = level;
  41 }
  42
  43 /*******************************************************************
  44 reads or writes a structure.
  45 ********************************************************************/
  46
  47 BOOL reg_io_q_open_hkcr(char *desc,  REG_Q_OPEN_HKCR *r_q, prs_struct *ps, int depth)
  48 {
  49         if (r_q == NULL)
  50                 return False;
  51
  52         prs_debug(ps, depth, desc, "reg_io_q_open_hkcr");
  53         depth++;
  54
  55         if(!prs_align(ps))
  56                 return False;
  57
  58         if(!prs_uint32("ptr      ", ps, depth, &r_q->ptr))
  59                 return False;
  60
  61         if (r_q->ptr != 0) {
  62                 if(!prs_uint16("unknown_0", ps, depth, &r_q->unknown_0))
  63                         return False;
  64                 if(!prs_uint16("unknown_1", ps, depth, &r_q->unknown_1))
  65                         return False;
  66                 if(!prs_uint32("level    ", ps, depth, &r_q->level))
  67                         return False;
  68         }
  69
  70         return True;
  71 }
  72
  73
  74 /*******************************************************************
  75 reads or writes a structure.
  76 ********************************************************************/
  77
  78 BOOL reg_io_r_open_hkcr(char *desc,  REG_R_OPEN_HKCR *r_r, prs_struct *ps, int depth)
  79 {
  80         if (r_r == NULL)
  81                 return False;
  82
  83         prs_debug(ps, depth, desc, "reg_io_r_open_hkcr");
  84         depth++;
  85
  86         if(!prs_align(ps))
  87                 return False;
  88
  89         if(!smb_io_pol_hnd("", &r_r->pol, ps, depth))
  90                 return False;
  91
  92         if(!prs_ntstatus("status", ps, depth, &r_r->status))
  93                 return False;
  94
  95         return True;
  96 }
  97
  98 /*******************************************************************
  99  Inits a structure.
 100 ********************************************************************/
 101
 102 void init_reg_q_open_hklm(REG_Q_OPEN_HKLM * q_o,
 103                           uint16 unknown_0, uint32 access_mask)
 104 {
 105         q_o->ptr = 1;
 106         q_o->unknown_0 = unknown_0;
 107         q_o->unknown_1 = 0x0;   /* random - changes */
 108         q_o->access_mask = access_mask;
 109
 110 }
 111
 112 /*******************************************************************
 113 reads or writes a structure.
 114 ********************************************************************/
 115 BOOL reg_io_q_open_hklm(char *desc, REG_Q_OPEN_HKLM * r_q, prs_struct *ps,
 116                         int depth)
 117 {
 118         if (r_q == NULL)
 119                 return False;
 120
 121         prs_debug(ps, depth, desc, "reg_io_q_open_hklm");
 122         depth++;
 123
 124         if (!prs_align(ps))
 125                 return False;
 126
 127         if (!prs_uint32("ptr      ", ps, depth, &(r_q->ptr)))
 128                 return False;
 129         if (r_q->ptr != 0)
 130         {
 131                 if (!prs_uint16("unknown_0", ps, depth, &(r_q->unknown_0)))
 132                 return False;
 133                 if (!prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1)))
 134                 return False;
 135                 if (!prs_uint32("access_mask", ps, depth, &(r_q->access_mask)))
 136                 return False;
 137         }
 138
 139         return True;
 140 }
 141
 142
 143 /*******************************************************************
 144 reads or writes a structure.
 145 ********************************************************************/
 146 BOOL reg_io_r_open_hklm(char *desc, REG_R_OPEN_HKLM * r_r, prs_struct *ps,
 147                         int depth)
 148 {
 149         if (r_r == NULL)
 150                 return False;
 151
 152         prs_debug(ps, depth, desc, "reg_io_r_open_hklm");
 153         depth++;
 154
 155         if (!prs_align(ps))
 156                 return False;
 157
 158         if (!smb_io_pol_hnd("", &r_r->pol, ps, depth))
 159                 return False;
 160
 161         if (!prs_ntstatus("status", ps, depth, &r_r->status))
 162                 return False;
 163
 164         return True;
 165 }
 166
 167
 168 /*******************************************************************
 169  Inits a structure.
 170 ********************************************************************/
 171
 172 void init_reg_q_flush_key(REG_Q_FLUSH_KEY *q_u, POLICY_HND *pol)
 173 {
 174         memcpy(&q_u->pol, pol, sizeof(q_u->pol));
 175 }
 176
 177 /*******************************************************************
 178 reads or writes a structure.
 179 ********************************************************************/
 180
 181 BOOL reg_io_q_flush_key(char *desc,  REG_Q_FLUSH_KEY *r_q, prs_struct *ps, int depth)
 182 {
 183         if (r_q == NULL)
 184                 return False;
 185
 186         prs_debug(ps, depth, desc, "reg_io_q_flush_key");
 187         depth++;
 188
 189         if(!prs_align(ps))
 190                 return False;
 191
 192         if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
 193                 return False;
 194
 195         return True;
 196 }
 197
 198 /*******************************************************************
 199 reads or writes a structure.
 200 ********************************************************************/
 201
 202 BOOL reg_io_r_flush_key(char *desc,  REG_R_FLUSH_KEY *r_r, prs_struct *ps, int depth)
 203 {
 204         if (r_r == NULL)
 205                 return False;
 206
 207         prs_debug(ps, depth, desc, "reg_io_r_flush_key");
 208         depth++;
 209
 210         if(!prs_align(ps))
 211                 return False;
 212
 213         if(!prs_ntstatus("status", ps, depth, &r_r->status))
 214                 return False;
 215
 216         return True;
 217 }
 218
 219 /*******************************************************************
 220 reads or writes SEC_DESC_BUF and SEC_DATA structures.
 221 ********************************************************************/
 222
 223 static BOOL reg_io_hdrbuf_sec(uint32 ptr, uint32 *ptr3, BUFHDR *hdr_sec, SEC_DESC_BUF *data, prs_struct *ps, int depth)
 224 {
 225         if (ptr != 0) {
 226                 uint32 hdr_offset;
 227                 uint32 old_offset;
 228                 if(!smb_io_hdrbuf_pre("hdr_sec", hdr_sec, ps, depth, &hdr_offset))
 229                         return False;
 230
 231                 old_offset = prs_offset(ps);
 232
 233                 if (ptr3 != NULL) {
 234                         if(!prs_uint32("ptr3", ps, depth, ptr3))
 235                                 return False;
 236                 }
 237
 238                 if (ptr3 == NULL || *ptr3 != 0) {
 239                         if(!sec_io_desc_buf("data   ", &data, ps, depth)) /* JRA - this line is probably wrong... */
 240                                 return False;
 241                 }
 242
 243                 if(!smb_io_hdrbuf_post("hdr_sec", hdr_sec, ps, depth, hdr_offset,
 244                                    data->max_len, data->len))
 245                                 return False;
 246                 if(!prs_set_offset(ps, old_offset + data->len + sizeof(uint32) * ((ptr3 != NULL) ? 5 : 3)))
 247                         return False;
 248
 249                 if(!prs_align(ps))
 250                         return False;
 251         }
 252
 253         return True;
 254 }
 255
 256 /*******************************************************************
 257  Inits a structure.
 258 ********************************************************************/
 259
 260 void init_reg_q_create_key(REG_Q_CREATE_KEY *q_c, POLICY_HND *hnd,
 261                                 char *name, char *class, SEC_ACCESS *sam_access,
 262                                 SEC_DESC_BUF *sec_buf)
 263 {
 264         int len_name  = name  != NULL ? strlen(name ) + 1: 0;
 265         int len_class = class != NULL ? strlen(class) + 1: 0;
 266
 267         ZERO_STRUCTP(q_c);
 268
 269         memcpy(&q_c->pnt_pol, hnd, sizeof(q_c->pnt_pol));
 270
 271         init_uni_hdr(&q_c->hdr_name, len_name);
 272         init_unistr2(&q_c->uni_name, name, len_name);
 273
 274         init_uni_hdr(&q_c->hdr_class, len_class);
 275         init_unistr2(&q_c->uni_class, class, len_class);
 276
 277         q_c->reserved = 0x00000000;
 278         memcpy(&q_c->sam_access, sam_access, sizeof(q_c->sam_access));
 279
 280         q_c->ptr1 = 1;
 281         q_c->sec_info = DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION;
 282
 283         q_c->data = sec_buf;
 284         q_c->ptr2 = 1;
 285         init_buf_hdr(&q_c->hdr_sec, sec_buf->len, sec_buf->len);
 286         q_c->ptr3 = 1;
 287         q_c->unknown_2 = 0x00000000;
 288 }
 289
 290 /*******************************************************************
 291 reads or writes a structure.
 292 ********************************************************************/
 293
 294 BOOL reg_io_q_create_key(char *desc,  REG_Q_CREATE_KEY *r_q, prs_struct *ps, int depth)
 295 {
 296         if (r_q == NULL)
 297                 return False;
 298
 299         prs_debug(ps, depth, desc, "reg_io_q_create_key");
 300         depth++;
 301
 302         if(!prs_align(ps))
 303                 return False;
 304
 305         if(!smb_io_pol_hnd("", &r_q->pnt_pol, ps, depth))
 306                 return False;
 307
 308         if(!smb_io_unihdr ("", &r_q->hdr_name, ps, depth))
 309                 return False;
 310         if(!smb_io_unistr2("", &r_q->uni_name, r_q->hdr_name.buffer, ps, depth))
 311                 return False;
 312         if(!prs_align(ps))
 313                 return False;
 314
 315         if(!smb_io_unihdr ("", &r_q->hdr_class, ps, depth))
 316                 return False;
 317         if(!smb_io_unistr2("", &r_q->uni_class, r_q->hdr_class.buffer, ps, depth))
 318                 return False;
 319         if(!prs_align(ps))
 320                 return False;
 321
 322         if(!prs_uint32("reserved", ps, depth, &r_q->reserved))
 323                 return False;
 324         if(!sec_io_access("sam_access", &r_q->sam_access, ps, depth))
 325                 return False;
 326
 327         if(!prs_uint32("ptr1", ps, depth, &r_q->ptr1))
 328                 return False;
 329
 330         if (r_q->ptr1 != 0) {
 331                 if(!prs_uint32("sec_info", ps, depth, &r_q->sec_info))
 332                         return False;
 333         }
 334
 335         if(!prs_uint32("ptr2", ps, depth, &r_q->ptr2))
 336                 return False;
 337         if(!reg_io_hdrbuf_sec(r_q->ptr2, &r_q->ptr3, &r_q->hdr_sec, r_q->data, ps, depth))
 338                 return False;
 339
 340         if(!prs_uint32("unknown_2", ps, depth, &r_q->unknown_2))
 341                 return False;
 342
 343         return True;
 344 }
 345
 346 /*******************************************************************
 347 reads or writes a structure.
 348 ********************************************************************/
 349
 350 BOOL reg_io_r_create_key(char *desc,  REG_R_CREATE_KEY *r_r, prs_struct *ps, int depth)
 351 {
 352         if (r_r == NULL)
 353                 return False;
 354
 355         prs_debug(ps, depth, desc, "reg_io_r_create_key");
 356         depth++;
 357
 358         if(!prs_align(ps))
 359                 return False;
 360
 361         if(!smb_io_pol_hnd("", &r_r->key_pol, ps, depth))
 362                 return False;
 363         if(!prs_uint32("unknown", ps, depth, &r_r->unknown))
 364                 return False;
 365
 366         if(!prs_ntstatus("status", ps, depth, &r_r->status))
 367                 return False;
 368
 369         return True;
 370 }
 371
 372
 373 /*******************************************************************
 374  Inits a structure.
 375 ********************************************************************/
 376
 377 void init_reg_q_delete_val(REG_Q_DELETE_VALUE *q_c, POLICY_HND *hnd,
 378                                 char *name)
 379 {
 380         int len_name  = name  != NULL ? strlen(name ) + 1: 0;
 381         ZERO_STRUCTP(q_c);
 382
 383         memcpy(&q_c->pnt_pol, hnd, sizeof(q_c->pnt_pol));
 384
 385         init_uni_hdr(&q_c->hdr_name, len_name);
 386         init_unistr2(&q_c->uni_name, name, len_name);
 387 }
 388
 389 /*******************************************************************
 390 reads or writes a structure.
 391 ********************************************************************/
 392
 393 BOOL reg_io_q_delete_val(char *desc,  REG_Q_DELETE_VALUE *r_q, prs_struct *ps, int depth)
 394 {
 395         if (r_q == NULL)
 396                 return False;
 397
 398         prs_debug(ps, depth, desc, "reg_io_q_delete_val");
 399         depth++;
 400
 401         if(!prs_align(ps))
 402                 return False;
 403
 404         if(!smb_io_pol_hnd("", &r_q->pnt_pol, ps, depth))
 405                 return False;
 406
 407         if(!smb_io_unihdr ("", &r_q->hdr_name, ps, depth))
 408                 return False;
 409         if(!smb_io_unistr2("", &r_q->uni_name, r_q->hdr_name.buffer, ps, depth))
 410                 return False;
 411         if(!prs_align(ps))
 412                 return False;
 413
 414         return True;
 415 }
 416
 417
 418 /*******************************************************************
 419 reads or writes a structure.
 420 ********************************************************************/
 421
 422 BOOL reg_io_r_delete_val(char *desc,  REG_R_DELETE_VALUE *r_r, prs_struct *ps, int depth)
 423 {
 424         if (r_r == NULL)
 425                 return False;
 426
 427         prs_debug(ps, depth, desc, "reg_io_r_delete_val");
 428         depth++;
 429
 430         if(!prs_align(ps))
 431                 return False;
 432
 433         if(!prs_ntstatus("status", ps, depth, &r_r->status))
 434                 return False;
 435
 436         return True;
 437 }
 438
 439 /*******************************************************************
 440  Inits a structure.
 441 ********************************************************************/
 442
 443 void init_reg_q_delete_key(REG_Q_DELETE_KEY *q_c, POLICY_HND *hnd,
 444                                 char *name)
 445 {
 446         int len_name  = name  != NULL ? strlen(name ) + 1: 0;
 447         ZERO_STRUCTP(q_c);
 448
 449         memcpy(&q_c->pnt_pol, hnd, sizeof(q_c->pnt_pol));
 450
 451         init_uni_hdr(&q_c->hdr_name, len_name);
 452         init_unistr2(&q_c->uni_name, name, len_name);
 453 }
 454
 455 /*******************************************************************
 456 reads or writes a structure.
 457 ********************************************************************/
 458
 459 BOOL reg_io_q_delete_key(char *desc,  REG_Q_DELETE_KEY *r_q, prs_struct *ps, int depth)
 460 {
 461         if (r_q == NULL)
 462                 return False;
 463
 464         prs_debug(ps, depth, desc, "reg_io_q_delete_key");
 465         depth++;
 466
 467         if(!prs_align(ps))
 468                 return False;
 469
 470         if(!smb_io_pol_hnd("", &r_q->pnt_pol, ps, depth))
 471                 return False;
 472
 473         if(!smb_io_unihdr ("", &r_q->hdr_name, ps, depth))
 474                 return False;
 475         if(!smb_io_unistr2("", &r_q->uni_name, r_q->hdr_name.buffer, ps, depth))
 476                 return False;
 477         if(!prs_align(ps))
 478                 return False;
 479
 480         return True;
 481 }
 482
 483 /*******************************************************************
 484 reads or writes a structure.
 485 ********************************************************************/
 486
 487 BOOL reg_io_r_delete_key(char *desc,  REG_R_DELETE_KEY *r_r, prs_struct *ps, int depth)
 488 {
 489         if (r_r == NULL)
 490                 return False;
 491
 492         prs_debug(ps, depth, desc, "reg_io_r_delete_key");
 493         depth++;
 494
 495         if(!prs_align(ps))
 496                 return False;
 497
 498         if(!prs_ntstatus("status", ps, depth, &r_r->status))
 499                 return False;
 500
 501         return True;
 502 }
 503
 504 /*******************************************************************
 505  Inits a structure.
 506 ********************************************************************/
 507
 508 void init_reg_q_query_key(REG_Q_QUERY_KEY *q_o, POLICY_HND *hnd,
 509                                 uint32 max_class_len)
 510 {
 511         ZERO_STRUCTP(q_o);
 512
 513         memcpy(&q_o->pol, hnd, sizeof(q_o->pol));
 514         init_uni_hdr(&q_o->hdr_class, max_class_len);
 515         q_o->uni_class.uni_max_len = max_class_len;
 516 }
 517
 518 /*******************************************************************
 519 reads or writes a structure.
 520 ********************************************************************/
 521
 522 BOOL reg_io_q_query_key(char *desc,  REG_Q_QUERY_KEY *r_q, prs_struct *ps, int depth)
 523 {
 524         if (r_q == NULL)
 525                 return False;
 526
 527         prs_debug(ps, depth, desc, "reg_io_q_query_key");
 528         depth++;
 529
 530         if(!prs_align(ps))
 531                 return False;
 532
 533         if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
 534                 return False;
 535         if(!smb_io_unihdr ("", &r_q->hdr_class, ps, depth))
 536                 return False;
 537         if(!smb_io_unistr2("", &r_q->uni_class, r_q->hdr_class.buffer, ps, depth))
 538                 return False;
 539
 540         if(!prs_align(ps))
 541                 return False;
 542
 543         return True;
 544 }
 545
 546
 547 /*******************************************************************
 548 reads or writes a structure.
 549 ********************************************************************/
 550
 551 BOOL reg_io_r_query_key(char *desc,  REG_R_QUERY_KEY *r_r, prs_struct *ps, int depth)
 552 {
 553         if (r_r == NULL)
 554                 return False;
 555
 556         prs_debug(ps, depth, desc, "reg_io_r_query_key");
 557         depth++;
 558
 559         if(!prs_align(ps))
 560                 return False;
 561
 562         if(!smb_io_unihdr ("", &r_r->hdr_class, ps, depth))
 563                 return False;
 564         if(!smb_io_unistr2("", &r_r->uni_class, r_r->hdr_class.buffer, ps, depth))
 565                 return False;
 566
 567         if(!prs_align(ps))
 568                 return False;
 569
 570         if(!prs_uint32("num_subkeys   ", ps, depth, &r_r->num_subkeys))
 571                 return False;
 572         if(!prs_uint32("max_subkeylen ", ps, depth, &r_r->max_subkeylen))
 573                 return False;
 574         if(!prs_uint32("mak_subkeysize", ps, depth, &r_r->max_subkeysize))
 575                 return False;
 576         if(!prs_uint32("num_values    ", ps, depth, &r_r->num_values))
 577                 return False;
 578         if(!prs_uint32("max_valnamelen", ps, depth, &r_r->max_valnamelen))
 579                 return False;
 580         if(!prs_uint32("max_valbufsize", ps, depth, &r_r->max_valbufsize))
 581                 return False;
 582         if(!prs_uint32("sec_desc      ", ps, depth, &r_r->sec_desc))
 583                 return False;
 584         if(!smb_io_time("mod_time     ", &r_r->mod_time, ps, depth))
 585                 return False;
 586
 587         if(!prs_ntstatus("status", ps, depth, &r_r->status))
 588                 return False;
 589
 590         return True;
 591 }
 592
 593 /*******************************************************************
 594  Inits a structure.
 595 ********************************************************************/
 596
 597 void init_reg_q_unk_1a(REG_Q_UNK_1A *q_o, POLICY_HND *hnd)
 598 {
 599         memcpy(&q_o->pol, hnd, sizeof(q_o->pol));
 600 }
 601
 602 /*******************************************************************
 603 reads or writes a structure.
 604 ********************************************************************/
 605
 606 BOOL reg_io_q_unk_1a(char *desc,  REG_Q_UNK_1A *r_q, prs_struct *ps, int depth)
 607 {
 608         if (r_q == NULL)
 609                 return False;
 610
 611         prs_debug(ps, depth, desc, "reg_io_q_unk_1a");
 612         depth++;
 613
 614         if(!prs_align(ps))
 615                 return False;
 616
 617         if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
 618                 return False;
 619
 620         return True;
 621 }
 622
 623 /*******************************************************************
 624 reads or writes a structure.
 625 ********************************************************************/
 626
 627 BOOL reg_io_r_unk_1a(char *desc,  REG_R_UNK_1A *r_r, prs_struct *ps, int depth)
 628 {
 629         if (r_r == NULL)
 630                 return False;
 631
 632         prs_debug(ps, depth, desc, "reg_io_r_unk_1a");
 633         depth++;
 634
 635         if(!prs_align(ps))
 636                 return False;
 637
 638         if(!prs_uint32("unknown", ps, depth, &r_r->unknown))
 639                 return False;
 640         if(!prs_ntstatus("status" , ps, depth, &r_r->status))
 641                 return False;
 642
 643         return True;
 644 }
 645
 646 /*******************************************************************
 647  Inits a structure.
 648 ********************************************************************/
 649
 650 void init_reg_q_open_hku(REG_Q_OPEN_HKU *q_o,
 651                                 uint16 unknown_0, uint32 level)
 652 {
 653         q_o->ptr = 1;
 654         q_o->unknown_0 = unknown_0;
 655         q_o->unknown_1 = 0x0; /* random - changes */
 656         q_o->level = level;
 657 }
 658
 659 /*******************************************************************
 660 reads or writes a structure.
 661 ********************************************************************/
 662
 663 BOOL reg_io_q_open_hku(char *desc,  REG_Q_OPEN_HKU *r_q, prs_struct *ps, int depth)
 664 {
 665         if (r_q == NULL)
 666                 return False;
 667
 668         prs_debug(ps, depth, desc, "reg_io_q_open_hku");
 669         depth++;
 670
 671         if(!prs_align(ps))
 672                 return False;
 673
 674         if(!prs_uint32("ptr      ", ps, depth, &r_q->ptr))
 675                 return False;
 676         if (r_q->ptr != 0) {
 677                 if(!prs_uint16("unknown_0", ps, depth, &r_q->unknown_0))
 678                         return False;
 679                 if(!prs_uint16("unknown_1", ps, depth, &r_q->unknown_1))
 680                         return False;
 681                 if(!prs_uint32("level    ", ps, depth, &r_q->level))
 682                         return False;
 683         }
 684
 685         return True;
 686 }
 687
 688 /*******************************************************************
 689 reads or writes a structure.
 690 ********************************************************************/
 691
 692 BOOL reg_io_r_open_hku(char *desc,  REG_R_OPEN_HKU *r_r, prs_struct *ps, int depth)
 693 {
 694         if (r_r == NULL)
 695                 return False;
 696
 697         prs_debug(ps, depth, desc, "reg_io_r_open_hku");
 698         depth++;
 699
 700         if(!prs_align(ps))
 701                 return False;
 702
 703         if(!smb_io_pol_hnd("", &r_r->pol, ps, depth))
 704                 return False;
 705
 706         if(!prs_ntstatus("status", ps, depth, &r_r->status))
 707                 return False;
 708
 709         return True;
 710 }
 711
 712 /*******************************************************************
 713  Inits an REG_Q_CLOSE structure.
 714 ********************************************************************/
 715
 716 void init_reg_q_close(REG_Q_CLOSE *q_c, POLICY_HND *hnd)
 717 {
 718         DEBUG(5,("init_reg_q_close\n"));
 719
 720         memcpy(&q_c->pol, hnd, sizeof(q_c->pol));
 721 }
 722
 723 /*******************************************************************
 724 reads or writes a structure.
 725 ********************************************************************/
 726
 727 BOOL reg_io_q_close(char *desc,  REG_Q_CLOSE *q_u, prs_struct *ps, int depth)
 728 {
 729         if (q_u == NULL)
 730                 return False;
 731
 732         prs_debug(ps, depth, desc, "reg_io_q_unknown_1");
 733         depth++;
 734
 735         if(!prs_align(ps))
 736                 return False;
 737
 738         if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
 739                 return False;
 740         if(!prs_align(ps))
 741                 return False;
 742
 743         return True;
 744 }
 745
 746 /*******************************************************************
 747 reads or writes a structure.
 748 ********************************************************************/
 749
 750 BOOL reg_io_r_close(char *desc,  REG_R_CLOSE *r_u, prs_struct *ps, int depth)
 751 {
 752         if (r_u == NULL)
 753                 return False;
 754
 755         prs_debug(ps, depth, desc, "reg_io_r_unknown_1");
 756         depth++;
 757
 758         if(!prs_align(ps))
 759                 return False;
 760
 761         if(!smb_io_pol_hnd("", &r_u->pol, ps, depth))
 762                 return False;
 763         if(!prs_align(ps))
 764                 return False;
 765
 766         if(!prs_ntstatus("status", ps, depth, &r_u->status))
 767                 return False;
 768
 769         return True;
 770 }
 771
 772 /*******************************************************************
 773 makes a structure.
 774 ********************************************************************/
 775
 776 void init_reg_q_set_key_sec(REG_Q_SET_KEY_SEC *q_i, POLICY_HND *pol, SEC_DESC_BUF *sec_desc_buf)
 777 {
 778         memcpy(&q_i->pol, pol, sizeof(q_i->pol));
 779
 780         q_i->sec_info = DACL_SECURITY_INFORMATION;
 781
 782         q_i->ptr = 1;
 783         init_buf_hdr(&q_i->hdr_sec, sec_desc_buf->len, sec_desc_buf->len);
 784         q_i->data = sec_desc_buf;
 785 }
 786
 787 /*******************************************************************
 788 reads or writes a structure.
 789 ********************************************************************/
 790
 791 BOOL reg_io_q_set_key_sec(char *desc,  REG_Q_SET_KEY_SEC *r_q, prs_struct *ps, int depth)
 792 {
 793         if (r_q == NULL)
 794                 return False;
 795
 796         prs_debug(ps, depth, desc, "reg_io_q_set_key_sec");
 797         depth++;
 798
 799         if(!prs_align(ps))
 800                 return False;
 801
 802         if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
 803                 return False;
 804
 805         if(!prs_uint32("sec_info", ps, depth, &r_q->sec_info))
 806                 return False;
 807         if(!prs_uint32("ptr    ", ps, depth, &r_q->ptr))
 808                 return False;
 809
 810         if(!reg_io_hdrbuf_sec(r_q->ptr, NULL, &r_q->hdr_sec, r_q->data, ps, depth))
 811                 return False;
 812
 813         return True;
 814 }
 815
 816 /*******************************************************************
 817 reads or writes a structure.
 818 ********************************************************************/
 819
 820 BOOL reg_io_r_set_key_sec(char *desc, REG_R_SET_KEY_SEC *r_q, prs_struct *ps, int depth)
 821 {
 822         if (r_q == NULL)
 823                 return False;
 824
 825         prs_debug(ps, depth, desc, "reg_io_r_set_key_sec");
 826         depth++;
 827
 828         if(!prs_align(ps))
 829                 return False;
 830
 831         if(!prs_ntstatus("status", ps, depth, &r_q->status))
 832                 return False;
 833
 834         return True;
 835 }
 836
 837
 838 /*******************************************************************
 839 makes a structure.
 840 ********************************************************************/
 841
 842 void init_reg_q_get_key_sec(REG_Q_GET_KEY_SEC *q_i, POLICY_HND *pol,
 843                                 uint32 sec_buf_size, SEC_DESC_BUF *psdb)
 844 {
 845         memcpy(&q_i->pol, pol, sizeof(q_i->pol));
 846
 847         q_i->sec_info = OWNER_SECURITY_INFORMATION |
 848                         GROUP_SECURITY_INFORMATION |
 849                         DACL_SECURITY_INFORMATION;
 850
 851         q_i->ptr = psdb != NULL ? 1 : 0;
 852         q_i->data = psdb;
 853
 854         init_buf_hdr(&q_i->hdr_sec, sec_buf_size, 0);
 855 }
 856
 857 /*******************************************************************
 858 reads or writes a structure.
 859 ********************************************************************/
 860
 861 BOOL reg_io_q_get_key_sec(char *desc,  REG_Q_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
 862 {
 863         if (r_q == NULL)
 864                 return False;
 865
 866         prs_debug(ps, depth, desc, "reg_io_q_get_key_sec");
 867         depth++;
 868
 869         if(!prs_align(ps))
 870                 return False;
 871
 872         if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
 873                 return False;
 874
 875         if(!prs_uint32("sec_info", ps, depth, &r_q->sec_info))
 876                 return False;
 877         if(!prs_uint32("ptr     ", ps, depth, &r_q->ptr))
 878                 return False;
 879
 880         if(!reg_io_hdrbuf_sec(r_q->ptr, NULL, &r_q->hdr_sec, r_q->data, ps, depth))
 881                 return False;
 882
 883         return True;
 884 }
 885
 886 #if 0
 887 /*******************************************************************
 888 makes a structure.
 889 ********************************************************************/
 890  void init_reg_r_get_key_sec(REG_R_GET_KEY_SEC *r_i, POLICY_HND *pol,
 891                                 uint32 buf_len, uint8 *buf,
 892                                 NTSTATUS status)
 893 {
 894         r_i->ptr = 1;
 895         init_buf_hdr(&r_i->hdr_sec, buf_len, buf_len);
 896         init_sec_desc_buf(r_i->data, buf_len, 1);
 897
 898         r_i->status = status; /* 0x0000 0000 or 0x0000 007a */
 899 }
 900 #endif
 901
 902 /*******************************************************************
 903 reads or writes a structure.
 904 ********************************************************************/
 905
 906 BOOL reg_io_r_get_key_sec(char *desc,  REG_R_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
 907 {
 908         if (r_q == NULL)
 909                 return False;
 910
 911         prs_debug(ps, depth, desc, "reg_io_r_get_key_sec");
 912         depth++;
 913
 914         if(!prs_align(ps))
 915                 return False;
 916
 917         if(!prs_uint32("ptr      ", ps, depth, &r_q->ptr))
 918                 return False;
 919
 920         if (r_q->ptr != 0) {
 921                 if(!smb_io_hdrbuf("", &r_q->hdr_sec, ps, depth))
 922                         return False;
 923                 if(!sec_io_desc_buf("", &r_q->data, ps, depth))
 924                         return False;
 925                 if(!prs_align(ps))
 926                         return False;
 927         }
 928
 929         if(!prs_ntstatus("status", ps, depth, &r_q->status))
 930                 return False;
 931
 932         return True;
 933 }
 934
 935 /*******************************************************************
 936 makes a structure.
 937 ********************************************************************/
 938
 939 BOOL init_reg_q_info(REG_Q_INFO *q_i, POLICY_HND *pol, char* val_name)
 940 {
 941         int len_type = val_name != NULL ? strlen(val_name) + 1 : 0;
 942
 943         if (q_i == NULL)
 944                 return False;
 945
 946         q_i->pol = *pol;
 947
 948         init_uni_hdr(&(q_i->hdr_type), len_type);
 949         init_unistr2(&(q_i->uni_type), val_name, len_type);
 950
 951         q_i->ptr_reserved = 1;
 952         q_i->ptr_buf = 1;
 953
 954         q_i->ptr_bufsize = 1;
 955         q_i->bufsize = 0;
 956         q_i->buf_unk = 0;
 957
 958         q_i->unk1 = 0;
 959         q_i->ptr_buflen = 1;
 960         q_i->buflen = 0;
 961
 962         q_i->ptr_buflen2 = 1;
 963         q_i->buflen2 = 0;
 964
 965         return True;
 966 }
 967
 968 /*******************************************************************
 969 reads or writes a structure.
 970 ********************************************************************/
 971
 972 BOOL reg_io_q_info(char *desc,  REG_Q_INFO *r_q, prs_struct *ps, int depth)
 973 {
 974         if (r_q == NULL)
 975                 return False;
 976
 977         prs_debug(ps, depth, desc, "reg_io_q_info");
 978         depth++;
 979
 980         if(!prs_align(ps))
 981                 return False;
 982
 983         if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
 984                 return False;
 985         if(!smb_io_unihdr ("", &r_q->hdr_type, ps, depth))
 986                 return False;
 987         if(!smb_io_unistr2("", &r_q->uni_type, r_q->hdr_type.buffer, ps, depth))
 988                 return False;
 989
 990         if(!prs_align(ps))
 991                 return False;
 992
 993         if(!prs_uint32("ptr_reserved", ps, depth, &(r_q->ptr_reserved)))
 994                 return False;
 995
 996         if(!prs_uint32("ptr_buf", ps, depth, &(r_q->ptr_buf)))
 997                 return False;
 998
 999         if(r_q->ptr_buf) {
1000                 if(!prs_uint32("ptr_bufsize", ps, depth, &(r_q->ptr_bufsize)))
1001                         return False;
1002                 if(!prs_uint32("bufsize", ps, depth, &(r_q->bufsize)))
1003                         return False;
1004                 if(!prs_uint32("buf_unk", ps, depth, &(r_q->buf_unk)))
1005                         return False;
1006         }
1007
1008         if(!prs_uint32("unk1", ps, depth, &(r_q->unk1)))
1009                 return False;
1010
1011         if(!prs_uint32("ptr_buflen", ps, depth, &(r_q->ptr_buflen)))
1012                 return False;
1013         if(!prs_uint32("buflen", ps, depth, &(r_q->buflen)))
1014                 return False;
1015
1016         if(!prs_uint32("ptr_buflen2", ps, depth, &(r_q->ptr_buflen2)))
1017                 return False;
1018         if(!prs_uint32("buflen2", ps, depth, &(r_q->buflen2)))
1019                 return False;
1020
1021         return True;
1022 }
1023
1024 /*******************************************************************
1025  Inits a structure.
1026 ********************************************************************/
1027
1028 BOOL init_reg_r_info(uint32 include_keyval, REG_R_INFO *r_r,
1029                      BUFFER2* buf, uint32 type, NTSTATUS status)
1030 {
1031   if(r_r == NULL)
1032     return False;
1033
1034
1035   r_r->ptr_type = 1;
1036   r_r->type = type;
1037
1038   /* if include_keyval is not set, don't send the key value, just
1039      the buflen data. probably used by NT5 to allocate buffer space - SK */
1040   r_r->ptr_uni_val = include_keyval ? 1:0;
1041   r_r->uni_val = buf;
1042
1043   r_r->ptr_max_len = 1;
1044   r_r->buf_max_len = r_r->uni_val->buf_max_len;
1045
1046   r_r->ptr_len = 1;
1047   r_r->buf_len = r_r->uni_val->buf_len;
1048
1049   r_r->status = status;
1050
1051   return True;
1052
1053 }
1054
1055 /*******************************************************************
1056 reads or writes a structure.
1057 ********************************************************************/
1058
1059 BOOL reg_io_r_info(char *desc, REG_R_INFO *r_r, prs_struct *ps, int depth)
1060 {
1061         if (r_r == NULL)
1062                 return False;
1063
1064         prs_debug(ps, depth, desc, "reg_io_r_info");
1065         depth++;
1066
1067         if(!prs_align(ps))
1068                 return False;
1069
1070         if(!prs_uint32("ptr_type", ps, depth, &(r_r->ptr_type)))
1071                 return False;
1072
1073         if (r_r->ptr_type != 0) {
1074                 if(!prs_uint32("type", ps, depth, &r_r->type))
1075                         return False;
1076         }
1077
1078         if(!prs_uint32("ptr_uni_val", ps, depth, &(r_r->ptr_uni_val)))
1079                 return False;
1080
1081         if(r_r->ptr_uni_val != 0) {
1082                 if(!smb_io_buffer2("uni_val", r_r->uni_val, r_r->ptr_uni_val, ps, depth))
1083                         return False;
1084         }
1085
1086         if(!prs_align(ps))
1087                 return False;
1088
1089         if(!prs_uint32("ptr_max_len", ps, depth, &(r_r->ptr_max_len)))
1090                 return False;
1091
1092         if (r_r->ptr_max_len != 0) {
1093                 if(!prs_uint32("buf_max_len", ps, depth, &(r_r->buf_max_len)))
1094                 return False;
1095         }
1096
1097         if(!prs_uint32("ptr_len", ps, depth, &(r_r->ptr_len)))
1098                 return False;
1099         if (r_r->ptr_len != 0) {
1100                 if(!prs_uint32("buf_len", ps, depth, &(r_r->buf_len)))
1101                         return False;
1102         }
1103
1104         if(!prs_ntstatus("status", ps, depth, &r_r->status))
1105                 return False;
1106
1107         return True;
1108 }
1109
1110 /*******************************************************************
1111 makes a structure.
1112 ********************************************************************/
1113
1114 void init_reg_q_enum_val(REG_Q_ENUM_VALUE *q_i, POLICY_HND *pol,
1115                                 uint32 val_idx, uint32 max_val_len,
1116                                 uint32 max_buf_len)
1117 {
1118         ZERO_STRUCTP(q_i);
1119
1120         memcpy(&q_i->pol, pol, sizeof(q_i->pol));
1121
1122         q_i->val_index = val_idx;
1123         init_uni_hdr(&q_i->hdr_name, max_val_len);
1124         q_i->uni_name.uni_max_len = max_val_len;
1125
1126         q_i->ptr_type = 1;
1127         q_i->type = 0x0;
1128
1129         q_i->ptr_value = 1;
1130         q_i->buf_value.buf_max_len = max_buf_len;
1131
1132         q_i->ptr1 = 1;
1133         q_i->len_value1 = max_buf_len;
1134
1135         q_i->ptr2 = 1;
1136         q_i->len_value2 = 0;
1137 }
1138
1139 /*******************************************************************
1140 reads or writes a structure.
1141 ********************************************************************/
1142
1143 BOOL reg_io_q_enum_val(char *desc,  REG_Q_ENUM_VALUE *q_q, prs_struct *ps, int depth)
1144 {
1145         if (q_q == NULL)
1146                 return False;
1147
1148         prs_debug(ps, depth, desc, "reg_io_q_enum_val");
1149         depth++;
1150
1151         if(!prs_align(ps))
1152                 return False;
1153
1154         if(!smb_io_pol_hnd("", &q_q->pol, ps, depth))
1155                 return False;
1156
1157         if(!prs_uint32("val_index", ps, depth, &q_q->val_index))
1158                 return False;
1159         if(!smb_io_unihdr ("hdr_name", &q_q->hdr_name, ps, depth))
1160                 return False;
1161         if(!smb_io_unistr2("uni_name", &q_q->uni_name, q_q->hdr_name.buffer, ps, depth))
1162                 return False;
1163         if(!prs_align(ps))
1164                 return False;
1165
1166         if(!prs_uint32("ptr_type", ps, depth, &q_q->ptr_type))
1167                 return False;
1168
1169         if (q_q->ptr_type != 0) {
1170                 if(!prs_uint32("type", ps, depth, &q_q->type))
1171                         return False;
1172         }
1173
1174         if(!prs_uint32("ptr_value", ps, depth, &q_q->ptr_value))
1175                 return False;
1176         if(!smb_io_buffer2("buf_value", &q_q->buf_value, q_q->ptr_value, ps, depth))
1177                 return False;
1178         if(!prs_align(ps))
1179                 return False;
1180
1181         if(!prs_uint32("ptr1", ps, depth, &q_q->ptr1))
1182                 return False;
1183         if (q_q->ptr1 != 0) {
1184                 if(!prs_uint32("len_value1", ps, depth, &q_q->len_value1))
1185                         return False;
1186         }
1187         if(!prs_uint32("ptr2", ps, depth, &q_q->ptr2))
1188                 return False;
1189         if (q_q->ptr2 != 0) {
1190                 if(!prs_uint32("len_value2", ps, depth, &q_q->len_value2))
1191                         return False;
1192         }
1193
1194         return True;
1195 }
1196
1197 /*******************************************************************
1198 reads or writes a structure.
1199 ********************************************************************/
1200
1201 BOOL reg_io_r_enum_val(char *desc,  REG_R_ENUM_VALUE *r_q, prs_struct *ps, int depth)
1202 {
1203         if (r_q == NULL)
1204                 return False;
1205
1206         prs_debug(ps, depth, desc, "reg_io_r_enum_val");
1207         depth++;
1208
1209         if(!prs_align(ps))
1210                 return False;
1211
1212         if(!smb_io_unihdr ("hdr_name", &r_q->hdr_name, ps, depth))
1213                 return False;
1214         if(!smb_io_unistr2("uni_name", &r_q->uni_name, r_q->hdr_name.buffer, ps, depth))
1215                 return False;
1216         if(!prs_align(ps))
1217                 return False;
1218
1219         if(!prs_uint32("ptr_type", ps, depth, &r_q->ptr_type))
1220                 return False;
1221
1222         if (r_q->ptr_type != 0) {
1223                 if(!prs_uint32("type", ps, depth, &r_q->type))
1224                         return False;
1225         }
1226
1227         if(!prs_uint32("ptr_value", ps, depth, &r_q->ptr_value))
1228                 return False;
1229         if(!smb_io_buffer2("buf_value", r_q->buf_value, r_q->ptr_value, ps, depth))
1230                 return False;
1231         if(!prs_align(ps))
1232                 return False;
1233
1234         if(!prs_uint32("ptr1", ps, depth, &r_q->ptr1))
1235                 return False;
1236         if (r_q->ptr1 != 0) {
1237                 if(!prs_uint32("len_value1", ps, depth, &r_q->len_value1))
1238                         return False;
1239         }
1240
1241         if(!prs_uint32("ptr2", ps, depth, &r_q->ptr2))
1242                 return False;
1243         if (r_q->ptr2 != 0) {
1244                 if(!prs_uint32("len_value2", ps, depth, &r_q->len_value2))
1245                         return False;
1246         }
1247
1248         if(!prs_ntstatus("status", ps, depth, &r_q->status))
1249                 return False;
1250
1251         return True;
1252 }
1253
1254 /*******************************************************************
1255 makes a structure.
1256 ********************************************************************/
1257
1258 void init_reg_q_create_val(REG_Q_CREATE_VALUE *q_i, POLICY_HND *pol,
1259                                 char *val_name, uint32 type,
1260                                 BUFFER3 *val)
1261 {
1262         int val_len = strlen(val_name) + 1;
1263
1264         ZERO_STRUCTP(q_i);
1265
1266         memcpy(&q_i->pol, pol, sizeof(q_i->pol));
1267
1268         init_uni_hdr(&q_i->hdr_name, val_len);
1269         init_unistr2(&q_i->uni_name, val_name, val_len);
1270
1271         q_i->type      = type;
1272         q_i->buf_value = val;
1273 }
1274
1275 /*******************************************************************
1276 reads or writes a structure.
1277 ********************************************************************/
1278
1279 BOOL reg_io_q_create_val(char *desc,  REG_Q_CREATE_VALUE *q_q, prs_struct *ps, int depth)
1280 {
1281         if (q_q == NULL)
1282                 return False;
1283
1284         prs_debug(ps, depth, desc, "reg_io_q_create_val");
1285         depth++;
1286
1287         if(!prs_align(ps))
1288                 return False;
1289
1290         if(!smb_io_pol_hnd("", &q_q->pol, ps, depth))
1291                 return False;
1292
1293         if(!smb_io_unihdr ("hdr_name", &q_q->hdr_name, ps, depth))
1294                 return False;
1295         if(!smb_io_unistr2("uni_name", &q_q->uni_name, q_q->hdr_name.buffer, ps, depth))
1296                 return False;
1297         if(!prs_align(ps))
1298                 return False;
1299
1300         if(!prs_uint32("type", ps, depth, &q_q->type))
1301                 return False;
1302         if(!smb_io_buffer3("buf_value", q_q->buf_value, ps, depth))
1303                 return False;
1304         if(!prs_align(ps))
1305                 return False;
1306
1307         return True;
1308 }
1309
1310 /*******************************************************************
1311 reads or writes a structure.
1312 ********************************************************************/
1313
1314 BOOL reg_io_r_create_val(char *desc,  REG_R_CREATE_VALUE *r_q, prs_struct *ps, int depth)
1315 {
1316         if (r_q == NULL)
1317                 return False;
1318
1319         prs_debug(ps, depth, desc, "reg_io_r_create_val");
1320         depth++;
1321
1322         if(!prs_align(ps))
1323                 return False;
1324
1325         if(!prs_ntstatus("status", ps, depth, &r_q->status))
1326                 return False;
1327
1328         return True;
1329 }
1330
1331 /*******************************************************************
1332 makes a structure.
1333 ********************************************************************/
1334
1335 void init_reg_q_enum_key(REG_Q_ENUM_KEY *q_i, POLICY_HND *pol, uint32 key_idx)
1336 {
1337         memcpy(&q_i->pol, pol, sizeof(q_i->pol));
1338
1339         q_i->key_index = key_idx;
1340         q_i->key_name_len = 0;
1341         q_i->unknown_1 = 0x0414;
1342
1343         q_i->ptr1 = 1;
1344         q_i->unknown_2 = 0x0000020A;
1345         memset(q_i->pad1, 0, sizeof(q_i->pad1));
1346
1347         q_i->ptr2 = 1;
1348         memset(q_i->pad2, 0, sizeof(q_i->pad2));
1349
1350         q_i->ptr3 = 1;
1351         unix_to_nt_time(&q_i->time, 0);            /* current time? */
1352 }
1353
1354 /*******************************************************************
1355 reads or writes a structure.
1356 ********************************************************************/
1357
1358 BOOL reg_io_q_enum_key(char *desc,  REG_Q_ENUM_KEY *q_q, prs_struct *ps, int depth)
1359 {
1360         if (q_q == NULL)
1361                 return False;
1362
1363         prs_debug(ps, depth, desc, "reg_io_q_enum_key");
1364         depth++;
1365
1366         if(!prs_align(ps))
1367                 return False;
1368
1369         if(!smb_io_pol_hnd("", &q_q->pol, ps, depth))
1370                 return False;
1371
1372         if(!prs_uint32("key_index", ps, depth, &q_q->key_index))
1373                 return False;
1374         if(!prs_uint16("key_name_len", ps, depth, &q_q->key_name_len))
1375                 return False;
1376         if(!prs_uint16("unknown_1", ps, depth, &q_q->unknown_1))
1377                 return False;
1378
1379         if(!prs_uint32("ptr1", ps, depth, &q_q->ptr1))
1380                 return False;
1381
1382         if (q_q->ptr1 != 0) {
1383                 if(!prs_uint32("unknown_2", ps, depth, &q_q->unknown_2))
1384                         return False;
1385                 if(!prs_uint8s(False, "pad1", ps, depth, q_q->pad1, sizeof(q_q->pad1)))
1386                         return False;
1387         }
1388
1389         if(!prs_uint32("ptr2", ps, depth, &q_q->ptr2))
1390                 return False;
1391
1392         if (q_q->ptr2 != 0) {
1393                 if(!prs_uint8s(False, "pad2", ps, depth, q_q->pad2, sizeof(q_q->pad2)))
1394                         return False;
1395         }
1396
1397         if(!prs_uint32("ptr3", ps, depth, &q_q->ptr3))
1398                 return False;
1399
1400         if (q_q->ptr3 != 0) {
1401                 if(!smb_io_time("", &q_q->time, ps, depth))
1402                         return False;
1403         }
1404
1405         return True;
1406 }
1407
1408 /*******************************************************************
1409 reads or writes a structure.
1410 ********************************************************************/
1411
1412 BOOL reg_io_r_enum_key(char *desc,  REG_R_ENUM_KEY *r_q, prs_struct *ps, int depth)
1413 {
1414         if (r_q == NULL)
1415                 return False;
1416
1417         prs_debug(ps, depth, desc, "reg_io_r_enum_key");
1418         depth++;
1419
1420         if(!prs_align(ps))
1421                 return False;
1422
1423         if(!prs_uint16("key_name_len", ps, depth, &r_q->key_name_len))
1424                 return False;
1425         if(!prs_uint16("unknown_1", ps, depth, &r_q->unknown_1))
1426                 return False;
1427
1428         if(!prs_uint32("ptr1", ps, depth, &r_q->ptr1))
1429                 return False;
1430
1431         if (r_q->ptr1 != 0) {
1432                 if(!prs_uint32("unknown_2", ps, depth, &r_q->unknown_2))
1433                         return False;
1434                 if(!prs_uint32("unknown_3", ps, depth, &r_q->unknown_3))
1435                         return False;
1436                 if(!smb_io_unistr3("key_name", &r_q->key_name, ps, depth))
1437                         return False;
1438                 if(!prs_align(ps))
1439                         return False;
1440         }
1441
1442         if(!prs_uint32("ptr2", ps, depth, &r_q->ptr2))
1443                 return False;
1444
1445         if (r_q->ptr2 != 0) {
1446                 if(!prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2)))
1447                         return False;
1448         }
1449
1450         if(!prs_uint32("ptr3", ps, depth, &r_q->ptr3))
1451                 return False;
1452
1453         if (r_q->ptr3 != 0) {
1454                 if(!smb_io_time("", &r_q->time, ps, depth))
1455                         return False;
1456         }
1457
1458         if(!prs_ntstatus("status", ps, depth, &r_q->status))
1459                 return False;
1460
1461         return True;
1462 }
1463
1464 /*******************************************************************
1465 makes a structure.
1466 ********************************************************************/
1467
1468 void init_reg_q_open_entry(REG_Q_OPEN_ENTRY *r_q, POLICY_HND *pol,
1469                                 char *key_name, uint32 unk)
1470 {
1471         int len_name = strlen(key_name)+1;
1472
1473         memcpy(&r_q->pol, pol, sizeof(r_q->pol));
1474
1475         init_uni_hdr(&r_q->hdr_name, len_name);
1476         init_unistr2(&r_q->uni_name, key_name, len_name);
1477
1478         r_q->unknown_0 = 0x00000000;
1479         r_q->unknown_1 = unk;
1480 }
1481
1482 /*******************************************************************
1483 reads or writes a structure.
1484 ********************************************************************/
1485
1486 BOOL reg_io_q_open_entry(char *desc,  REG_Q_OPEN_ENTRY *r_q, prs_struct *ps, int depth)
1487 {
1488         if (r_q == NULL)
1489                 return False;
1490
1491         prs_debug(ps, depth, desc, "reg_io_q_entry");
1492         depth++;
1493
1494         if(!prs_align(ps))
1495                 return False;
1496
1497         if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
1498                 return False;
1499         if(!smb_io_unihdr ("", &r_q->hdr_name, ps, depth))
1500                 return False;
1501         if(!smb_io_unistr2("", &r_q->uni_name, r_q->hdr_name.buffer, ps, depth))
1502                 return False;
1503
1504         if(!prs_align(ps))
1505                 return False;
1506
1507         if(!prs_uint32("unknown_0", ps, depth, &r_q->unknown_0))
1508                 return False;
1509         if(!prs_uint32("unknown_1", ps, depth, &r_q->unknown_1))
1510                 return False;
1511
1512         return True;
1513 }
1514
1515 /*******************************************************************
1516  Inits a structure.
1517 ********************************************************************/
1518
1519 void init_reg_r_open_entry(REG_R_OPEN_ENTRY *r_r,
1520                            POLICY_HND *pol, NTSTATUS status)
1521 {
1522         memcpy(&r_r->pol, pol, sizeof(r_r->pol));
1523         r_r->status = status;
1524 }
1525
1526 /*******************************************************************
1527 reads or writes a structure.
1528 ********************************************************************/
1529
1530 BOOL reg_io_r_open_entry(char *desc,  REG_R_OPEN_ENTRY *r_r, prs_struct *ps, int depth)
1531 {
1532         if (r_r == NULL)
1533                 return False;
1534
1535         prs_debug(ps, depth, desc, "reg_io_r_open_entry");
1536         depth++;
1537
1538         if(!prs_align(ps))
1539                 return False;
1540
1541         if(!smb_io_pol_hnd("", &r_r->pol, ps, depth))
1542                 return False;
1543
1544         if(!prs_ntstatus("status", ps, depth, &r_r->status))
1545                 return False;
1546
1547         return True;
1548 }
1549
1550 /*******************************************************************
1551 Inits a structure.
1552 ********************************************************************/
1553 void init_reg_q_shutdown(REG_Q_SHUTDOWN * q_s,
1554                          const char *msg, uint32 timeout, uint16 flags)
1555 {
1556         int msg_len;
1557         msg_len = strlen(msg);
1558
1559         q_s->ptr_0 = 1;
1560         q_s->ptr_1 = 1;
1561         q_s->ptr_2 = 1;
1562
1563         init_uni_hdr(&(q_s->hdr_msg), msg_len);
1564         init_unistr2(&(q_s->uni_msg), msg, msg_len);
1565
1566         q_s->timeout = timeout;
1567         q_s->flags = flags;
1568
1569 }
1570
1571 /*******************************************************************
1572 reads or writes a structure.
1573 ********************************************************************/
1574 BOOL reg_io_q_shutdown(char *desc, REG_Q_SHUTDOWN * q_s, prs_struct *ps,
1575                        int depth)
1576 {
1577         if (q_s == NULL)
1578                 return False;
1579
1580         prs_debug(ps, depth, desc, "reg_io_q_shutdown");
1581         depth++;
1582
1583         if (!prs_align(ps))
1584                 return False;
1585
1586         if (!prs_uint32("ptr_0", ps, depth, &(q_s->ptr_0)))
1587                 return False;
1588         if (!prs_uint32("ptr_1", ps, depth, &(q_s->ptr_1)))
1589                 return False;
1590         if (!prs_uint32("ptr_2", ps, depth, &(q_s->ptr_2)))
1591                 return False;
1592
1593         if (!smb_io_unihdr("hdr_msg", &(q_s->hdr_msg), ps, depth))
1594                 return False;
1595         if (!smb_io_unistr2("uni_msg", &(q_s->uni_msg), q_s->hdr_msg.buffer, ps, depth))
1596                 return False;
1597         if (!prs_align(ps))
1598                 return False;
1599
1600         if (!prs_uint32("timeout", ps, depth, &(q_s->timeout)))
1601                 return False;
1602         if (!prs_uint16("flags  ", ps, depth, &(q_s->flags)))
1603                 return False;
1604
1605         return True;
1606 }
1607
1608 /*******************************************************************
1609 reads or writes a structure.
1610 ********************************************************************/
1611 BOOL reg_io_r_shutdown(char *desc, REG_R_SHUTDOWN * r_s, prs_struct *ps,
1612                        int depth)
1613 {
1614         if (r_s == NULL)
1615                 return False;
1616
1617         prs_debug(ps, depth, desc, "reg_io_r_shutdown");
1618         depth++;
1619
1620         if(!prs_align(ps))
1621                 return False;
1622
1623         if(!prs_ntstatus("status", ps, depth, &r_s->status))
1624                 return False;
1625
1626         return True;
1627 }
1628
1629 /*******************************************************************
1630 Inits a structure.
1631 ********************************************************************/
1632 void init_reg_q_abort_shutdown(REG_Q_ABORT_SHUTDOWN * q_s)
1633 {
1634
1635         q_s->ptr_server = 0;
1636
1637 }
1638
1639 /*******************************************************************
1640 reads or writes a structure.
1641 ********************************************************************/
1642 BOOL reg_io_q_abort_shutdown(char *desc, REG_Q_ABORT_SHUTDOWN * q_s,
1643                              prs_struct *ps, int depth)
1644 {
1645         if (q_s == NULL)
1646                 return False;
1647
1648         prs_debug(ps, depth, desc, "reg_io_q_abort_shutdown");
1649         depth++;
1650
1651         if (!prs_align(ps))
1652                 return False;
1653
1654         if (!prs_uint32("ptr_server", ps, depth, &(q_s->ptr_server)))
1655                 return False;
1656         if (q_s->ptr_server != 0)
1657                 if (!prs_uint16("server", ps, depth, &(q_s->server)))
1658                         return False;
1659
1660         return True;
1661 }
1662
1663 /*******************************************************************
1664 reads or writes a structure.
1665 ********************************************************************/
1666 BOOL reg_io_r_abort_shutdown(char *desc, REG_R_ABORT_SHUTDOWN * r_s,
1667                              prs_struct *ps, int depth)
1668 {
1669         if (r_s == NULL)
1670                 return False;
1671
1672         prs_debug(ps, depth, desc, "reg_io_r_abort_shutdown");
1673         depth++;
1674
1675         if (!prs_align(ps))
1676                 return False;
1677
1678         if (!prs_ntstatus("status", ps, depth, &r_s->status))
1679                 return False;
1680
1681         return True;
1682 }