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
 123 /*******************************************************************
 124 creates a structure.
 125 ********************************************************************/
 126 void make_reg_q_create_key(REG_Q_CREATE_KEY *q_c, POLICY_HND *hnd,
 127                                 char *name, char *class,
 128                                 SEC_INFO *sam_access)
 129 {
 130         int len_name  = name  != NULL ? strlen(name ) + 1: 0;
 131         int len_class = class != NULL ? strlen(class) + 1: 0;
 132
 133         static unsigned char data[] =
 134         {
 135                 0x01, 0x00, 0x00, 0x80,
 136                 0x00, 0x00, 0x00, 0x00,
 137                 0x00, 0x00, 0x00, 0x00,
 138                 0x00, 0x00, 0x00, 0x00,
 139                 0x00, 0x00, 0x00, 0x00
 140         };
 141
 142         ZERO_STRUCTP(q_c);
 143
 144         memcpy(&(q_c->pnt_pol), hnd, sizeof(q_c->pnt_pol));
 145
 146         make_uni_hdr(&(q_c->hdr_name), len_name, len_name, 1);
 147         make_unistr2(&(q_c->uni_name), name, len_name);
 148
 149         make_uni_hdr(&(q_c->hdr_class), len_class, len_class, 1);
 150         make_unistr2(&(q_c->uni_class), class, len_class);
 151
 152         q_c->reserved = 0x00000000;
 153         memcpy(&(q_c->sam_access), sam_access, sizeof(q_c->sam_access));
 154
 155         q_c->ptr1 = 1;
 156         q_c->unknown_0 = 0x0000000C;
 157
 158         q_c->ptr2 = 1;
 159         q_c->sec_len1 = 0x14;
 160         q_c->sec_len2 = 0x14;
 161         q_c->sec_len3 = 0x0;
 162         q_c->sec_len4 = 0x14;
 163         q_c->sec_len5 = 0x0;
 164         q_c->sec_len6 = 0x14;
 165
 166         memcpy(&q_c->buf_unk, data, sizeof(q_c->buf_unk));
 167
 168         q_c->unknown_2 = 0x00000000;
 169 }
 170
 171 /*******************************************************************
 172 reads or writes a structure.
 173 ********************************************************************/
 174 void reg_io_q_create_key(char *desc,  REG_Q_CREATE_KEY *r_q, prs_struct *ps, int depth)
 175 {
 176         if (r_q == NULL) return;
 177
 178         prs_debug(ps, depth, desc, "reg_io_q_create_key");
 179         depth++;
 180
 181         prs_align(ps);
 182
 183         smb_io_pol_hnd("", &(r_q->pnt_pol), ps, depth);
 184
 185         smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
 186         smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
 187         prs_align(ps);
 188
 189         smb_io_unihdr ("", &(r_q->hdr_class), ps, depth);
 190         smb_io_unistr2("", &(r_q->uni_class), r_q->hdr_class.buffer, ps, depth);
 191         prs_align(ps);
 192
 193         prs_uint32("reserved", ps, depth, &(r_q->reserved));
 194         sec_io_info("sam_access", &r_q->sam_access, ps, depth);
 195
 196         prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
 197         if (r_q->ptr2 != 0)
 198         {
 199                 prs_uint32("unknown_0", ps, depth, &(r_q->unknown_0));
 200         }
 201
 202         prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
 203         if (r_q->ptr2)
 204         {
 205                 prs_uint32("sec_len1", ps, depth, &(r_q->sec_len1));
 206                 prs_uint32("sec_len2", ps, depth, &(r_q->sec_len2));
 207                 prs_uint32("sec_len3", ps, depth, &(r_q->sec_len3));
 208                 prs_uint32("sec_len4", ps, depth, &(r_q->sec_len4));
 209                 prs_uint32("sec_len5", ps, depth, &(r_q->sec_len5));
 210                 prs_uint32("sec_len6", ps, depth, &(r_q->sec_len6));
 211                 prs_uint8s(False, "buf_unk", ps, depth, r_q->buf_unk, sizeof(r_q->buf_unk));
 212                 prs_align(ps);
 213
 214                 prs_uint32("unknown_2", ps, depth, &(r_q->unknown_2));
 215         }
 216
 217         prs_align(ps);
 218 }
 219
 220
 221 /*******************************************************************
 222 reads or writes a structure.
 223 ********************************************************************/
 224 void reg_io_r_create_key(char *desc,  REG_R_CREATE_KEY *r_r, prs_struct *ps, int depth)
 225 {
 226         if (r_r == NULL) return;
 227
 228         prs_debug(ps, depth, desc, "reg_io_r_create_key");
 229         depth++;
 230
 231         prs_align(ps);
 232
 233         smb_io_pol_hnd("", &(r_r->key_pol), ps, depth);
 234         prs_uint32("unknown", ps, depth, &(r_r->unknown));
 235
 236         prs_uint32("status", ps, depth, &(r_r->status));
 237 }
 238
 239
 240 /*******************************************************************
 241 creates a structure.
 242 ********************************************************************/
 243 void make_reg_q_delete_key(REG_Q_DELETE_KEY *q_c, POLICY_HND *hnd,
 244                                 char *name)
 245 {
 246         int len_name  = name  != NULL ? strlen(name ) + 1: 0;
 247         ZERO_STRUCTP(q_c);
 248
 249         memcpy(&(q_c->pnt_pol), hnd, sizeof(q_c->pnt_pol));
 250
 251         make_uni_hdr(&(q_c->hdr_name), len_name, len_name, 1);
 252         make_unistr2(&(q_c->uni_name), name, len_name);
 253 }
 254
 255 /*******************************************************************
 256 reads or writes a structure.
 257 ********************************************************************/
 258 void reg_io_q_delete_key(char *desc,  REG_Q_DELETE_KEY *r_q, prs_struct *ps, int depth)
 259 {
 260         if (r_q == NULL) return;
 261
 262         prs_debug(ps, depth, desc, "reg_io_q_delete_key");
 263         depth++;
 264
 265         prs_align(ps);
 266
 267         smb_io_pol_hnd("", &(r_q->pnt_pol), ps, depth);
 268
 269         smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
 270         smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
 271         prs_align(ps);
 272 }
 273
 274
 275 /*******************************************************************
 276 reads or writes a structure.
 277 ********************************************************************/
 278 void reg_io_r_delete_key(char *desc,  REG_R_DELETE_KEY *r_r, prs_struct *ps, int depth)
 279 {
 280         if (r_r == NULL) return;
 281
 282         prs_debug(ps, depth, desc, "reg_io_r_delete_key");
 283         depth++;
 284
 285         prs_align(ps);
 286
 287         prs_uint32("status", ps, depth, &(r_r->status));
 288 }
 289
 290
 291 /*******************************************************************
 292 creates a structure.
 293 ********************************************************************/
 294 void make_reg_q_query_key(REG_Q_QUERY_KEY *q_o, POLICY_HND *hnd,
 295                                 uint32 max_class_len)
 296 {
 297         ZERO_STRUCTP(q_o);
 298
 299         memcpy(&(q_o->pol), hnd, sizeof(q_o->pol));
 300         make_uni_hdr(&q_o->hdr_class, max_class_len, 0, max_class_len > 0 ? 1 : 0);
 301         q_o->uni_class.uni_max_len = max_class_len;
 302 }
 303
 304 /*******************************************************************
 305 reads or writes a structure.
 306 ********************************************************************/
 307 void reg_io_q_query_key(char *desc,  REG_Q_QUERY_KEY *r_q, prs_struct *ps, int depth)
 308 {
 309         if (r_q == NULL) return;
 310
 311         prs_debug(ps, depth, desc, "reg_io_q_query_key");
 312         depth++;
 313
 314         prs_align(ps);
 315
 316         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
 317         smb_io_unihdr ("", &(r_q->hdr_class), ps, depth);
 318         smb_io_unistr2("", &(r_q->uni_class), r_q->hdr_class.buffer, ps, depth);
 319
 320         prs_align(ps);
 321 }
 322
 323
 324 /*******************************************************************
 325 reads or writes a structure.
 326 ********************************************************************/
 327 void reg_io_r_query_key(char *desc,  REG_R_QUERY_KEY *r_r, prs_struct *ps, int depth)
 328 {
 329         if (r_r == NULL) return;
 330
 331         prs_debug(ps, depth, desc, "reg_io_r_query_key");
 332         depth++;
 333
 334         prs_align(ps);
 335
 336         smb_io_unihdr ("", &(r_r->hdr_class), ps, depth);
 337         smb_io_unistr2("", &(r_r->uni_class), r_r->hdr_class.buffer, ps, depth);
 338
 339         prs_align(ps);
 340
 341         prs_uint32("num_subkeys   ", ps, depth, &(r_r->num_subkeys   ));
 342         prs_uint32("max_subkeylen ", ps, depth, &(r_r->max_subkeylen ));
 343         prs_uint32("mak_subkeysize", ps, depth, &(r_r->max_subkeysize));
 344         prs_uint32("num_values    ", ps, depth, &(r_r->num_values    ));
 345         prs_uint32("max_valnamelen", ps, depth, &(r_r->max_valnamelen));
 346         prs_uint32("max_valbufsize", ps, depth, &(r_r->max_valbufsize));
 347         prs_uint32("sec_desc      ", ps, depth, &(r_r->sec_desc      ));
 348         smb_io_time("mod_time     ", &(r_r->mod_time), ps, depth);
 349
 350         prs_uint32("status", ps, depth, &(r_r->status));
 351 }
 352
 353
 354 /*******************************************************************
 355 creates a structure.
 356 ********************************************************************/
 357 void make_reg_q_unk_1a(REG_Q_UNK_1A *q_o, POLICY_HND *hnd)
 358 {
 359         memcpy(&(q_o->pol), hnd, sizeof(q_o->pol));
 360 }
 361
 362 /*******************************************************************
 363 reads or writes a structure.
 364 ********************************************************************/
 365 void reg_io_q_unk_1a(char *desc,  REG_Q_UNK_1A *r_q, prs_struct *ps, int depth)
 366 {
 367         if (r_q == NULL) return;
 368
 369         prs_debug(ps, depth, desc, "reg_io_q_unk_1a");
 370         depth++;
 371
 372         prs_align(ps);
 373
 374         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
 375 }
 376
 377
 378 /*******************************************************************
 379 reads or writes a structure.
 380 ********************************************************************/
 381 void reg_io_r_unk_1a(char *desc,  REG_R_UNK_1A *r_r, prs_struct *ps, int depth)
 382 {
 383         if (r_r == NULL) return;
 384
 385         prs_debug(ps, depth, desc, "reg_io_r_unk_1a");
 386         depth++;
 387
 388         prs_align(ps);
 389
 390         prs_uint32("unknown", ps, depth, &(r_r->unknown));
 391         prs_uint32("status" , ps, depth, &(r_r->status ));
 392 }
 393
 394
 395 /*******************************************************************
 396 creates a structure.
 397 ********************************************************************/
 398 void make_reg_q_open_hku(REG_Q_OPEN_HKU *q_o,
 399                                 uint16 unknown_0, uint32 level)
 400 {
 401         q_o->ptr = 1;
 402         q_o->unknown_0 = unknown_0;
 403         q_o->unknown_1 = 0x0; /* random - changes */
 404         q_o->level = level;
 405 }
 406
 407 /*******************************************************************
 408 reads or writes a structure.
 409 ********************************************************************/
 410 void reg_io_q_open_hku(char *desc,  REG_Q_OPEN_HKU *r_q, prs_struct *ps, int depth)
 411 {
 412         if (r_q == NULL) return;
 413
 414         prs_debug(ps, depth, desc, "reg_io_q_open_hku");
 415         depth++;
 416
 417         prs_align(ps);
 418
 419         prs_uint32("ptr      ", ps, depth, &(r_q->ptr      ));
 420         if (r_q->ptr != 0)
 421         {
 422                 prs_uint16("unknown_0", ps, depth, &(r_q->unknown_0));
 423                 prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1));
 424                 prs_uint32("level    ", ps, depth, &(r_q->level    ));
 425         }
 426 }
 427
 428
 429 /*******************************************************************
 430 reads or writes a structure.
 431 ********************************************************************/
 432 void reg_io_r_open_hku(char *desc,  REG_R_OPEN_HKU *r_r, prs_struct *ps, int depth)
 433 {
 434         if (r_r == NULL) return;
 435
 436         prs_debug(ps, depth, desc, "reg_io_r_open_hku");
 437         depth++;
 438
 439         prs_align(ps);
 440
 441         smb_io_pol_hnd("", &(r_r->pol), ps, depth);
 442
 443         prs_uint32("status", ps, depth, &(r_r->status));
 444 }
 445
 446
 447 /*******************************************************************
 448 makes an REG_Q_CLOSE structure.
 449 ********************************************************************/
 450 void make_reg_q_close(REG_Q_CLOSE *q_c, POLICY_HND *hnd)
 451 {
 452         if (q_c == NULL || hnd == NULL) return;
 453
 454         DEBUG(5,("make_reg_q_close\n"));
 455
 456         memcpy(&(q_c->pol), hnd, sizeof(q_c->pol));
 457 }
 458
 459 /*******************************************************************
 460 reads or writes a structure.
 461 ********************************************************************/
 462 void reg_io_q_close(char *desc,  REG_Q_CLOSE *q_u, prs_struct *ps, int depth)
 463 {
 464         if (q_u == NULL) return;
 465
 466         prs_debug(ps, depth, desc, "reg_io_q_unknown_1");
 467         depth++;
 468
 469         prs_align(ps);
 470
 471         smb_io_pol_hnd("", &(q_u->pol), ps, depth);
 472         prs_align(ps);
 473 }
 474
 475 /*******************************************************************
 476 reads or writes a structure.
 477 ********************************************************************/
 478 void reg_io_r_close(char *desc,  REG_R_CLOSE *r_u, prs_struct *ps, int depth)
 479 {
 480         if (r_u == NULL) return;
 481
 482         prs_debug(ps, depth, desc, "reg_io_r_unknown_1");
 483         depth++;
 484
 485         prs_align(ps);
 486
 487         smb_io_pol_hnd("", &(r_u->pol), ps, depth);
 488         prs_align(ps);
 489
 490         prs_uint32("status", ps, depth, &(r_u->status));
 491 }
 492
 493 /*******************************************************************
 494 makes a structure.
 495 ********************************************************************/
 496 void make_reg_q_get_key_sec(REG_Q_GET_KEY_SEC *q_i, POLICY_HND *pol,
 497                                 uint32 buf_len, SEC_DESC_BUF *sec_buf)
 498 {
 499         if (q_i == NULL) return;
 500
 501         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
 502
 503         q_i->unknown = 0x7;
 504
 505         q_i->ptr = 1;
 506         q_i->data = sec_buf;
 507
 508         make_buf_hdr(&(q_i->hdr_sec), buf_len, 0);
 509         make_sec_desc_buf(q_i->data, buf_len, 0);
 510 }
 511
 512 /*******************************************************************
 513 reads or writes a structure.
 514 ********************************************************************/
 515 void reg_io_q_get_key_sec(char *desc,  REG_Q_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
 516 {
 517         if (r_q == NULL) return;
 518
 519         prs_debug(ps, depth, desc, "reg_io_q_get_key_sec");
 520         depth++;
 521
 522         prs_align(ps);
 523
 524         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
 525
 526         prs_uint32("unknown", ps, depth, &(r_q->unknown));
 527         prs_uint32("ptr    ", ps, depth, &(r_q->ptr    ));
 528
 529         if (r_q->ptr != 0)
 530         {
 531                 smb_io_hdrbuf  ("hdr_sec", &(r_q->hdr_sec), ps, depth);
 532                 sec_io_desc_buf("data   ",   r_q->data    , ps, depth);
 533
 534                 prs_align(ps);
 535         }
 536 }
 537
 538 /*******************************************************************
 539 makes a structure.
 540 ********************************************************************/
 541 void make_reg_r_get_key_sec(REG_R_GET_KEY_SEC *r_i, POLICY_HND *pol,
 542                                 uint32 buf_len, uint8 *buf,
 543                                 uint32 status)
 544 {
 545         if (r_i == NULL) return;
 546
 547         r_i->ptr = 1;
 548         make_buf_hdr(&(r_i->hdr_sec), buf_len, buf_len);
 549         make_sec_desc_buf(r_i->data, buf_len, 1);
 550
 551         r_i->status = status; /* 0x0000 0000 or 0x0000 007a */
 552 }
 553
 554 /*******************************************************************
 555 reads or writes a structure.
 556 ********************************************************************/
 557 void reg_io_r_get_key_sec(char *desc,  REG_R_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
 558 {
 559         if (r_q == NULL) return;
 560
 561         prs_debug(ps, depth, desc, "reg_io_r_get_key_sec");
 562         depth++;
 563
 564         prs_align(ps);
 565
 566         prs_uint32("ptr      ", ps, depth, &(r_q->ptr      ));
 567
 568         if (r_q->ptr != 0)
 569         {
 570                 smb_io_hdrbuf("", &(r_q->hdr_sec), ps, depth);
 571                 sec_io_desc_buf("", r_q->data, ps, depth);
 572
 573                 prs_align(ps);
 574         }
 575
 576         prs_uint32("status", ps, depth, &(r_q->status));
 577 }
 578
 579
 580 /*******************************************************************
 581 makes a structure.
 582 ********************************************************************/
 583 void make_reg_q_info(REG_Q_INFO *q_i, POLICY_HND *pol, char *product_type,
 584                                 time_t unix_time, uint8 major, uint8 minor)
 585 {
 586         int len_type  = strlen(product_type);
 587
 588         if (q_i == NULL) return;
 589
 590         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
 591
 592         make_uni_hdr(&(q_i->hdr_type), len_type, len_type, 1);
 593         make_unistr2(&(q_i->uni_type), product_type, len_type);
 594
 595         q_i->ptr1 = 1;
 596         unix_to_nt_time(&(q_i->time), unix_time);
 597         q_i->major_version1 = major;
 598         q_i->minor_version1 = minor;
 599         memset(q_i->pad1, 0, sizeof(q_i->pad1));
 600
 601         q_i->ptr2 = 1;
 602         q_i->major_version2 = major;
 603         q_i->minor_version2 = minor;
 604         memset(q_i->pad2, 0, sizeof(q_i->pad2));
 605
 606         q_i->ptr3 = 1;
 607         q_i->unknown = 0x00000000;
 608 }
 609
 610 /*******************************************************************
 611 reads or writes a structure.
 612 ********************************************************************/
 613 void reg_io_q_info(char *desc,  REG_Q_INFO *r_q, prs_struct *ps, int depth)
 614 {
 615         if (r_q == NULL) return;
 616
 617         prs_debug(ps, depth, desc, "reg_io_q_info");
 618         depth++;
 619
 620         prs_align(ps);
 621
 622         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
 623         smb_io_unihdr ("", &(r_q->hdr_type), ps, depth);
 624         smb_io_unistr2("", &(r_q->uni_type), r_q->hdr_type.buffer, ps, depth);
 625
 626         prs_align(ps);
 627
 628         prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
 629
 630         if (r_q->ptr1 != 0)
 631         {
 632                 smb_io_time("", &(r_q->time), ps, depth);
 633                 prs_uint8 ("major_version1", ps, depth, &(r_q->major_version1));
 634                 prs_uint8 ("minor_version1", ps, depth, &(r_q->minor_version1));
 635                 prs_uint8s(False, "pad1", ps, depth, r_q->pad1, sizeof(r_q->pad1));
 636         }
 637
 638         prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
 639
 640         if (r_q->ptr2 != 0)
 641         {
 642                 prs_uint8 ("major_version2", ps, depth, &(r_q->major_version2));
 643                 prs_uint8 ("minor_version2", ps, depth, &(r_q->minor_version2));
 644                 prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2));
 645         }
 646
 647         prs_uint32("ptr3", ps, depth, &(r_q->ptr3));
 648
 649         if (r_q->ptr3 != 0)
 650         {
 651                 prs_uint32("unknown", ps, depth, &(r_q->unknown));
 652         }
 653 }
 654
 655
 656 /*******************************************************************
 657 creates a structure.
 658 ********************************************************************/
 659 void make_reg_r_info(REG_R_INFO *r_r,
 660                                 uint32 level, char *os_type,
 661                                 uint32 unknown_0, uint32 unknown_1,
 662                                 uint32 status)
 663 {
 664         uint8 buf[512];
 665         int len = struni2((uint16*)buf, os_type);
 666
 667         r_r->ptr1 = 1;
 668         r_r->level = level;
 669
 670         r_r->ptr_type = 1;
 671         make_buffer2(&(r_r->uni_type), buf, len*2);
 672
 673         r_r->ptr2 = 1;
 674         r_r->unknown_0 = unknown_0;
 675
 676         r_r->ptr3 = 1;
 677         r_r->unknown_1 = unknown_1;
 678
 679         r_r->status = status;
 680 }
 681
 682 /*******************************************************************
 683 reads or writes a structure.
 684 ********************************************************************/
 685 void reg_io_r_info(char *desc, REG_R_INFO *r_r, prs_struct *ps, int depth)
 686 {
 687         if (r_r == NULL) return;
 688
 689         prs_debug(ps, depth, desc, "reg_io_r_info");
 690         depth++;
 691
 692         prs_align(ps);
 693
 694         prs_uint32("ptr1", ps, depth, &(r_r->ptr1));
 695
 696         if (r_r->ptr1 != 0)
 697         {
 698                 prs_uint32("level", ps, depth, &(r_r->level));
 699                 prs_uint32("ptr_type", ps, depth, &(r_r->ptr_type));
 700
 701                 smb_io_buffer2("uni_type", &(r_r->uni_type), r_r->ptr_type, ps, depth);
 702
 703                 prs_uint32("ptr2", ps, depth, &(r_r->ptr2));
 704
 705                 if (r_r->ptr2 != 0)
 706                 {
 707                         prs_uint32("unknown_0", ps, depth, &(r_r->unknown_0));
 708                 }
 709
 710                 prs_uint32("ptr3", ps, depth, &(r_r->ptr3));
 711
 712                 if (r_r->ptr3 != 0)
 713                 {
 714                         prs_uint32("unknown_1", ps, depth, &(r_r->unknown_1));
 715                 }
 716
 717         }
 718         prs_uint32("status", ps, depth, &(r_r->status));
 719 }
 720
 721 /*******************************************************************
 722 makes a structure.
 723 ********************************************************************/
 724 void make_reg_q_enum_val(REG_Q_ENUM_VALUE *q_i, POLICY_HND *pol,
 725                                 uint32 val_idx, uint32 max_val_len,
 726                                 uint32 max_buf_len)
 727 {
 728         if (q_i == NULL) return;
 729
 730         ZERO_STRUCTP(q_i);
 731
 732         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
 733
 734         q_i->val_index = val_idx;
 735         make_uni_hdr(&q_i->hdr_name, max_val_len, 0, 1);
 736         q_i->uni_name.uni_max_len = max_val_len;
 737
 738         q_i->ptr_type = 1;
 739         q_i->type = 0x0;
 740
 741         q_i->ptr_value = 1;
 742         q_i->buf_value.buf_max_len = max_buf_len;
 743
 744         q_i->ptr1 = 1;
 745         q_i->len_value1 = max_buf_len;
 746
 747         q_i->ptr2 = 1;
 748         q_i->len_value2 = 0;
 749 }
 750
 751 /*******************************************************************
 752 reads or writes a structure.
 753 ********************************************************************/
 754 void reg_io_q_enum_val(char *desc,  REG_Q_ENUM_VALUE *q_q, prs_struct *ps, int depth)
 755 {
 756         if (q_q == NULL) return;
 757
 758         prs_debug(ps, depth, desc, "reg_io_q_enum_val");
 759         depth++;
 760
 761         prs_align(ps);
 762
 763         smb_io_pol_hnd("", &(q_q->pol), ps, depth);
 764
 765         prs_uint32("val_index", ps, depth, &(q_q->val_index));
 766         smb_io_unihdr ("hdr_name", &(q_q->hdr_name), ps, depth);
 767         smb_io_unistr2("uni_name", &(q_q->uni_name), q_q->hdr_name.buffer, ps, depth);
 768         prs_align(ps);
 769
 770         prs_uint32("ptr_type", ps, depth, &(q_q->ptr_type));
 771
 772         if (q_q->ptr_type != 0)
 773         {
 774                 prs_uint32("type", ps, depth, &(q_q->type));
 775         }
 776
 777         prs_uint32("ptr_value", ps, depth, &(q_q->ptr_value));
 778         smb_io_buffer2("buf_value", &(q_q->buf_value), q_q->ptr_value, ps, depth);
 779         prs_align(ps);
 780
 781         prs_uint32("ptr1", ps, depth, &(q_q->ptr1));
 782         if (q_q->ptr1 != 0)
 783         {
 784                 prs_uint32("len_value1", ps, depth, &(q_q->len_value1));
 785         }
 786         prs_uint32("ptr2", ps, depth, &(q_q->ptr2));
 787         if (q_q->ptr2 != 0)
 788         {
 789                 prs_uint32("len_value2", ps, depth, &(q_q->len_value2));
 790         }
 791 }
 792
 793 /*******************************************************************
 794 reads or writes a structure.
 795 ********************************************************************/
 796 void reg_io_r_enum_val(char *desc,  REG_R_ENUM_VALUE *r_q, prs_struct *ps, int depth)
 797 {
 798         if (r_q == NULL) return;
 799
 800         prs_debug(ps, depth, desc, "reg_io_r_enum_val");
 801         depth++;
 802
 803         prs_align(ps);
 804
 805         smb_io_unihdr ("hdr_name", &(r_q->hdr_name), ps, depth);
 806         smb_io_unistr2("uni_name", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
 807         prs_align(ps);
 808
 809         prs_uint32("ptr_type", ps, depth, &(r_q->ptr_type));
 810
 811         if (r_q->ptr_type != 0)
 812         {
 813                 prs_uint32("type", ps, depth, &(r_q->type));
 814         }
 815
 816         prs_uint32("ptr_value", ps, depth, &(r_q->ptr_value));
 817         smb_io_buffer2("buf_value", r_q->buf_value, r_q->ptr_value, ps, depth);
 818         prs_align(ps);
 819
 820         prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
 821         if (r_q->ptr1 != 0)
 822         {
 823                 prs_uint32("len_value1", ps, depth, &(r_q->len_value1));
 824         }
 825
 826         prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
 827         if (r_q->ptr2 != 0)
 828         {
 829                 prs_uint32("len_value2", ps, depth, &(r_q->len_value2));
 830         }
 831
 832         prs_uint32("status", ps, depth, &(r_q->status));
 833 }
 834
 835 /*******************************************************************
 836 makes a structure.
 837 ********************************************************************/
 838 void make_reg_q_create_val(REG_Q_CREATE_VALUE *q_i, POLICY_HND *pol,
 839                                 char *val_name, uint32 type,
 840                                 BUFFER3 *val)
 841 {
 842         int val_len = strlen(val_name) + 1;
 843
 844         if (q_i == NULL) return;
 845
 846         ZERO_STRUCTP(q_i);
 847
 848         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
 849
 850         make_uni_hdr(&q_i->hdr_name, val_len, val_len, 1);
 851         make_unistr2(&(q_i->uni_name), val_name, val_len);
 852
 853         q_i->type      = type;
 854         q_i->buf_value = val;
 855 }
 856
 857 /*******************************************************************
 858 reads or writes a structure.
 859 ********************************************************************/
 860 void reg_io_q_create_val(char *desc,  REG_Q_CREATE_VALUE *q_q, prs_struct *ps, int depth)
 861 {
 862         if (q_q == NULL) return;
 863
 864         prs_debug(ps, depth, desc, "reg_io_q_create_val");
 865         depth++;
 866
 867         prs_align(ps);
 868
 869         smb_io_pol_hnd("", &(q_q->pol), ps, depth);
 870
 871         smb_io_unihdr ("hdr_name", &(q_q->hdr_name), ps, depth);
 872         smb_io_unistr2("uni_name", &(q_q->uni_name), q_q->hdr_name.buffer, ps, depth);
 873         prs_align(ps);
 874
 875         prs_uint32("type", ps, depth, &(q_q->type));
 876         smb_io_buffer3("buf_value", q_q->buf_value, ps, depth);
 877         prs_align(ps);
 878 }
 879
 880 /*******************************************************************
 881 reads or writes a structure.
 882 ********************************************************************/
 883 void reg_io_r_create_val(char *desc,  REG_R_CREATE_VALUE *r_q, prs_struct *ps, int depth)
 884 {
 885         if (r_q == NULL) return;
 886
 887         prs_debug(ps, depth, desc, "reg_io_r_create_val");
 888         depth++;
 889
 890         prs_align(ps);
 891
 892         prs_uint32("status", ps, depth, &(r_q->status));
 893 }
 894
 895 /*******************************************************************
 896 makes a structure.
 897 ********************************************************************/
 898 void make_reg_q_enum_key(REG_Q_ENUM_KEY *q_i, POLICY_HND *pol, uint32 key_idx)
 899 {
 900         if (q_i == NULL) return;
 901
 902         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
 903
 904         q_i->key_index = key_idx;
 905         q_i->key_name_len = 0;
 906         q_i->unknown_1 = 0x0414;
 907
 908         q_i->ptr1 = 1;
 909         q_i->unknown_2 = 0x0000020A;
 910         memset(q_i->pad1, 0, sizeof(q_i->pad1));
 911
 912         q_i->ptr2 = 1;
 913         memset(q_i->pad2, 0, sizeof(q_i->pad2));
 914
 915         q_i->ptr3 = 1;
 916         unix_to_nt_time(&q_i->time, 0);            /* current time? */
 917 }
 918
 919 /*******************************************************************
 920 reads or writes a structure.
 921 ********************************************************************/
 922 void reg_io_q_enum_key(char *desc,  REG_Q_ENUM_KEY *q_q, prs_struct *ps, int depth)
 923 {
 924         if (q_q == NULL) return;
 925
 926         prs_debug(ps, depth, desc, "reg_io_q_enum_key");
 927         depth++;
 928
 929         prs_align(ps);
 930
 931         smb_io_pol_hnd("", &(q_q->pol), ps, depth);
 932
 933         prs_uint32("key_index", ps, depth, &(q_q->key_index));
 934         prs_uint16("key_name_len", ps, depth, &(q_q->key_name_len));
 935         prs_uint16("unknown_1", ps, depth, &(q_q->unknown_1));
 936
 937         prs_uint32("ptr1", ps, depth, &(q_q->ptr1));
 938
 939         if (q_q->ptr1 != 0)
 940         {
 941                 prs_uint32("unknown_2", ps, depth, &(q_q->unknown_2));
 942                 prs_uint8s(False, "pad1", ps, depth, q_q->pad1, sizeof(q_q->pad1));
 943         }
 944
 945         prs_uint32("ptr2", ps, depth, &(q_q->ptr2));
 946
 947         if (q_q->ptr2 != 0)
 948         {
 949                 prs_uint8s(False, "pad2", ps, depth, q_q->pad2, sizeof(q_q->pad2));
 950         }
 951
 952         prs_uint32("ptr3", ps, depth, &(q_q->ptr3));
 953
 954         if (q_q->ptr3 != 0)
 955         {
 956                 smb_io_time("", &(q_q->time), ps, depth);
 957         }
 958 }
 959
 960 /*******************************************************************
 961 reads or writes a structure.
 962 ********************************************************************/
 963 void reg_io_r_enum_key(char *desc,  REG_R_ENUM_KEY *r_q, prs_struct *ps, int depth)
 964 {
 965         if (r_q == NULL) return;
 966
 967         prs_debug(ps, depth, desc, "reg_io_r_enum_key");
 968         depth++;
 969
 970         prs_align(ps);
 971
 972         prs_uint16("key_name_len", ps, depth, &(r_q->key_name_len));
 973         prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1));
 974
 975         prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
 976
 977         if (r_q->ptr1 != 0)
 978         {
 979                 prs_uint32("unknown_2", ps, depth, &(r_q->unknown_2));
 980                 prs_uint32("unknown_3", ps, depth, &(r_q->unknown_3));
 981                 smb_io_unistr3("key_name", &(r_q->key_name), ps, depth);
 982                 prs_align(ps);
 983         }
 984
 985         prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
 986
 987         if (r_q->ptr2 != 0)
 988         {
 989                 prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2));
 990         }
 991
 992         prs_uint32("ptr3", ps, depth, &(r_q->ptr3));
 993
 994         if (r_q->ptr3 != 0)
 995         {
 996                 smb_io_time("", &(r_q->time), ps, depth);
 997         }
 998
 999         prs_uint32("status", ps, depth, &(r_q->status));
