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
 812                 prs_uint32("ptr2", ps, depth, &(r_r->ptr2));
 813
 814                 if (r_r->ptr2 != 0)
 815                 {
 816                         prs_uint32("unknown_0", ps, depth, &(r_r->unknown_0));
 817                 }
 818
 819                 prs_uint32("ptr3", ps, depth, &(r_r->ptr3));
 820
 821                 if (r_r->ptr3 != 0)
 822                 {
 823                         prs_uint32("unknown_1", ps, depth, &(r_r->unknown_1));
 824                 }
 825
 826         }
 827         prs_uint32("status", ps, depth, &(r_r->status));
 828 }
 829
 830 /*******************************************************************
 831 makes a structure.
 832 ********************************************************************/
 833 void make_reg_q_enum_val(REG_Q_ENUM_VALUE *q_i, POLICY_HND *pol,
 834                                 uint32 val_idx, uint32 max_val_len,
 835                                 uint32 max_buf_len)
 836 {
 837         if (q_i == NULL) return;
 838
 839         ZERO_STRUCTP(q_i);
 840
 841         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
 842
 843         q_i->val_index = val_idx;
 844         make_uni_hdr(&q_i->hdr_name, max_val_len, 0, 1);
 845         q_i->uni_name.uni_max_len = max_val_len;
 846
 847         q_i->ptr_type = 1;
 848         q_i->type = 0x0;
 849
 850         q_i->ptr_value = 1;
 851         q_i->buf_value.buf_max_len = max_buf_len;
 852
 853         q_i->ptr1 = 1;
 854         q_i->len_value1 = max_buf_len;
 855
 856         q_i->ptr2 = 1;
 857         q_i->len_value2 = 0;
 858 }
 859
 860 /*******************************************************************
 861 reads or writes a structure.
 862 ********************************************************************/
 863 void reg_io_q_enum_val(char *desc,  REG_Q_ENUM_VALUE *q_q, prs_struct *ps, int depth)
 864 {
 865         if (q_q == NULL) return;
 866
 867         prs_debug(ps, depth, desc, "reg_io_q_enum_val");
 868         depth++;
 869
 870         prs_align(ps);
 871
 872         smb_io_pol_hnd("", &(q_q->pol), ps, depth);
 873
 874         prs_uint32("val_index", ps, depth, &(q_q->val_index));
 875         smb_io_unihdr ("hdr_name", &(q_q->hdr_name), ps, depth);
 876         smb_io_unistr2("uni_name", &(q_q->uni_name), q_q->hdr_name.buffer, ps, depth);
 877         prs_align(ps);
 878
 879         prs_uint32("ptr_type", ps, depth, &(q_q->ptr_type));
 880
 881         if (q_q->ptr_type != 0)
 882         {
 883                 prs_uint32("type", ps, depth, &(q_q->type));
 884         }
 885
 886         prs_uint32("ptr_value", ps, depth, &(q_q->ptr_value));
 887         smb_io_buffer2("buf_value", &(q_q->buf_value), q_q->ptr_value, ps, depth);
 888         prs_align(ps);
 889
 890         prs_uint32("ptr1", ps, depth, &(q_q->ptr1));
 891         if (q_q->ptr1 != 0)
 892         {
 893                 prs_uint32("len_value1", ps, depth, &(q_q->len_value1));
 894         }
 895         prs_uint32("ptr2", ps, depth, &(q_q->ptr2));
 896         if (q_q->ptr2 != 0)
 897         {
 898                 prs_uint32("len_value2", ps, depth, &(q_q->len_value2));
 899         }
 900 }
 901
 902 /*******************************************************************
 903 reads or writes a structure.
 904 ********************************************************************/
 905 void reg_io_r_enum_val(char *desc,  REG_R_ENUM_VALUE *r_q, prs_struct *ps, int depth)
 906 {
 907         if (r_q == NULL) return;
 908
 909         prs_debug(ps, depth, desc, "reg_io_r_enum_val");
 910         depth++;
 911
 912         prs_align(ps);
 913
 914         smb_io_unihdr ("hdr_name", &(r_q->hdr_name), ps, depth);
 915         smb_io_unistr2("uni_name", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
 916         prs_align(ps);
 917
 918         prs_uint32("ptr_type", ps, depth, &(r_q->ptr_type));
 919
 920         if (r_q->ptr_type != 0)
 921         {
 922                 prs_uint32("type", ps, depth, &(r_q->type));
 923         }
 924
 925         prs_uint32("ptr_value", ps, depth, &(r_q->ptr_value));
 926         smb_io_buffer2("buf_value", r_q->buf_value, r_q->ptr_value, ps, depth);
 927         prs_align(ps);
 928
 929         prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
 930         if (r_q->ptr1 != 0)
 931         {
 932                 prs_uint32("len_value1", ps, depth, &(r_q->len_value1));
 933         }
 934
 935         prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
 936         if (r_q->ptr2 != 0)
 937         {
 938                 prs_uint32("len_value2", ps, depth, &(r_q->len_value2));
 939         }
 940
 941         prs_uint32("status", ps, depth, &(r_q->status));
 942 }
 943
 944 /*******************************************************************
 945 makes a structure.
 946 ********************************************************************/
 947 void make_reg_q_create_val(REG_Q_CREATE_VALUE *q_i, POLICY_HND *pol,
 948                                 char *val_name, uint32 type,
 949                                 BUFFER3 *val)
 950 {
 951         int val_len = strlen(val_name) + 1;
 952
 953         if (q_i == NULL) return;
 954
 955         ZERO_STRUCTP(q_i);
 956
 957         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
 958
 959         make_uni_hdr(&q_i->hdr_name, val_len, val_len, 1);
 960         make_unistr2(&(q_i->uni_name), val_name, val_len);
 961
 962         q_i->type      = type;
 963         q_i->buf_value = val;
 964 }
 965
 966 /*******************************************************************
 967 reads or writes a structure.
 968 ********************************************************************/
 969 void reg_io_q_create_val(char *desc,  REG_Q_CREATE_VALUE *q_q, prs_struct *ps, int depth)
 970 {
 971         if (q_q == NULL) return;
 972
 973         prs_debug(ps, depth, desc, "reg_io_q_create_val");
 974         depth++;
 975
 976         prs_align(ps);
 977
 978         smb_io_pol_hnd("", &(q_q->pol), ps, depth);
 979
 980         smb_io_unihdr ("hdr_name", &(q_q->hdr_name), ps, depth);
 981         smb_io_unistr2("uni_name", &(q_q->uni_name), q_q->hdr_name.buffer, ps, depth);
 982         prs_align(ps);
 983
 984         prs_uint32("type", ps, depth, &(q_q->type));
 985         smb_io_buffer3("buf_value", q_q->buf_value, ps, depth);
 986         prs_align(ps);
 987 }
 988
 989 /*******************************************************************
 990 reads or writes a structure.
 991 ********************************************************************/
 992 void reg_io_r_create_val(char *desc,  REG_R_CREATE_VALUE *r_q, prs_struct *ps, int depth)
 993 {
 994         if (r_q == NULL) return;
 995
 996         prs_debug(ps, depth, desc, "reg_io_r_create_val");
 997         depth++;
 998
 999         prs_align(ps);
1000
1001         prs_uint32("status", ps, depth, &(r_q->status));
1002 }
1003
1004 /*******************************************************************
1005 makes a structure.
1006 ********************************************************************/
1007 void make_reg_q_enum_key(REG_Q_ENUM_KEY *q_i, POLICY_HND *pol, uint32 key_idx)
1008 {
1009         if (q_i == NULL) return;
1010
1011         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
1012
1013         q_i->key_index = key_idx;
1014         q_i->key_name_len = 0;
1015         q_i->unknown_1 = 0x0414;
1016
1017         q_i->ptr1 = 1;
1018         q_i->unknown_2 = 0x0000020A;
1019         memset(q_i->pad1, 0, sizeof(q_i->pad1));
1020
1021         q_i->ptr2 = 1;
1022         memset(q_i->pad2, 0, sizeof(q_i->pad2));
1023
1024         q_i->ptr3 = 1;
1025         init_nt_time(&(q_i->time));   /* ignored ? */
1026 }
1027
1028 /*******************************************************************
1029 reads or writes a structure.
1030 ********************************************************************/
1031 void reg_io_q_enum_key(char *desc,  REG_Q_ENUM_KEY *q_q, prs_struct *ps, int depth)
1032 {
1033         if (q_q == NULL) return;
1034
1035         prs_debug(ps, depth, desc, "reg_io_q_enum_key");
1036         depth++;
1037
1038         prs_align(ps);
1039
1040         smb_io_pol_hnd("", &(q_q->pol), ps, depth);
1041
1042         prs_uint32("key_index", ps, depth, &(q_q->key_index));
1043         prs_uint16("key_name_len", ps, depth, &(q_q->key_name_len));
1044         prs_uint16("unknown_1", ps, depth, &(q_q->unknown_1));
1045
1046         prs_uint32("ptr1", ps, depth, &(q_q->ptr1));
1047
1048         if (q_q->ptr1 != 0)
1049         {
1050                 prs_uint32("unknown_2", ps, depth, &(q_q->unknown_2));
1051                 prs_uint8s(False, "pad1", ps, depth, q_q->pad1, sizeof(q_q->pad1));
1052         }
1053
1054         prs_uint32("ptr2", ps, depth, &(q_q->ptr2));
1055
1056         if (q_q->ptr2 != 0)
1057         {
1058                 prs_uint8s(False, "pad2", ps, depth, q_q->pad2, sizeof(q_q->pad2));
1059         }
1060
1061         prs_uint32("ptr3", ps, depth, &(q_q->ptr3));
1062
1063         if (q_q->ptr3 != 0)
1064         {
1065                 smb_io_time("", &(q_q->time), ps, depth);
1066         }
1067 }
1068
1069 /*******************************************************************
1070 reads or writes a structure.
1071 ********************************************************************/
1072 void reg_io_r_enum_key(char *desc,  REG_R_ENUM_KEY *r_q, prs_struct *ps, int depth)
1073 {
1074         if (r_q == NULL) return;
1075
1076         prs_debug(ps, depth, desc, "reg_io_r_enum_key");
1077         depth++;
1078
1079         prs_align(ps);
1080
1081         prs_uint16("key_name_len", ps, depth, &(r_q->key_name_len));
1082         prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1));
1083
1084         prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
1085
1086         if (r_q->ptr1 != 0)
1087         {
1088                 prs_uint32("unknown_2", ps, depth, &(r_q->unknown_2));
1089                 prs_uint32("unknown_3", ps, depth, &(r_q->unknown_3));
1090                 smb_io_unistr3("key_name", &(r_q->key_name), ps, depth);
1091                 prs_align(ps);
1092         }
1093
1094         prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
1095
1096         if (r_q->ptr2 != 0)
1097         {
1098                 prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2));
1099         }
1100
1101         prs_uint32("ptr3", ps, depth, &(r_q->ptr3));
1102
1103         if (r_q->ptr3 != 0)
1104         {
1105                 smb_io_time("", &(r_q->time), ps, depth);
1106         }
1107
1108         prs_uint32("status", ps, depth, &(r_q->status));
1109 }
1110
1111
1112 /*******************************************************************
1113 makes a structure.
1114 ********************************************************************/
1115 void make_reg_q_open_entry(REG_Q_OPEN_ENTRY *r_q, POLICY_HND *pol,
1116                                 char *key_name, uint32 unk)
1117 {
1118         int len_name = strlen(key_name)+1;
1119
1120         if (r_q == NULL) return;
1121
1122         memcpy(&(r_q->pol), pol, sizeof(r_q->pol));
1123
1124         make_uni_hdr(&(r_q->hdr_name), len_name, len_name, 1);
1125         make_unistr2(&(r_q->uni_name), key_name, len_name);
1126
1127         r_q->unknown_0 = 0x00000000;
1128         r_q->unknown_1 = unk;
1129 }
1130
1131 /*******************************************************************
1132 reads or writes a structure.
1133 ********************************************************************/
1134 void reg_io_q_open_entry(char *desc,  REG_Q_OPEN_ENTRY *r_q, prs_struct *ps, int depth)
1135 {
1136         if (r_q == NULL) return;
1137
1138         prs_debug(ps, depth, desc, "reg_io_q_entry");
1139         depth++;
1140
1141         prs_align(ps);
1142
1143         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
1144         smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
1145         smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
1146
1147         prs_align(ps);
1148
1149         prs_uint32("unknown_0", ps, depth, &(r_q->unknown_0));
1150         prs_uint32("unknown_1", ps, depth, &(r_q->unknown_1));
1151 }
1152
1153
1154 /*******************************************************************
1155 creates a structure.
1156 ********************************************************************/
1157 void make_reg_r_open_entry(REG_R_OPEN_ENTRY *r_r,
1158                                 POLICY_HND *pol, uint32 status)
1159 {
1160         if (r_r == NULL) return;
1161
1162         memcpy(&(r_r->pol), pol, sizeof(r_r->pol));
1163         r_r->status = status;
1164 }
1165
1166 /*******************************************************************
1167 reads or writes a structure.
1168 ********************************************************************/
1169 void reg_io_r_open_entry(char *desc,  REG_R_OPEN_ENTRY *r_r, prs_struct *ps, int depth)
1170 {
1171         if (r_r == NULL) return;
1172
1173         prs_debug(ps, depth, desc, "reg_io_r_open_entry");
1174         depth++;
1175
1176         prs_align(ps);
1177
1178         smb_io_pol_hnd("", &(r_r->pol), ps, depth);
1179
1180         prs_uint32("status", ps, depth, &(r_r->status));
1181 }
1182
1183 /*******************************************************************
1184 makes a structure.
1185 ********************************************************************/
1186 void make_reg_q_shutdown(REG_Q_SHUTDOWN *q_i,
1187                                 char *msg, uint32 timeout, uint16 flags)
1188 {
1189         int len = strlen(msg) + 1;
1190
1191         if (q_i == NULL) return;
1192
1193         ZERO_STRUCTP(q_i);
1194
1195         q_i->ptr_0 = 1;
1196         q_i->ptr_1 = 1;
1197         q_i->ptr_2 = 1;
1198
1199         make_uni_hdr(&q_i->hdr_msg, len, len, 1);
1200         make_unistr2(&(q_i->uni_msg), msg, len);
1201
1202         q_i->timeout = timeout;
1203         q_i->flags   = flags;
1204 }
1205
1206 /*******************************************************************
1207 reads or writes a structure.
1208 ********************************************************************/
1209 void reg_io_q_shutdown(char *desc,  REG_Q_SHUTDOWN *q_q, prs_struct *ps, int depth)
1210 {
1211         if (q_q == NULL) return;
1212
1213         prs_debug(ps, depth, desc, "reg_io_q_shutdown");
1214         depth++;
1215
1216         prs_align(ps);
1217
1218         prs_uint32("ptr_0", ps, depth, &(q_q->ptr_0));
1219         prs_uint32("ptr_1", ps, depth, &(q_q->ptr_1));
1220         prs_uint32("ptr_2", ps, depth, &(q_q->ptr_2));
1221
1222         smb_io_unihdr ("hdr_msg", &(q_q->hdr_msg), ps, depth);
1223         smb_io_unistr2("uni_msg", &(q_q->uni_msg), q_q->hdr_msg.buffer, ps, depth);
1224         prs_align(ps);
1225
1226         prs_uint32("timeout", ps, depth, &(q_q->timeout));
1227         prs_uint16("flags  ", ps, depth, &(q_q->flags  ));
1228         prs_align(ps);
1229 }
1230
1231 /*******************************************************************
1232 reads or writes a structure.
1233 ********************************************************************/
1234 void reg_io_r_shutdown(char *desc,  REG_R_SHUTDOWN *r_q, prs_struct *ps, int depth)
1235 {
1236         if (r_q == NULL) return;
1237
1238         prs_debug(ps, depth, desc, "reg_io_r_shutdown");
1239         depth++;
1240
1241         prs_align(ps);
1242
1243         prs_uint32("status", ps, depth, &(r_q->status));
1244 }
1245