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