source3/rpc_parse/parse_reg.c

   1 /*
   2  *  Unix SMB/Netbios implementation.
   3  *  Version 1.9.
   4  *  RPC Pipe client / server routines
   5  *  Copyright (C) Andrew Tridgell              1992-1999,
   6  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1999,
   7  *  Copyright (C) Paul Ashton                  1997-1999.
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24
  25 #include "includes.h"
  26
  27 extern int DEBUGLEVEL;
  28
  29
  30 /*******************************************************************
  31 creates a structure.
  32 ********************************************************************/
  33 BOOL make_reg_q_open_hkcr(REG_Q_OPEN_HKCR *q_o,
  34                                 uint16 unknown_0, uint32 level)
  35 {
  36         q_o->ptr = 1;
  37         q_o->unknown_0 = unknown_0;
  38         q_o->unknown_1 = 0x0; /* random - changes */
  39         q_o->level = level;
  40
  41         return True;
  42 }
  43
  44 /*******************************************************************
  45 reads or writes a structure.
  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) return False;
  50
  51         prs_debug(ps, depth, desc, "reg_io_q_open_hkcr");
  52         depth++;
  53
  54         prs_align(ps);
  55
  56         prs_uint32("ptr      ", ps, depth, &(r_q->ptr      ));
  57         if (r_q->ptr != 0)
  58         {
  59                 prs_uint16("unknown_0", ps, depth, &(r_q->unknown_0));
  60                 prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1));
  61                 prs_uint32("level    ", ps, depth, &(r_q->level    ));
  62         }
  63
  64         return True;
  65 }
  66
  67
  68 /*******************************************************************
  69 reads or writes a structure.
  70 ********************************************************************/
  71 BOOL reg_io_r_open_hkcr(char *desc,  REG_R_OPEN_HKCR *r_r, prs_struct *ps, int depth)
  72 {
  73         if (r_r == NULL) return False;
  74
  75         prs_debug(ps, depth, desc, "reg_io_r_open_hkcr");
  76         depth++;
  77
  78         prs_align(ps);
  79
  80         smb_io_pol_hnd("", &(r_r->pol), ps, depth);
  81
  82         prs_uint32("status", ps, depth, &(r_r->status));
  83
  84         return True;
  85 }
  86
  87
  88 /*******************************************************************
  89 creates a structure.
  90 ********************************************************************/
  91 BOOL make_reg_q_open_hklm(REG_Q_OPEN_HKLM *q_o,
  92                                 uint16 unknown_0, uint32 level)
  93 {
  94         q_o->ptr = 1;
  95         q_o->unknown_0 = unknown_0;
  96         q_o->unknown_1 = 0x0; /* random - changes */
  97         q_o->level = level;
  98
  99         return True;
 100 }
 101
 102 /*******************************************************************
 103 reads or writes a structure.
 104 ********************************************************************/
 105 BOOL reg_io_q_open_hklm(char *desc,  REG_Q_OPEN_HKLM *r_q, prs_struct *ps, int depth)
 106 {
 107         if (r_q == NULL) return False;
 108
 109         prs_debug(ps, depth, desc, "reg_io_q_open_hklm");
 110         depth++;
 111
 112         prs_align(ps);
 113
 114         prs_uint32("ptr      ", ps, depth, &(r_q->ptr      ));
 115         if (r_q->ptr != 0)
 116         {
 117                 prs_uint16("unknown_0", ps, depth, &(r_q->unknown_0));
 118                 prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1));
 119                 prs_uint32("level    ", ps, depth, &(r_q->level    ));
 120         }
 121
 122         return True;
 123 }
 124
 125
 126 /*******************************************************************
 127 reads or writes a structure.
 128 ********************************************************************/
 129 BOOL reg_io_r_open_hklm(char *desc,  REG_R_OPEN_HKLM *r_r, prs_struct *ps, int depth)
 130 {
 131         if (r_r == NULL) return False;
 132
 133         prs_debug(ps, depth, desc, "reg_io_r_open_hklm");
 134         depth++;
 135
 136         prs_align(ps);
 137
 138         smb_io_pol_hnd("", &(r_r->pol), ps, depth);
 139
 140         prs_uint32("status", ps, depth, &(r_r->status));
 141
 142         return True;
 143 }
 144
 145
 146 /*******************************************************************
 147 creates a structure.
 148 ********************************************************************/
 149 BOOL make_reg_q_flush_key(REG_Q_FLUSH_KEY *q_u, POLICY_HND *pol)
 150 {
 151         memcpy(&(q_u->pol), pol, sizeof(q_u->pol));
 152
 153         return True;
 154 }
 155
 156 /*******************************************************************
 157 reads or writes a structure.
 158 ********************************************************************/
 159 BOOL reg_io_q_flush_key(char *desc,  REG_Q_FLUSH_KEY *r_q, prs_struct *ps, int depth)
 160 {
 161         if (r_q == NULL) return False;
 162
 163         prs_debug(ps, depth, desc, "reg_io_q_flush_key");
 164         depth++;
 165
 166         prs_align(ps);
 167
 168         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
 169
 170         return True;
 171 }
 172
 173
 174 /*******************************************************************
 175 reads or writes a structure.
 176 ********************************************************************/
 177 BOOL reg_io_r_flush_key(char *desc,  REG_R_FLUSH_KEY *r_r, prs_struct *ps, int depth)
 178 {
 179         if (r_r == NULL) return False;
 180
 181         prs_debug(ps, depth, desc, "reg_io_r_flush_key");
 182         depth++;
 183
 184         prs_align(ps);
 185
 186         prs_uint32("status", ps, depth, &(r_r->status));
 187
 188         return True;
 189 }
 190
 191 /*******************************************************************
 192 reads or writes SEC_DESC_BUF and SEC_DATA structures.
 193 ********************************************************************/
 194 static BOOL reg_io_hdrbuf_sec(uint32 ptr, uint32 *ptr3, BUFHDR *hdr_sec,
 195                                 SEC_DESC_BUF *data, prs_struct *ps, int depth)
 196 {
 197         if (ptr != 0)
 198         {
 199                 uint32 hdr_offset;
 200                 uint32 old_offset;
 201                 smb_io_hdrbuf_pre("hdr_sec", hdr_sec, ps, depth, &hdr_offset);
 202                 old_offset = ps->offset;
 203                 if (ptr3 != NULL)
 204                 {
 205                         prs_uint32("ptr3", ps, depth, ptr3);
 206                 }
 207                 if (ptr3 == NULL || *ptr3 != 0)
 208                 {
 209                         sec_io_desc_buf("data   ", data   , ps, depth);
 210                 }
 211                 smb_io_hdrbuf_post("hdr_sec", hdr_sec, ps, depth, hdr_offset,
 212                                    data->max_len, data->len);
 213                 ps->offset = old_offset + data->len + sizeof(uint32) * ((ptr3 != NULL) ? 5 : 3);
 214                 prs_align(ps);
 215         }
 216
 217         return True;
 218 }
 219
 220
 221 /*******************************************************************
 222 creates a structure.
 223 ********************************************************************/
 224 BOOL make_reg_q_create_key(REG_Q_CREATE_KEY *q_c, POLICY_HND *hnd,
 225                                 char *key_name, char *key_class,
 226                                 SEC_ACCESS *sam_access,
 227                                 SEC_DESC_BUF *sec_buf,
 228                                 int sec_len, SEC_DESC *sec)
 229 {
 230         int len_name  = key_name  != NULL ? strlen(key_name ) + 1: 0;
 231         int len_class = key_class != NULL ? strlen(key_class) + 1: 0;
 232
 233         ZERO_STRUCTP(q_c);
 234
 235         memcpy(&(q_c->pnt_pol), hnd, sizeof(q_c->pnt_pol));
 236
 237         make_uni_hdr(&(q_c->hdr_name), len_name);
 238         make_unistr2(&(q_c->uni_name), key_name, len_name);
 239
 240         make_uni_hdr(&(q_c->hdr_class), len_class);
 241         make_unistr2(&(q_c->uni_class), key_class, len_class);
 242
 243         q_c->reserved = 0x00000000;
 244         memcpy(&(q_c->sam_access), sam_access, sizeof(q_c->sam_access));
 245
 246         q_c->ptr1 = 1;
 247         q_c->sec_info = DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION;
 248
 249         q_c->data = sec_buf;
 250         q_c->ptr2 = 1;
 251         make_buf_hdr(&(q_c->hdr_sec), sec_len, sec_len);
 252         q_c->ptr3 = 1;
 253         make_sec_desc_buf(q_c->data, sec_len, sec);
 254
 255         q_c->unknown_2 = 0x00000000;
 256
 257         return True;
 258 }
 259
 260 /*******************************************************************
 261 reads or writes a structure.
 262 ********************************************************************/
 263 BOOL reg_io_q_create_key(char *desc,  REG_Q_CREATE_KEY *r_q, prs_struct *ps, int depth)
 264 {
 265         if (r_q == NULL) return False;
 266
 267         prs_debug(ps, depth, desc, "reg_io_q_create_key");
 268         depth++;
 269
 270         prs_align(ps);
 271
 272         smb_io_pol_hnd("", &(r_q->pnt_pol), ps, depth);
 273
 274         smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
 275         smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
 276         prs_align(ps);
 277
 278         smb_io_unihdr ("", &(r_q->hdr_class), ps, depth);
 279         smb_io_unistr2("", &(r_q->uni_class), r_q->hdr_class.buffer, ps, depth);
 280         prs_align(ps);
 281
 282         prs_uint32("reserved", ps, depth, &(r_q->reserved));
 283         sec_io_access("sam_access", &r_q->sam_access, ps, depth);
 284
 285         prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
 286         if (r_q->ptr1 != 0)
 287         {
 288                 prs_uint32("sec_info", ps, depth, &(r_q->sec_info));
 289         }
 290
 291         prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
 292         reg_io_hdrbuf_sec(r_q->ptr2, &r_q->ptr3, &r_q->hdr_sec, r_q->data, ps, depth);
 293
 294         prs_uint32("unknown_2", ps, depth, &(r_q->unknown_2));
 295
 296         return True;
 297 }
 298
 299
 300 /*******************************************************************
 301 reads or writes a structure.
 302 ********************************************************************/
 303 BOOL reg_io_r_create_key(char *desc,  REG_R_CREATE_KEY *r_r, prs_struct *ps, int depth)
 304 {
 305         if (r_r == NULL) return False;
 306
 307         prs_debug(ps, depth, desc, "reg_io_r_create_key");
 308         depth++;
 309
 310         prs_align(ps);
 311
 312         smb_io_pol_hnd("", &(r_r->key_pol), ps, depth);
 313         prs_uint32("unknown", ps, depth, &(r_r->unknown));
 314
 315         prs_uint32("status", ps, depth, &(r_r->status));
 316
 317         return True;
 318 }
 319
 320
 321 /*******************************************************************
 322 creates a structure.
 323 ********************************************************************/
 324 BOOL make_reg_q_delete_val(REG_Q_DELETE_VALUE *q_c, POLICY_HND *hnd,
 325                                 char *name)
 326 {
 327         int len_name  = name  != NULL ? strlen(name ) + 1: 0;
 328         ZERO_STRUCTP(q_c);
 329
 330         memcpy(&(q_c->pnt_pol), hnd, sizeof(q_c->pnt_pol));
 331
 332         make_uni_hdr(&(q_c->hdr_name), len_name);
 333         make_unistr2(&(q_c->uni_name), name, len_name);
 334
 335         return True;
 336 }
 337
 338 /*******************************************************************
 339 reads or writes a structure.
 340 ********************************************************************/
 341 BOOL reg_io_q_delete_val(char *desc,  REG_Q_DELETE_VALUE *r_q, prs_struct *ps, int depth)
 342 {
 343         if (r_q == NULL) return False;
 344
 345         prs_debug(ps, depth, desc, "reg_io_q_delete_val");
 346         depth++;
 347
 348         prs_align(ps);
 349
 350         smb_io_pol_hnd("", &(r_q->pnt_pol), ps, depth);
 351
 352         smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
 353         smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
 354         prs_align(ps);
 355
 356         return True;
 357 }
 358
 359
 360 /*******************************************************************
 361 reads or writes a structure.
 362 ********************************************************************/
 363 BOOL reg_io_r_delete_val(char *desc,  REG_R_DELETE_VALUE *r_r, prs_struct *ps, int depth)
 364 {
 365         if (r_r == NULL) return False;
 366
 367         prs_debug(ps, depth, desc, "reg_io_r_delete_val");
 368         depth++;
 369
 370         prs_align(ps);
 371
 372         prs_uint32("status", ps, depth, &(r_r->status));
 373
 374         return True;
 375 }
 376
 377
 378 /*******************************************************************
 379 creates a structure.
 380 ********************************************************************/
 381 BOOL make_reg_q_delete_key(REG_Q_DELETE_KEY *q_c, POLICY_HND *hnd,
 382                                 char *name)
 383 {
 384         int len_name  = name  != NULL ? strlen(name ) + 1: 0;
 385         ZERO_STRUCTP(q_c);
 386
 387         memcpy(&(q_c->pnt_pol), hnd, sizeof(q_c->pnt_pol));
 388
 389         make_uni_hdr(&(q_c->hdr_name), len_name);
 390         make_unistr2(&(q_c->uni_name), name, len_name);
 391
 392         return True;
 393 }
 394
 395 /*******************************************************************
 396 reads or writes a structure.
 397 ********************************************************************/
 398 BOOL reg_io_q_delete_key(char *desc,  REG_Q_DELETE_KEY *r_q, prs_struct *ps, int depth)
 399 {
 400         if (r_q == NULL) return False;
 401
 402         prs_debug(ps, depth, desc, "reg_io_q_delete_key");
 403         depth++;
 404
 405         prs_align(ps);
 406
 407         smb_io_pol_hnd("", &(r_q->pnt_pol), ps, depth);
 408
 409         smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
 410         smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
 411         prs_align(ps);
 412
 413         return True;
 414 }
 415
 416
 417 /*******************************************************************
 418 reads or writes a structure.
 419 ********************************************************************/
 420 BOOL reg_io_r_delete_key(char *desc,  REG_R_DELETE_KEY *r_r, prs_struct *ps, int depth)
 421 {
 422         if (r_r == NULL) return False;
 423
 424         prs_debug(ps, depth, desc, "reg_io_r_delete_key");
 425         depth++;
 426
 427         prs_align(ps);
 428
 429         prs_uint32("status", ps, depth, &(r_r->status));
 430
 431         return True;
 432 }
 433
 434
 435 /*******************************************************************
 436 creates a structure.
 437 ********************************************************************/
 438 BOOL make_reg_q_query_key(REG_Q_QUERY_KEY *q_o, POLICY_HND *hnd,
 439                                 uint32 max_class_len)
 440 {
 441         ZERO_STRUCTP(q_o);
 442
 443         memcpy(&(q_o->pol), hnd, sizeof(q_o->pol));
 444         q_o->hdr_class.uni_str_len = 0;
 445         q_o->hdr_class.uni_max_len = max_class_len * 2;
 446         q_o->hdr_class.buffer = max_class_len > 0 ? 1 : 0;
 447         q_o->uni_class.uni_max_len = max_class_len;
 448
 449         return True;
 450 }
 451
 452 /*******************************************************************
 453 reads or writes a structure.
 454 ********************************************************************/
 455 BOOL reg_io_q_query_key(char *desc,  REG_Q_QUERY_KEY *r_q, prs_struct *ps, int depth)
 456 {
 457         if (r_q == NULL) return False;
 458
 459         prs_debug(ps, depth, desc, "reg_io_q_query_key");
 460         depth++;
 461
 462         prs_align(ps);
 463
 464         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
 465         smb_io_unihdr ("", &(r_q->hdr_class), ps, depth);
 466         smb_io_unistr2("", &(r_q->uni_class), r_q->hdr_class.buffer, ps, depth);
 467
 468         prs_align(ps);
 469
 470         return True;
 471 }
 472
 473
 474 /*******************************************************************
 475 reads or writes a structure.
 476 ********************************************************************/
 477 BOOL reg_io_r_query_key(char *desc,  REG_R_QUERY_KEY *r_r, prs_struct *ps, int depth)
 478 {
 479         if (r_r == NULL) return False;
 480
 481         prs_debug(ps, depth, desc, "reg_io_r_query_key");
 482         depth++;
 483
 484         prs_align(ps);
 485
 486         smb_io_unihdr ("", &(r_r->hdr_class), ps, depth);
 487         smb_io_unistr2("", &(r_r->uni_class), r_r->hdr_class.buffer, ps, depth);
 488
 489         prs_align(ps);
 490
 491         prs_uint32("num_subkeys   ", ps, depth, &(r_r->num_subkeys   ));
 492         prs_uint32("max_subkeylen ", ps, depth, &(r_r->max_subkeylen ));
 493         prs_uint32("mak_subkeysize", ps, depth, &(r_r->max_subkeysize));
 494         prs_uint32("num_values    ", ps, depth, &(r_r->num_values    ));
 495         prs_uint32("max_valnamelen", ps, depth, &(r_r->max_valnamelen));
 496         prs_uint32("max_valbufsize", ps, depth, &(r_r->max_valbufsize));
 497         prs_uint32("sec_desc      ", ps, depth, &(r_r->sec_desc      ));
 498         smb_io_time("mod_time     ", &(r_r->mod_time), ps, depth);
 499
 500         prs_uint32("status", ps, depth, &(r_r->status));
 501
 502         return True;
 503 }
 504
 505
 506 /*******************************************************************
 507 creates a structure.
 508 ********************************************************************/
 509 BOOL make_reg_q_unk_1a(REG_Q_UNK_1A *q_o, POLICY_HND *hnd)
 510 {
 511         memcpy(&(q_o->pol), hnd, sizeof(q_o->pol));
 512
 513         return True;
 514 }
 515
 516 /*******************************************************************
 517 reads or writes a structure.
 518 ********************************************************************/
 519 BOOL reg_io_q_unk_1a(char *desc,  REG_Q_UNK_1A *r_q, prs_struct *ps, int depth)
 520 {
 521         if (r_q == NULL) return False;
 522
 523         prs_debug(ps, depth, desc, "reg_io_q_unk_1a");
 524         depth++;
 525
 526         prs_align(ps);
 527
 528         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
 529
 530         return True;
 531 }
 532
 533
 534 /*******************************************************************
 535 reads or writes a structure.
 536 ********************************************************************/
 537 BOOL reg_io_r_unk_1a(char *desc,  REG_R_UNK_1A *r_r, prs_struct *ps, int depth)
 538 {
 539         if (r_r == NULL) return False;
 540
 541         prs_debug(ps, depth, desc, "reg_io_r_unk_1a");
 542         depth++;
 543
 544         prs_align(ps);
 545
 546         prs_uint32("unknown", ps, depth, &(r_r->unknown));
 547         prs_uint32("status" , ps, depth, &(r_r->status ));
 548
 549         return True;
 550 }
 551
 552
 553 /*******************************************************************
 554 creates a structure.
 555 ********************************************************************/
 556 BOOL make_reg_q_open_hku(REG_Q_OPEN_HKU *q_o,
 557                                 uint16 unknown_0, uint32 level)
 558 {
 559         q_o->ptr = 1;
 560         q_o->unknown_0 = unknown_0;
 561         q_o->unknown_1 = 0x0; /* random - changes */
 562         q_o->level = level;
 563
 564         return True;
 565 }
 566
 567 /*******************************************************************
 568 reads or writes a structure.
 569 ********************************************************************/
 570 BOOL reg_io_q_open_hku(char *desc,  REG_Q_OPEN_HKU *r_q, prs_struct *ps, int depth)
 571 {
 572         if (r_q == NULL) return False;
 573
 574         prs_debug(ps, depth, desc, "reg_io_q_open_hku");
 575         depth++;
 576
 577         prs_align(ps);
 578
 579         prs_uint32("ptr      ", ps, depth, &(r_q->ptr      ));
 580         if (r_q->ptr != 0)
 581         {
 582                 prs_uint16("unknown_0", ps, depth, &(r_q->unknown_0));
 583                 prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1));
 584                 prs_uint32("level    ", ps, depth, &(r_q->level    ));
 585         }
 586
 587         return True;
 588 }
 589
 590
 591 /*******************************************************************
 592 reads or writes a structure.
 593 ********************************************************************/
 594 BOOL reg_io_r_open_hku(char *desc,  REG_R_OPEN_HKU *r_r, prs_struct *ps, int depth)
 595 {
 596         if (r_r == NULL) return False;
 597
 598         prs_debug(ps, depth, desc, "reg_io_r_open_hku");
 599         depth++;
 600
 601         prs_align(ps);
 602
 603         smb_io_pol_hnd("", &(r_r->pol), ps, depth);
 604
 605         prs_uint32("status", ps, depth, &(r_r->status));
 606
 607         return True;
 608 }
 609
 610
 611 /*******************************************************************
 612 makes an REG_Q_CLOSE structure.
 613 ********************************************************************/
 614 BOOL make_reg_q_close(REG_Q_CLOSE *q_c, POLICY_HND *hnd)
 615 {
 616         if (q_c == NULL || hnd == NULL) return False;
 617
 618         DEBUG(5,("make_reg_q_close\n"));
 619
 620         memcpy(&(q_c->pol), hnd, sizeof(q_c->pol));
 621
 622         return True;
 623 }
 624
 625 /*******************************************************************
 626 reads or writes a structure.
 627 ********************************************************************/
 628 BOOL reg_io_q_close(char *desc,  REG_Q_CLOSE *q_u, prs_struct *ps, int depth)
 629 {
 630         if (q_u == NULL) return False;
 631
 632         prs_debug(ps, depth, desc, "reg_io_q_close");
 633         depth++;
 634
 635         prs_align(ps);
 636
 637         smb_io_pol_hnd("", &(q_u->pol), ps, depth);
 638         prs_align(ps);
 639
 640         return True;
 641 }
 642
 643 /*******************************************************************
 644 reads or writes a structure.
 645 ********************************************************************/
 646 BOOL reg_io_r_close(char *desc,  REG_R_CLOSE *r_u, prs_struct *ps, int depth)
 647 {
 648         if (r_u == NULL) return False;
 649
 650         prs_debug(ps, depth, desc, "reg_io_r_close");
 651         depth++;
 652
 653         prs_align(ps);
 654
 655         smb_io_pol_hnd("", &(r_u->pol), ps, depth);
 656         prs_align(ps);
 657
 658         prs_uint32("status", ps, depth, &(r_u->status));
 659
 660         return True;
 661 }
 662
 663 /*******************************************************************
 664 makes a structure.
 665 ********************************************************************/
 666 BOOL make_reg_q_set_key_sec(REG_Q_SET_KEY_SEC *q_i, POLICY_HND *pol,
 667                                 uint32 buf_len, SEC_DESC *sec_desc)
 668 {
 669         if (q_i == NULL) return False;
 670
 671         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
 672
 673         q_i->sec_info = DACL_SECURITY_INFORMATION;
 674
 675         q_i->ptr = 1;
 676         make_buf_hdr(&(q_i->hdr_sec), buf_len, buf_len);
 677         make_sec_desc_buf(q_i->data, buf_len, sec_desc);
 678
 679         return True;
 680 }
 681
 682 /*******************************************************************
 683 reads or writes a structure.
 684 ********************************************************************/
 685 BOOL reg_io_q_set_key_sec(char *desc,  REG_Q_SET_KEY_SEC *r_q, prs_struct *ps, int depth)
 686 {
 687         if (r_q == NULL) return False;
 688
 689         prs_debug(ps, depth, desc, "reg_io_q_set_key_sec");
 690         depth++;
 691
 692         prs_align(ps);
 693
 694         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
 695
 696         prs_uint32("sec_info", ps, depth, &(r_q->sec_info));
 697         prs_uint32("ptr    ", ps, depth, &(r_q->ptr    ));
 698
 699         reg_io_hdrbuf_sec(r_q->ptr, NULL, &r_q->hdr_sec, r_q->data, ps, depth);
 700
 701         return True;
 702 }
 703
 704 /*******************************************************************
 705 reads or writes a structure.
 706 ********************************************************************/
 707 BOOL reg_io_r_set_key_sec(char *desc, REG_R_SET_KEY_SEC *r_q, prs_struct *ps, int depth)
 708 {
 709         if (r_q == NULL) return False;
 710
 711         prs_debug(ps, depth, desc, "reg_io_r_set_key_sec");
 712         depth++;
 713
 714         prs_align(ps);
 715
 716         prs_uint32("status", ps, depth, &(r_q->status));
 717
 718         return True;
 719 }
 720
 721
 722 /*******************************************************************
 723 makes a structure.
 724 ********************************************************************/
 725 BOOL make_reg_q_get_key_sec(REG_Q_GET_KEY_SEC *q_i, POLICY_HND *pol,
 726                                 uint32 buf_len, SEC_DESC_BUF *sec_buf)
 727 {
 728         if (q_i == NULL) return False;
 729
 730         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
 731
 732         q_i->sec_info = OWNER_SECURITY_INFORMATION |
 733                         GROUP_SECURITY_INFORMATION |
 734                         DACL_SECURITY_INFORMATION;
 735
 736         q_i->ptr = sec_buf != NULL ? 1 : 0;
 737         q_i->data = sec_buf;
 738
 739         if (sec_buf != NULL)
 740         {
 741                 make_buf_hdr(&(q_i->hdr_sec), buf_len, 0);
 742                 make_sec_desc_buf(q_i->data, buf_len, NULL);
 743         }
 744
 745         return True;
 746 }
 747
 748 /*******************************************************************
 749 reads or writes a structure.
 750 ********************************************************************/
 751 BOOL reg_io_q_get_key_sec(char *desc,  REG_Q_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
 752 {
 753         if (r_q == NULL) return False;
 754
 755         prs_debug(ps, depth, desc, "reg_io_q_get_key_sec");
 756         depth++;
 757
 758         prs_align(ps);
 759
 760         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
 761
 762         prs_uint32("sec_info", ps, depth, &(r_q->sec_info));
 763         prs_uint32("ptr     ", ps, depth, &(r_q->ptr     ));
 764
 765         reg_io_hdrbuf_sec(r_q->ptr, NULL, &r_q->hdr_sec, r_q->data, ps, depth);
 766
 767         return True;
 768 }
 769
 770 #if 0
 771 /*******************************************************************
 772 makes a structure.
 773 ********************************************************************/
 774  void make_reg_r_get_key_sec(REG_R_GET_KEY_SEC *r_i, POLICY_HND *pol,
 775                                 uint32 buf_len, uint8 *buf,
 776                                 uint32 status)
 777 {
 778         if (r_i == NULL) return False;
 779
 780         r_i->ptr = 1;
 781         make_buf_hdr(&(r_i->hdr_sec), buf_len, buf_len);
 782         make_sec_desc_buf(r_i->data, buf_len, 1);
 783
 784         r_i->status = status; /* 0x0000 0000 or 0x0000 007a */
 785
 786         return True;
 787 }
 788 #endif
 789
 790 /*******************************************************************
 791 reads or writes a structure.
 792 ********************************************************************/
 793 BOOL reg_io_r_get_key_sec(char *desc,  REG_R_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
 794 {
 795         if (r_q == NULL) return False;
 796
 797         prs_debug(ps, depth, desc, "reg_io_r_get_key_sec");
 798         depth++;
 799
 800         prs_align(ps);
 801
 802         prs_uint32("ptr      ", ps, depth, &(r_q->ptr      ));
 803
 804         if (r_q->ptr != 0)
 805         {
 806                 smb_io_hdrbuf("", &(r_q->hdr_sec), ps, depth);
 807                 sec_io_desc_buf("", r_q->data, ps, depth);
 808
 809                 prs_align(ps);
 810         }
 811
 812         prs_uint32("status", ps, depth, &(r_q->status));
 813
 814         return True;
 815 }
 816
 817
 818 /*******************************************************************
 819 makes a structure.
 820 ********************************************************************/
 821 BOOL make_reg_q_info(REG_Q_INFO *q_i, POLICY_HND *pol, char *product_type,
 822                                 time_t unix_time, uint8 major, uint8 minor)
 823 {
 824         int len_type  = strlen(product_type);
 825
 826         if (q_i == NULL) return False;
 827
 828         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
 829
 830         make_uni_hdr(&(q_i->hdr_type), len_type);
 831         make_unistr2(&(q_i->uni_type), product_type, len_type);
 832
 833         q_i->ptr1 = 1;
 834         unix_to_nt_time(&(q_i->time), unix_time);
 835         q_i->major_version1 = major;
 836         q_i->minor_version1 = minor;
 837         memset(q_i->pad1, 0, sizeof(q_i->pad1));
 838
 839         q_i->ptr2 = 1;
 840         q_i->major_version2 = major;
 841         q_i->minor_version2 = minor;
 842         memset(q_i->pad2, 0, sizeof(q_i->pad2));
 843
 844         q_i->ptr3 = 1;
 845         q_i->unknown = 0x00000000;
 846
 847         return True;
 848 }
 849
 850 /*******************************************************************
 851 reads or writes a structure.
 852 ********************************************************************/
 853 BOOL reg_io_q_info(char *desc,  REG_Q_INFO *r_q, prs_struct *ps, int depth)
 854 {
 855         if (r_q == NULL) return False;
 856
 857         prs_debug(ps, depth, desc, "reg_io_q_info");
 858         depth++;
 859
 860         prs_align(ps);
 861
 862         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
 863         smb_io_unihdr ("", &(r_q->hdr_type), ps, depth);
 864         smb_io_unistr2("", &(r_q->uni_type), r_q->hdr_type.buffer, ps, depth);
 865
 866         prs_align(ps);
 867
 868         prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
 869
 870         if (r_q->ptr1 != 0)
 871         {
 872                 smb_io_time("", &(r_q->time), ps, depth);
 873                 prs_uint8 ("major_version1", ps, depth, &(r_q->major_version1));
 874                 prs_uint8 ("minor_version1", ps, depth, &(r_q->minor_version1));
 875                 prs_uint8s(False, "pad1", ps, depth, r_q->pad1, sizeof(r_q->pad1));
 876         }
 877
 878         prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
 879
 880         if (r_q->ptr2 != 0)
 881         {
 882                 prs_uint8 ("major_version2", ps, depth, &(r_q->major_version2));
 883                 prs_uint8 ("minor_version2", ps, depth, &(r_q->minor_version2));
 884                 prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2));
 885         }
 886
 887         prs_uint32("ptr3", ps, depth, &(r_q->ptr3));
 888
 889         if (r_q->ptr3 != 0)
 890         {
 891                 prs_uint32("unknown", ps, depth, &(r_q->unknown));
 892         }
 893
 894         return True;
 895 }
 896
 897
 898 /*******************************************************************
 899 creates a structure.
 900 ********************************************************************/
 901 BOOL make_reg_r_info(REG_R_INFO *r_r,
 902                                 uint32 level, char *os_type,
 903                                 uint32 status)
 904 {
 905         int len;
 906
 907         if (r_r == NULL || os_type == NULL) return False;
 908
 909         len = strlen(os_type);
 910
 911         r_r->ptr1 = 1;
 912         r_r->level = level;
 913
 914         r_r->ptr_type = 1;
 915         make_buffer2(&(r_r->uni_type), os_type, len);
 916
 917         r_r->ptr2 = r_r->ptr3 = 1;
 918         r_r->unknown_0 = r_r->unknown_1 = len * 2;
 919
 920         r_r->status = status;
 921
 922         return True;
 923 }
 924
 925 /*******************************************************************
 926 reads or writes a structure.
 927 ********************************************************************/
 928 BOOL reg_io_r_info(char *desc, REG_R_INFO *r_r, prs_struct *ps, int depth)
 929 {
 930         if (r_r == NULL) return False;
 931
 932         prs_debug(ps, depth, desc, "reg_io_r_info");
 933         depth++;
 934
 935         prs_align(ps);
 936
 937         prs_uint32("ptr1", ps, depth, &(r_r->ptr1));
 938
 939         if (r_r->ptr1 != 0)
 940         {
 941                 prs_uint32("level", ps, depth, &(r_r->level));
 942                 prs_uint32("ptr_type", ps, depth, &(r_r->ptr_type));
 943
 944                 smb_io_buffer2("uni_type", &(r_r->uni_type), r_r->ptr_type, ps, depth);
 945                 prs_align(ps);
 946
 947                 prs_uint32("ptr2", ps, depth, &(r_r->ptr2));
 948
 949                 if (r_r->ptr2 != 0)
 950                 {
 951                         prs_uint32("unknown_0", ps, depth, &(r_r->unknown_0));
 952                 }
 953
 954                 prs_uint32("ptr3", ps, depth, &(r_r->ptr3));
 955
 956                 if (r_r->ptr3 != 0)
 957                 {
 958                         prs_uint32("unknown_1", ps, depth, &(r_r->unknown_1));
 959                 }
 960
 961         }
 962         prs_uint32("status", ps, depth, &(r_r->status));
 963
 964         return True;
 965 }
 966
 967 /*******************************************************************
 968 makes a structure.
 969 ********************************************************************/
 970 BOOL make_reg_q_enum_val(REG_Q_ENUM_VALUE *q_i, POLICY_HND *pol,
 971                                 uint32 val_idx, uint32 max_val_len,
 972                                 uint32 max_buf_len)
 973 {
 974         if (q_i == NULL) return False;
 975
 976         ZERO_STRUCTP(q_i);
 977
 978         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
 979
 980         q_i->val_index = val_idx;
 981         q_i->hdr_name.uni_str_len = 0;
 982         q_i->hdr_name.uni_max_len = max_val_len * 2;
 983         q_i->hdr_name.buffer = max_val_len > 0 ? 1 : 0;
 984         q_i->uni_name.uni_max_len = max_val_len;
 985
 986         q_i->ptr_type = 1;
 987         q_i->type = 0x0;
 988
 989         q_i->ptr_value = 1;
 990         q_i->buf_value.buf_max_len = max_buf_len;
 991
 992         q_i->ptr1 = 1;
 993         q_i->len_value1 = max_buf_len;
 994
 995         q_i->ptr2 = 1;
 996         q_i->len_value2 = 0;
 997
 998         return True;
 999 }