1000 }
1001
1002
1003 /*******************************************************************
1004 makes a structure.
1005 ********************************************************************/
1006 void make_reg_q_open_entry(REG_Q_OPEN_ENTRY *r_q, POLICY_HND *pol,
1007                                 char *key_name, uint32 unk)
1008 {
1009         int len_name = strlen(key_name)+1;
1010
1011         if (r_q == NULL) return;
1012
1013         memcpy(&(r_q->pol), pol, sizeof(r_q->pol));
1014
1015         make_uni_hdr(&(r_q->hdr_name), len_name, len_name, 1);
1016         make_unistr2(&(r_q->uni_name), key_name, len_name);
1017
1018         r_q->unknown_0 = 0x00000000;
1019         r_q->unknown_1 = unk;
1020 }
1021
1022 /*******************************************************************
1023 reads or writes a structure.
1024 ********************************************************************/
1025 void reg_io_q_open_entry(char *desc,  REG_Q_OPEN_ENTRY *r_q, prs_struct *ps, int depth)
1026 {
1027         if (r_q == NULL) return;
1028
1029         prs_debug(ps, depth, desc, "reg_io_q_entry");
1030         depth++;
1031
1032         prs_align(ps);
1033
1034         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
1035         smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
1036         smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
1037
1038         prs_align(ps);
1039
1040         prs_uint32("unknown_0", ps, depth, &(r_q->unknown_0));
1041         prs_uint32("unknown_1", ps, depth, &(r_q->unknown_1));
1042 }
1043
1044
1045 /*******************************************************************
1046 creates a structure.
1047 ********************************************************************/
1048 void make_reg_r_open_entry(REG_R_OPEN_ENTRY *r_r,
1049                                 POLICY_HND *pol, uint32 status)
1050 {
1051         if (r_r == NULL) return;
1052
1053         memcpy(&(r_r->pol), pol, sizeof(r_r->pol));
1054         r_r->status = status;
1055 }
1056
1057 /*******************************************************************
1058 reads or writes a structure.
1059 ********************************************************************/
1060 void reg_io_r_open_entry(char *desc,  REG_R_OPEN_ENTRY *r_r, prs_struct *ps, int depth)
1061 {
1062         if (r_r == NULL) return;
1063
1064         prs_debug(ps, depth, desc, "reg_io_r_open_entry");
1065         depth++;
1066
1067         prs_align(ps);
1068
1069         smb_io_pol_hnd("", &(r_r->pol), ps, depth);
1070
1071         prs_uint32("status", ps, depth, &(r_r->status));
1072 }
1073