1000
1001 /*******************************************************************
1002 reads or writes a structure.
1003 ********************************************************************/
1004 BOOL reg_io_q_enum_val(char *desc,  REG_Q_ENUM_VALUE *q_q, prs_struct *ps, int depth)
1005 {
1006         if (q_q == NULL) return False;
1007
1008         prs_debug(ps, depth, desc, "reg_io_q_enum_val");
1009         depth++;
1010
1011         prs_align(ps);
1012
1013         smb_io_pol_hnd("", &(q_q->pol), ps, depth);
1014
1015         prs_uint32("val_index", ps, depth, &(q_q->val_index));
1016         smb_io_unihdr ("hdr_name", &(q_q->hdr_name), ps, depth);
1017         smb_io_unistr2("uni_name", &(q_q->uni_name), q_q->hdr_name.buffer, ps, depth);
1018         prs_align(ps);
1019
1020         prs_uint32("ptr_type", ps, depth, &(q_q->ptr_type));
1021
1022         if (q_q->ptr_type != 0)
1023         {
1024                 prs_uint32("type", ps, depth, &(q_q->type));
1025         }
1026
1027         prs_uint32("ptr_value", ps, depth, &(q_q->ptr_value));
1028         smb_io_buffer2("buf_value", &(q_q->buf_value), q_q->ptr_value, ps, depth);
1029         prs_align(ps);
1030
1031         prs_uint32("ptr1", ps, depth, &(q_q->ptr1));
1032         if (q_q->ptr1 != 0)
1033         {
1034                 prs_uint32("len_value1", ps, depth, &(q_q->len_value1));
1035         }
1036         prs_uint32("ptr2", ps, depth, &(q_q->ptr2));
1037         if (q_q->ptr2 != 0)
1038         {
1039                 prs_uint32("len_value2", ps, depth, &(q_q->len_value2));
1040         }
1041
1042         return True;
1043 }
1044
1045 /*******************************************************************
1046 reads or writes a structure.
1047 ********************************************************************/
1048 BOOL reg_io_r_enum_val(char *desc,  REG_R_ENUM_VALUE *r_q, prs_struct *ps, int depth)
1049 {
1050         if (r_q == NULL) return False;
1051
1052         prs_debug(ps, depth, desc, "reg_io_r_enum_val");
1053         depth++;
1054
1055         prs_align(ps);
1056
1057         smb_io_unihdr ("hdr_name", &(r_q->hdr_name), ps, depth);
1058         smb_io_unistr2("uni_name", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
1059         prs_align(ps);
1060
1061         prs_uint32("ptr_type", ps, depth, &(r_q->ptr_type));
1062
1063         if (r_q->ptr_type != 0)
1064         {
1065                 prs_uint32("type", ps, depth, &(r_q->type));
1066         }
1067
1068         prs_uint32("ptr_value", ps, depth, &(r_q->ptr_value));
1069         smb_io_buffer2("buf_value", r_q->buf_value, r_q->ptr_value, ps, depth);
1070         prs_align(ps);
1071
1072         prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
1073         if (r_q->ptr1 != 0)
1074         {
1075                 prs_uint32("len_value1", ps, depth, &(r_q->len_value1));
1076         }
1077
1078         prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
1079         if (r_q->ptr2 != 0)
1080         {
1081                 prs_uint32("len_value2", ps, depth, &(r_q->len_value2));
1082         }
1083
1084         prs_uint32("status", ps, depth, &(r_q->status));
1085
1086         return True;
1087 }
1088
1089 /*******************************************************************
1090 makes a structure.
1091 ********************************************************************/
1092 BOOL make_reg_q_create_val(REG_Q_CREATE_VALUE *q_i, POLICY_HND *pol,
1093                                 char *val_name, uint32 type,
1094                                 BUFFER3 *val)
1095 {
1096         int val_len = strlen(val_name) + 1;
1097
1098         if (q_i == NULL) return False;
1099
1100         ZERO_STRUCTP(q_i);
1101
1102         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
1103
1104         make_uni_hdr(&q_i->hdr_name, val_len);
1105         make_unistr2(&(q_i->uni_name), val_name, val_len);
1106
1107         q_i->type      = type;
1108         q_i->buf_value = val;
1109
1110         return True;
1111 }
1112
1113 /*******************************************************************
1114 reads or writes a structure.
1115 ********************************************************************/
1116 BOOL reg_io_q_create_val(char *desc,  REG_Q_CREATE_VALUE *q_q, prs_struct *ps, int depth)
1117 {
1118         if (q_q == NULL) return False;
1119
1120         prs_debug(ps, depth, desc, "reg_io_q_create_val");
1121         depth++;
1122
1123         prs_align(ps);
1124
1125         smb_io_pol_hnd("", &(q_q->pol), ps, depth);
1126
1127         smb_io_unihdr ("hdr_name", &(q_q->hdr_name), ps, depth);
1128         smb_io_unistr2("uni_name", &(q_q->uni_name), q_q->hdr_name.buffer, ps, depth);
1129         prs_align(ps);
1130
1131         prs_uint32("type", ps, depth, &(q_q->type));
1132         smb_io_buffer3("buf_value", q_q->buf_value, ps, depth);
1133         prs_align(ps);
1134
1135         return True;
1136 }
1137
1138 /*******************************************************************
1139 reads or writes a structure.
1140 ********************************************************************/
1141 BOOL reg_io_r_create_val(char *desc,  REG_R_CREATE_VALUE *r_q, prs_struct *ps, int depth)
1142 {
1143         if (r_q == NULL) return False;
1144
1145         prs_debug(ps, depth, desc, "reg_io_r_create_val");
1146         depth++;
1147
1148         prs_align(ps);
1149
1150         prs_uint32("status", ps, depth, &(r_q->status));
1151
1152         return True;
1153 }
1154
1155 /*******************************************************************
1156 makes a structure.
1157 ********************************************************************/
1158 BOOL make_reg_q_enum_key(REG_Q_ENUM_KEY *q_i, POLICY_HND *pol, uint32 key_idx)
1159 {
1160         if (q_i == NULL) return False;
1161
1162         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
1163
1164         q_i->key_index = key_idx;
1165         q_i->key_name_len = 0;
1166         q_i->unknown_1 = 0x0414;
1167
1168         q_i->ptr1 = 1;
1169         q_i->unknown_2 = 0x0000020A;
1170         memset(q_i->pad1, 0, sizeof(q_i->pad1));
1171
1172         q_i->ptr2 = 1;
1173         memset(q_i->pad2, 0, sizeof(q_i->pad2));
1174
1175         q_i->ptr3 = 1;
1176         init_nt_time(&(q_i->time));   /* ignored ? */
1177
1178         return True;
1179 }
1180
1181 /*******************************************************************
1182 reads or writes a structure.
1183 ********************************************************************/
1184 BOOL reg_io_q_enum_key(char *desc,  REG_Q_ENUM_KEY *q_q, prs_struct *ps, int depth)
1185 {
1186         if (q_q == NULL) return False;
1187
1188         prs_debug(ps, depth, desc, "reg_io_q_enum_key");
1189         depth++;
1190
1191         prs_align(ps);
1192
1193         smb_io_pol_hnd("", &(q_q->pol), ps, depth);
1194
1195         prs_uint32("key_index", ps, depth, &(q_q->key_index));
1196         prs_uint16("key_name_len", ps, depth, &(q_q->key_name_len));
1197         prs_uint16("unknown_1", ps, depth, &(q_q->unknown_1));
1198
1199         prs_uint32("ptr1", ps, depth, &(q_q->ptr1));
1200
1201         if (q_q->ptr1 != 0)
1202         {
1203                 prs_uint32("unknown_2", ps, depth, &(q_q->unknown_2));
1204                 prs_uint8s(False, "pad1", ps, depth, q_q->pad1, sizeof(q_q->pad1));
1205         }
1206
1207         prs_uint32("ptr2", ps, depth, &(q_q->ptr2));
1208
1209         if (q_q->ptr2 != 0)
1210         {
1211                 prs_uint8s(False, "pad2", ps, depth, q_q->pad2, sizeof(q_q->pad2));
1212         }
1213
1214         prs_uint32("ptr3", ps, depth, &(q_q->ptr3));
1215
1216         if (q_q->ptr3 != 0)
1217         {
1218                 smb_io_time("", &(q_q->time), ps, depth);
1219         }
1220
1221         return True;
1222 }
1223
1224 /*******************************************************************
1225 reads or writes a structure.
1226 ********************************************************************/
1227 BOOL reg_io_r_enum_key(char *desc,  REG_R_ENUM_KEY *r_q, prs_struct *ps, int depth)
1228 {
1229         if (r_q == NULL) return False;
1230
1231         prs_debug(ps, depth, desc, "reg_io_r_enum_key");
1232         depth++;
1233
1234         prs_align(ps);
1235
1236         prs_uint16("key_name_len", ps, depth, &(r_q->key_name_len));
1237         prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1));
1238
1239         prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
1240
1241         if (r_q->ptr1 != 0)
1242         {
1243                 prs_uint32("unknown_2", ps, depth, &(r_q->unknown_2));
1244                 prs_uint32("unknown_3", ps, depth, &(r_q->unknown_3));
1245                 smb_io_unistr3("key_name", &(r_q->key_name), ps, depth);
1246                 prs_align(ps);
1247         }
1248
1249         prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
1250
1251         if (r_q->ptr2 != 0)
1252         {
1253                 prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2));
1254         }
1255
1256         prs_uint32("ptr3", ps, depth, &(r_q->ptr3));
1257
1258         if (r_q->ptr3 != 0)
1259         {
1260                 smb_io_time("", &(r_q->time), ps, depth);
1261         }
1262
1263         prs_uint32("status", ps, depth, &(r_q->status));
1264
1265         return True;
1266 }
1267
1268
1269 /*******************************************************************
1270 makes a structure.
1271 ********************************************************************/
1272 BOOL make_reg_q_open_entry(REG_Q_OPEN_ENTRY *r_q, POLICY_HND *pol,
1273                                 char *key_name, uint32 unk)
1274 {
1275         int len_name = strlen(key_name)+1;
1276
1277         if (r_q == NULL) return False;
1278
1279         memcpy(&(r_q->pol), pol, sizeof(r_q->pol));
1280
1281         make_uni_hdr(&(r_q->hdr_name), len_name);
1282         make_unistr2(&(r_q->uni_name), key_name, len_name);
1283
1284         r_q->unknown_0 = 0x00000000;
1285         r_q->unknown_1 = unk;
1286
1287         return True;
1288 }
1289
1290 /*******************************************************************
1291 reads or writes a structure.
1292 ********************************************************************/
1293 BOOL reg_io_q_open_entry(char *desc,  REG_Q_OPEN_ENTRY *r_q, prs_struct *ps, int depth)
1294 {
1295         if (r_q == NULL) return False;
1296
1297         prs_debug(ps, depth, desc, "reg_io_q_entry");
1298         depth++;
1299
1300         prs_align(ps);
1301
1302         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
1303         smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
1304         smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
1305
1306         prs_align(ps);
1307
1308         prs_uint32("unknown_0", ps, depth, &(r_q->unknown_0));
1309         prs_uint32("unknown_1", ps, depth, &(r_q->unknown_1));
1310
1311         return True;
1312 }
1313
1314
1315 /*******************************************************************
1316 creates a structure.
1317 ********************************************************************/
1318 BOOL make_reg_r_open_entry(REG_R_OPEN_ENTRY *r_r,
1319                                 POLICY_HND *pol, uint32 status)
1320 {
1321         if (r_r == NULL) return False;
1322
1323         memcpy(&(r_r->pol), pol, sizeof(r_r->pol));
1324         r_r->status = status;
1325
1326         return True;
1327 }
1328
1329 /*******************************************************************
1330 reads or writes a structure.
1331 ********************************************************************/
1332 BOOL reg_io_r_open_entry(char *desc,  REG_R_OPEN_ENTRY *r_r, prs_struct *ps, int depth)
1333 {
1334         if (r_r == NULL) return False;
1335
1336         prs_debug(ps, depth, desc, "reg_io_r_open_entry");
1337         depth++;
1338
1339         prs_align(ps);
1340
1341         smb_io_pol_hnd("", &(r_r->pol), ps, depth);
1342
1343         prs_uint32("status", ps, depth, &(r_r->status));
1344
1345         return True;
1346 }
1347
1348 /*******************************************************************
1349 makes a structure.
1350 ********************************************************************/
1351 BOOL make_reg_q_shutdown(REG_Q_SHUTDOWN *q_i,
1352                                 char *msg, uint32 timeout, uint16 flags)
1353 {
1354         int len = strlen(msg) + 1;
1355
1356         if (q_i == NULL) return False;
1357
1358         ZERO_STRUCTP(q_i);
1359
1360         q_i->ptr_0 = 1;
1361         q_i->ptr_1 = 1;
1362         q_i->ptr_2 = 1;
1363
1364         make_uni_hdr(&q_i->hdr_msg, len);
1365         make_unistr2(&(q_i->uni_msg), msg, len);
1366
1367         q_i->timeout = timeout;
1368         q_i->flags   = flags;
1369
1370         return True;
1371 }
1372
1373 /*******************************************************************
1374 reads or writes a structure.
1375 ********************************************************************/
1376 BOOL reg_io_q_shutdown(char *desc,  REG_Q_SHUTDOWN *q_q, prs_struct *ps, int depth)
1377 {
1378         if (q_q == NULL) return False;
1379
1380         prs_debug(ps, depth, desc, "reg_io_q_shutdown");
1381         depth++;
1382
1383         prs_align(ps);
1384
1385         prs_uint32("ptr_0", ps, depth, &(q_q->ptr_0));
1386         prs_uint32("ptr_1", ps, depth, &(q_q->ptr_1));
1387         prs_uint32("ptr_2", ps, depth, &(q_q->ptr_2));
1388
1389         smb_io_unihdr ("hdr_msg", &(q_q->hdr_msg), ps, depth);
1390         smb_io_unistr2("uni_msg", &(q_q->uni_msg), q_q->hdr_msg.buffer, ps, depth);
1391         prs_align(ps);
1392
1393         prs_uint32("timeout", ps, depth, &(q_q->timeout));
1394         prs_uint16("flags  ", ps, depth, &(q_q->flags  ));
1395         prs_align(ps);
1396
1397         return True;
1398 }
1399
1400 /*******************************************************************
1401 reads or writes a structure.
1402 ********************************************************************/
1403 BOOL reg_io_r_shutdown(char *desc,  REG_R_SHUTDOWN *r_q, prs_struct *ps, int depth)
1404 {
1405         if (r_q == NULL) return False;
1406
1407         prs_debug(ps, depth, desc, "reg_io_r_shutdown");
1408         depth++;
1409
1410         prs_align(ps);
1411
1412         prs_uint32("status", ps, depth, &(r_q->status));
1413
1414         return True;
1415 }
1416