source/rpc_parse/parse_misc.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 static TALLOC_CTX *parse_misc_talloc = NULL;
  30
  31 /******************************************************************* a
  32 free up temporary memory - called from the main loop
  33 ********************************************************************/
  34
  35 void parse_talloc_free(void)
  36 {
  37     if (!parse_misc_talloc)
  38         return;
  39     talloc_destroy(parse_misc_talloc);
  40     parse_misc_talloc = NULL;
  41 }
  42
  43 /*******************************************************************
  44  Reads or writes a UTIME type.
  45 ********************************************************************/
  46
  47 static BOOL smb_io_utime(char *desc, UTIME *t, prs_struct *ps, int depth)
  48 {
  49         if (t == NULL)
  50                 return False;
  51
  52         prs_debug(ps, depth, desc, "smb_io_utime");
  53         depth++;
  54
  55         if(!prs_align(ps))
  56                 return False;
  57
  58         if(!prs_uint32 ("time", ps, depth, &t->time))
  59                 return False;
  60
  61         return True;
  62 }
  63
  64 /*******************************************************************
  65  Reads or writes an NTTIME structure.
  66 ********************************************************************/
  67
  68 BOOL smb_io_time(char *desc, NTTIME *nttime, prs_struct *ps, int depth)
  69 {
  70         if (nttime == NULL)
  71                 return False;
  72
  73         prs_debug(ps, depth, desc, "smb_io_time");
  74         depth++;
  75
  76         if(!prs_align(ps))
  77                 return False;
  78
  79         if(!prs_uint32("low ", ps, depth, &nttime->low)) /* low part */
  80                 return False;
  81         if(!prs_uint32("high", ps, depth, &nttime->high)) /* high part */
  82                 return False;
  83
  84         return True;
  85 }
  86
  87 /*******************************************************************
  88  Reads or writes a LOOKUP_LEVEL structure.
  89 ********************************************************************/
  90
  91 BOOL smb_io_lookup_level(char *desc, LOOKUP_LEVEL *level, prs_struct *ps, int depth)
  92 {
  93         if (level == NULL)
  94                 return False;
  95
  96         prs_debug(ps, depth, desc, "smb_io_lookup_level");
  97         depth++;
  98
  99         if(!prs_align(ps))
 100                 return False;
 101         if(!prs_uint16("value", ps, depth, &level->value))
 102                 return False;
 103         if(!prs_align(ps))
 104                 return False;
 105
 106         return True;
 107 }
 108
 109 /*******************************************************************
 110  Gets an enumeration handle from an ENUM_HND structure.
 111 ********************************************************************/
 112
 113 uint32 get_enum_hnd(ENUM_HND *enh)
 114 {
 115         return (enh && enh->ptr_hnd != 0) ? enh->handle : 0;
 116 }
 117
 118 /*******************************************************************
 119  Inits an ENUM_HND structure.
 120 ********************************************************************/
 121
 122 void init_enum_hnd(ENUM_HND *enh, uint32 hnd)
 123 {
 124         DEBUG(5,("smb_io_enum_hnd\n"));
 125
 126         enh->ptr_hnd = (hnd != 0) ? 1 : 0;
 127         enh->handle = hnd;
 128 }
 129
 130 /*******************************************************************
 131  Reads or writes an ENUM_HND structure.
 132 ********************************************************************/
 133
 134 BOOL smb_io_enum_hnd(char *desc, ENUM_HND *hnd, prs_struct *ps, int depth)
 135 {
 136         if (hnd == NULL)
 137                 return False;
 138
 139         prs_debug(ps, depth, desc, "smb_io_enum_hnd");
 140         depth++;
 141
 142         if(!prs_align(ps))
 143                 return False;
 144
 145         if(!prs_uint32("ptr_hnd", ps, depth, &hnd->ptr_hnd)) /* pointer */
 146                 return False;
 147
 148         if (hnd->ptr_hnd != 0) {
 149                 if(!prs_uint32("handle ", ps, depth, &hnd->handle )) /* enum handle */
 150                         return False;
 151         }
 152
 153         return True;
 154 }
 155
 156 /*******************************************************************
 157  Reads or writes a DOM_SID structure.
 158 ********************************************************************/
 159
 160 BOOL smb_io_dom_sid(char *desc, DOM_SID *sid, prs_struct *ps, int depth)
 161 {
 162         int i;
 163
 164         if (sid == NULL)
 165                 return False;
 166
 167         prs_debug(ps, depth, desc, "smb_io_dom_sid");
 168         depth++;
 169
 170         if(!prs_align(ps))
 171                 return False;
 172
 173         if(!prs_uint8 ("sid_rev_num", ps, depth, &sid->sid_rev_num))
 174                 return False;
 175         if(!prs_uint8 ("num_auths  ", ps, depth, &sid->num_auths))
 176                 return False;
 177
 178         for (i = 0; i < 6; i++)
 179         {
 180                 fstring tmp;
 181                 slprintf(tmp, sizeof(tmp) - 1, "id_auth[%d] ", i);
 182                 if(!prs_uint8 (tmp, ps, depth, &sid->id_auth[i]))
 183                         return False;
 184         }
 185
 186         /* oops! XXXX should really issue a warning here... */
 187         if (sid->num_auths > MAXSUBAUTHS)
 188                 sid->num_auths = MAXSUBAUTHS;
 189
 190         if(!prs_uint32s(False, "sub_auths ", ps, depth, sid->sub_auths, sid->num_auths))
 191                 return False;
 192
 193         return True;
 194 }
 195
 196 /*******************************************************************
 197  Inits a DOM_SID structure.
 198
 199  BIG NOTE: this function only does SIDS where the identauth is not >= 2^32
 200  identauth >= 2^32 can be detected because it will be specified in hex
 201 ********************************************************************/
 202
 203 void init_dom_sid(DOM_SID *sid, char *str_sid)
 204 {
 205         pstring domsid;
 206         int identauth;
 207         char *p;
 208
 209         if (str_sid == NULL)
 210         {
 211                 DEBUG(4,("netlogon domain SID: none\n"));
 212                 sid->sid_rev_num = 0;
 213                 sid->num_auths = 0;
 214                 return;
 215         }
 216
 217         pstrcpy(domsid, str_sid);
 218
 219         DEBUG(4,("init_dom_sid %d SID:  %s\n", __LINE__, domsid));
 220
 221         /* assume, but should check, that domsid starts "S-" */
 222         p = strtok(domsid+2,"-");
 223         sid->sid_rev_num = atoi(p);
 224
 225         /* identauth in decimal should be <  2^32 */
 226         /* identauth in hex     should be >= 2^32 */
 227         identauth = atoi(strtok(0,"-"));
 228
 229         DEBUG(4,("netlogon rev %d\n", sid->sid_rev_num));
 230         DEBUG(4,("netlogon %s ia %d\n", p, identauth));
 231
 232         sid->id_auth[0] = 0;
 233         sid->id_auth[1] = 0;
 234         sid->id_auth[2] = (identauth & 0xff000000) >> 24;
 235         sid->id_auth[3] = (identauth & 0x00ff0000) >> 16;
 236         sid->id_auth[4] = (identauth & 0x0000ff00) >> 8;
 237         sid->id_auth[5] = (identauth & 0x000000ff);
 238
 239         sid->num_auths = 0;
 240
 241         while ((p = strtok(0, "-")) != NULL && sid->num_auths < MAXSUBAUTHS)
 242                 sid->sub_auths[sid->num_auths++] = atoi(p);
 243
 244         DEBUG(4,("init_dom_sid: %d SID:  %s\n", __LINE__, domsid));
 245 }
 246
 247 /*******************************************************************
 248  Inits a DOM_SID2 structure.
 249 ********************************************************************/
 250
 251 void init_dom_sid2(DOM_SID2 *sid2, DOM_SID *sid)
 252 {
 253         sid2->sid = *sid;
 254         sid2->num_auths = sid2->sid.num_auths;
 255 }
 256
 257 /*******************************************************************
 258  Reads or writes a DOM_SID2 structure.
 259 ********************************************************************/
 260
 261 BOOL smb_io_dom_sid2(char *desc, DOM_SID2 *sid, prs_struct *ps, int depth)
 262 {
 263         if (sid == NULL)
 264                 return False;
 265
 266         prs_debug(ps, depth, desc, "smb_io_dom_sid2");
 267         depth++;
 268
 269         if(!prs_align(ps))
 270                 return False;
 271
 272         if(!prs_uint32("num_auths", ps, depth, &sid->num_auths))
 273                 return False;
 274
 275         if(!smb_io_dom_sid("sid", &sid->sid, ps, depth))
 276                 return False;
 277
 278         return True;
 279 }
 280
 281 /*******************************************************************
 282 creates a STRHDR structure.
 283 ********************************************************************/
 284
 285 void init_str_hdr(STRHDR *hdr, int max_len, int len, uint32 buffer)
 286 {
 287         hdr->str_max_len = max_len;
 288         hdr->str_str_len = len;
 289         hdr->buffer      = buffer;
 290 }
 291
 292 /*******************************************************************
 293  Reads or writes a STRHDR structure.
 294 ********************************************************************/
 295
 296 BOOL smb_io_strhdr(char *desc,  STRHDR *hdr, prs_struct *ps, int depth)
 297 {
 298         if (hdr == NULL)
 299                 return False;
 300
 301         prs_debug(ps, depth, desc, "smb_io_strhdr");
 302         depth++;
 303
 304         prs_align(ps);
 305
 306         if(!prs_uint16("str_str_len", ps, depth, &hdr->str_str_len))
 307                 return False;
 308         if(!prs_uint16("str_max_len", ps, depth, &hdr->str_max_len))
 309                 return False;
 310         if(!prs_uint32("buffer     ", ps, depth, &hdr->buffer))
 311                 return False;
 312
 313         return True;
 314 }
 315
 316 /*******************************************************************
 317  Inits a UNIHDR structure.
 318 ********************************************************************/
 319
 320 void init_uni_hdr(UNIHDR *hdr, int len)
 321 {
 322         hdr->uni_str_len = 2 * len;
 323         hdr->uni_max_len = 2 * len;
 324         hdr->buffer      = len != 0 ? 1 : 0;
 325 }
 326
 327 /*******************************************************************
 328  Reads or writes a UNIHDR structure.
 329 ********************************************************************/
 330
 331 BOOL smb_io_unihdr(char *desc, UNIHDR *hdr, prs_struct *ps, int depth)
 332 {
 333         if (hdr == NULL)
 334                 return False;
 335
 336         prs_debug(ps, depth, desc, "smb_io_unihdr");
 337         depth++;
 338
 339         if(!prs_align(ps))
 340                 return False;
 341
 342         if(!prs_uint16("uni_str_len", ps, depth, &hdr->uni_str_len))
 343                 return False;
 344         if(!prs_uint16("uni_max_len", ps, depth, &hdr->uni_max_len))
 345                 return False;
 346         if(!prs_uint32("buffer     ", ps, depth, &hdr->buffer))
 347                 return False;
 348
 349         return True;
 350 }
 351
 352 /*******************************************************************
 353  Inits a BUFHDR structure.
 354 ********************************************************************/
 355
 356 void init_buf_hdr(BUFHDR *hdr, int max_len, int len)
 357 {
 358         hdr->buf_max_len = max_len;
 359         hdr->buf_len     = len;
 360 }
 361
 362 /*******************************************************************
 363  prs_uint16 wrapper. Call this and it sets up a pointer to where the
 364  uint16 should be stored, or gets the size if reading.
 365  ********************************************************************/
 366
 367 BOOL smb_io_hdrbuf_pre(char *desc, BUFHDR *hdr, prs_struct *ps, int depth, uint32 *offset)
 368 {
 369         (*offset) = prs_offset(ps);
 370         if (ps->io) {
 371
 372                 /* reading. */
 373
 374                 if(!smb_io_hdrbuf(desc, hdr, ps, depth))
 375                         return False;
 376
 377         } else {
 378
 379                 /* writing. */
 380
 381                 if(!prs_set_offset(ps, prs_offset(ps) + (sizeof(uint32) * 2)))
 382                         return False;
 383         }
 384
 385         return True;
 386 }
 387
 388 /*******************************************************************
 389  smb_io_hdrbuf wrapper. Call this and it retrospectively stores the size.
 390  Does nothing on reading, as that is already handled by ...._pre()
 391  ********************************************************************/
 392
 393 BOOL smb_io_hdrbuf_post(char *desc, BUFHDR *hdr, prs_struct *ps, int depth,
 394                                 uint32 ptr_hdrbuf, uint32 max_len, uint32 len)
 395 {
 396         if (!ps->io) {
 397                 /* writing: go back and do a retrospective job.  i hate this */
 398
 399                 uint32 old_offset = prs_offset(ps);
 400
 401                 init_buf_hdr(hdr, max_len, len);
 402                 if(!prs_set_offset(ps, ptr_hdrbuf))
 403                         return False;
 404                 if(!smb_io_hdrbuf(desc, hdr, ps, depth))
 405                         return False;
 406
 407                 if(!prs_set_offset(ps, old_offset))
 408                         return False;
 409         }
 410
 411         return True;
 412 }
 413
 414 /*******************************************************************
 415  Reads or writes a BUFHDR structure.
 416 ********************************************************************/
 417
 418 BOOL smb_io_hdrbuf(char *desc, BUFHDR *hdr, prs_struct *ps, int depth)
 419 {
 420         if (hdr == NULL)
 421                 return False;
 422
 423         prs_debug(ps, depth, desc, "smb_io_hdrbuf");
 424         depth++;
 425
 426         if(!prs_align(ps))
 427                 return False;
 428
 429         if(!prs_uint32("buf_max_len", ps, depth, &hdr->buf_max_len))
 430                 return False;
 431         if(!prs_uint32("buf_len    ", ps, depth, &hdr->buf_len))
 432                 return False;
 433
 434         return True;
 435 }
 436
 437 /*******************************************************************
 438 creates a UNIHDR2 structure.
 439 ********************************************************************/
 440
 441 void init_uni_hdr2(UNIHDR2 *hdr, int len)
 442 {
 443         init_uni_hdr(&hdr->unihdr, len);
 444         hdr->buffer = (len > 0) ? 1 : 0;
 445 }
 446
 447 /*******************************************************************
 448  Reads or writes a UNIHDR2 structure.
 449 ********************************************************************/
 450
 451 BOOL smb_io_unihdr2(char *desc, UNIHDR2 *hdr2, prs_struct *ps, int depth)
 452 {
 453         if (hdr2 == NULL)
 454                 return False;
 455
 456         prs_debug(ps, depth, desc, "smb_io_unihdr2");
 457         depth++;
 458
 459         if(!prs_align(ps))
 460                 return False;
 461
 462         if(!smb_io_unihdr("hdr", &hdr2->unihdr, ps, depth))
 463                 return False;
 464         if(!prs_uint32("buffer", ps, depth, &hdr2->buffer))
 465                 return False;
 466
 467         return True;
 468 }
 469
 470 /*******************************************************************
 471  Inits a UNISTR structure.
 472 ********************************************************************/
 473
 474 void init_unistr(UNISTR *str, const char *buf)
 475 {
 476         size_t len;
 477
 478         if (buf == NULL) {
 479                 str->buffer = NULL;
 480                 return;
 481         }
 482
 483
 484         len = strlen(buf) + 1;
 485
 486         if (!parse_misc_talloc)
 487                 parse_misc_talloc = talloc_init();
 488
 489         if (len < MAX_UNISTRLEN)
 490                 len = MAX_UNISTRLEN;
 491         len *= sizeof(uint16);
 492
 493         str->buffer = (uint16 *)talloc(parse_misc_talloc, len);
 494         if (str->buffer == NULL)
 495                 smb_panic("init_unistr: malloc fail\n");
 496
 497         /* store the string (null-terminated copy) */
 498         dos_struni2((char *)str->buffer, buf, len);
 499 }
 500
 501 /*******************************************************************
 502 reads or writes a UNISTR structure.
 503 XXXX NOTE: UNISTR structures NEED to be null-terminated.
 504 ********************************************************************/
 505
 506 BOOL smb_io_unistr(char *desc, UNISTR *uni, prs_struct *ps, int depth)
 507 {
 508         if (uni == NULL)
 509                 return False;
 510
 511         prs_debug(ps, depth, desc, "smb_io_unistr");
 512         depth++;
 513
 514         if(!prs_align(ps))
 515                 return False;
 516         if(!prs_unistr("unistr", ps, depth, uni))
 517                 return False;
 518
 519         return True;
 520 }
 521
 522 /*******************************************************************
 523  Allocate the BUFFER3 memory.
 524 ********************************************************************/
 525
 526 static void create_buffer3(BUFFER3 *str, size_t len)
 527 {
 528     if (!parse_misc_talloc)
 529                 parse_misc_talloc = talloc_init();
 530
 531         if (len < MAX_BUFFERLEN)
 532                 len = MAX_BUFFERLEN;
 533
 534     str->buffer = talloc(parse_misc_talloc, len);
 535         if (str->buffer == NULL)
 536                 smb_panic("create_buffer3: malloc fail\n");
 537
 538 }
 539
 540 /*******************************************************************
 541  Inits a BUFFER3 structure from a uint32
 542 ********************************************************************/
 543
 544 void init_buffer3_uint32(BUFFER3 *str, uint32 val)
 545 {
 546         ZERO_STRUCTP(str);
 547
 548         /* set up string lengths. */
 549         str->buf_max_len = sizeof(uint32);
 550         str->buf_len     = sizeof(uint32);
 551
 552         create_buffer3(str, sizeof(uint32));
 553         SIVAL(str->buffer, 0, val);
 554 }
 555
 556 /*******************************************************************
 557  Inits a BUFFER3 structure.
 558 ********************************************************************/
 559
 560 void init_buffer3_str(BUFFER3 *str, char *buf, int len)
 561 {
 562         ZERO_STRUCTP(str);
 563
 564         /* set up string lengths. */
 565         str->buf_max_len = len * 2;
 566         str->buf_len     = len * 2;
 567
 568         create_buffer3(str, str->buf_max_len);
 569
 570         /* store the string (null-terminated 8 bit chars into 16 bit chars) */
 571         dos_struni2((char *)str->buffer, buf, str->buf_max_len);
 572 }
 573
 574 /*******************************************************************
 575  Inits a BUFFER3 structure from a hex string.
 576 ********************************************************************/
 577
 578 void init_buffer3_hex(BUFFER3 *str, char *buf)
 579 {
 580         ZERO_STRUCTP(str);
 581         create_buffer3(str, strlen(buf));
 582         str->buf_max_len = str->buf_len = strhex_to_str((char *)str->buffer, sizeof(str->buffer), buf);
 583 }
 584
 585 /*******************************************************************
 586  Inits a BUFFER3 structure.
 587 ********************************************************************/
 588
 589 void init_buffer3_bytes(BUFFER3 *str, uint8 *buf, int len)
 590 {
 591         ZERO_STRUCTP(str);
 592
 593         /* max buffer size (allocated size) */
 594         str->buf_max_len = len;
 595         if (buf != NULL) {
 596                 create_buffer3(str, len);
 597                 memcpy(str->buffer, buf, len);
 598         }
 599         str->buf_len = buf != NULL ? len : 0;
 600 }
 601
 602 /*******************************************************************
 603  Reads or writes a BUFFER3 structure.
 604    the uni_max_len member tells you how large the buffer is.
 605    the uni_str_len member tells you how much of the buffer is really used.
 606 ********************************************************************/
 607
 608 BOOL smb_io_buffer3(char *desc, BUFFER3 *buf3, prs_struct *ps, int depth)
 609 {
 610         if (buf3 == NULL)
 611                 return False;
 612
 613         prs_debug(ps, depth, desc, "smb_io_buffer3");
 614         depth++;
 615
 616         if(!prs_align(ps))
 617                 return False;
 618
 619         if(!prs_uint32("uni_max_len", ps, depth, &buf3->buf_max_len))
 620                 return False;
 621
 622         if (UNMARSHALLING(ps)) {
 623                 buf3->buffer = prs_alloc_mem(ps, buf3->buf_max_len);
 624                 if (buf3->buffer == NULL)
 625                         return False;
 626         }
 627
 628         if(!prs_uint8s(True, "buffer     ", ps, depth, buf3->buffer, buf3->buf_max_len))
 629                 return False;
 630
 631         if(!prs_uint32("buf_len    ", ps, depth, &buf3->buf_len))
 632                 return False;
 633
 634         return True;
 635 }
 636
 637 /*******************************************************************
 638 reads or writes a BUFFER5 structure.
 639 the buf_len member tells you how large the buffer is.
 640 ********************************************************************/
 641 BOOL smb_io_buffer5(char *desc, BUFFER5 *buf5, prs_struct *ps, int depth)
 642 {
 643         prs_debug(ps, depth, desc, "smb_io_buffer5");
 644         depth++;
 645
 646         if (buf5 == NULL) return False;
 647
 648         prs_align(ps);
 649         prs_uint32("buf_len", ps, depth, &(buf5->buf_len));
 650
 651         /* reading: alloc the buffer first */
 652         if ( UNMARSHALLING(ps) ) {
 653                 buf5->buffer=(uint16 *)prs_alloc_mem(ps, sizeof(uint16)*buf5->buf_len );
 654                 if (buf5->buffer == NULL)
 655                         return False;
 656         }
 657
 658         prs_uint16s(True, "buffer", ps, depth, buf5->buffer, buf5->buf_len);
 659
 660         return True;
 661 }
 662
 663 /*******************************************************************
 664  Inits a BUFFER2 structure.
 665 ********************************************************************/
 666
 667 void init_buffer2(BUFFER2 *str, uint8 *buf, int len)
 668 {
 669         ZERO_STRUCTP(str);
 670
 671         /* max buffer size (allocated size) */
 672         str->buf_max_len = len;
 673         str->undoc       = 0;
 674         str->buf_len = buf != NULL ? len : 0;
 675
 676         if (buf != NULL) {
 677                 if (!parse_misc_talloc)
 678                         parse_misc_talloc = talloc_init();
 679
 680                 if (len < MAX_BUFFERLEN)
 681                         len = MAX_BUFFERLEN;
 682                 str->buffer = talloc(parse_misc_talloc, len);
 683                 if (str->buffer == NULL)
 684                         smb_panic("init_buffer2: malloc fail\n");
 685                 memcpy(str->buffer, buf, MIN(str->buf_len, len));
 686         }
 687 }
 688
 689 /*******************************************************************
 690  Reads or writes a BUFFER2 structure.
 691    the uni_max_len member tells you how large the buffer is.
 692    the uni_str_len member tells you how much of the buffer is really used.
 693 ********************************************************************/
 694
 695 BOOL smb_io_buffer2(char *desc, BUFFER2 *buf2, uint32 buffer, prs_struct *ps, int depth)
 696 {
 697         if (buf2 == NULL)
 698                 return False;
 699
 700         if (buffer) {
 701
 702                 prs_debug(ps, depth, desc, "smb_io_buffer2");
 703                 depth++;
 704
 705                 if(!prs_align(ps))
 706                         return False;
 707
 708                 if(!prs_uint32("uni_max_len", ps, depth, &buf2->buf_max_len))
 709                         return False;
 710                 if(!prs_uint32("undoc      ", ps, depth, &buf2->undoc))
 711                         return False;
 712                 if(!prs_uint32("buf_len    ", ps, depth, &buf2->buf_len))
 713                         return False;
 714
 715                 /* buffer advanced by indicated length of string
 716                    NOT by searching for null-termination */
 717
 718                 if(!prs_buffer2(True, "buffer     ", ps, depth, buf2))
 719                         return False;
 720
 721         } else {
 722
 723                 prs_debug(ps, depth, desc, "smb_io_buffer2 - NULL");
 724                 depth++;
 725                 memset((char *)buf2, '\0', sizeof(*buf2));
 726
 727         }
 728         return True;
 729 }
 730
 731 /*******************************************************************
 732 creates a UNISTR2 structure: sets up the buffer, too
 733 ********************************************************************/
 734
 735 void init_buf_unistr2(UNISTR2 *str, uint32 *ptr, const char *buf)
 736 {
 737         if (buf != NULL) {
 738
 739                 *ptr = 1;
 740                 init_unistr2(str, buf, strlen(buf)+1);
 741
 742         } else {
 743
 744                 *ptr = 0;
 745                 init_unistr2(str, "", 0);
 746
 747         }
 748 }
 749
 750 /*******************************************************************
 751  Copies a UNISTR2 structure.
 752 ********************************************************************/
 753
 754 void copy_unistr2(UNISTR2 *str, UNISTR2 *from)
 755 {
 756
 757         /* set up string lengths. add one if string is not null-terminated */
 758         str->uni_max_len = from->uni_max_len;
 759         str->undoc       = from->undoc;
 760         str->uni_str_len = from->uni_str_len;
 761
 762         if (from->buffer == NULL)
 763                 return;
 764
 765         /* the string buffer is allocated to the maximum size
 766            (the the length of the source string) to prevent
 767            reallocation of memory. */
 768         if (str->buffer == NULL) {
 769                 size_t len = from->uni_max_len * sizeof(uint16);
 770
 771                 if (!parse_misc_talloc)
 772                         parse_misc_talloc = talloc_init();
 773
 774                 if (len < MAX_UNISTRLEN)
 775                         len = MAX_UNISTRLEN;
 776                 len *= sizeof(uint16);
 777
 778                 str->buffer = (uint16 *)talloc(parse_misc_talloc, len);
 779                 if ((str->buffer == NULL) && (len > 0 ))
 780                 {
 781                         smb_panic("copy_unistr2: malloc fail\n");
 782                         return;
 783                 }
 784         }
 785
 786         /* copy the string */
 787         memcpy(str->buffer, from->buffer, from->uni_max_len*sizeof(uint16));
 788 }
 789
 790 /*******************************************************************
 791  Creates a STRING2 structure.
 792 ********************************************************************/
 793
 794 void init_string2(STRING2 *str, char *buf, int len)
 795 {
 796         int alloc_len = 0;
 797
 798         /* set up string lengths. */
 799         str->str_max_len = len;
 800         str->undoc       = 0;
 801         str->str_str_len = len;
 802
 803         /* store the string */
 804         if(len != 0) {
 805                 if (!parse_misc_talloc)
 806                         parse_misc_talloc = talloc_init();
 807
 808                 if (len < MAX_STRINGLEN)
 809                         alloc_len = MAX_STRINGLEN;
 810                 str->buffer = talloc(parse_misc_talloc, alloc_len);
 811                 if (str->buffer == NULL)
 812                         smb_panic("init_string2: malloc fail\n");
 813                 memcpy(str->buffer, buf, len);
 814   }
 815 }
 816
 817 /*******************************************************************
 818  Reads or writes a STRING2 structure.
 819  XXXX NOTE: STRING2 structures need NOT be null-terminated.
 820    the str_str_len member tells you how long the string is;
 821    the str_max_len member tells you how large the buffer is.
 822 ********************************************************************/
 823
 824 BOOL smb_io_string2(char *desc, STRING2 *str2, uint32 buffer, prs_struct *ps, int depth)
 825 {
 826         if (str2 == NULL)
 827                 return False;
 828
 829         if (buffer) {
 830
 831                 prs_debug(ps, depth, desc, "smb_io_string2");
 832                 depth++;
 833
 834                 if(!prs_align(ps))
 835                         return False;
 836
 837                 if(!prs_uint32("str_max_len", ps, depth, &str2->str_max_len))
 838                         return False;
 839                 if(!prs_uint32("undoc      ", ps, depth, &str2->undoc))
 840                         return False;
 841                 if(!prs_uint32("str_str_len", ps, depth, &str2->str_str_len))
 842                         return False;
 843
 844                 /* buffer advanced by indicated length of string
 845                    NOT by searching for null-termination */
 846                 if(!prs_string2(True, "buffer     ", ps, depth, str2))
 847                         return False;
 848
 849         } else {
 850
 851                 prs_debug(ps, depth, desc, "smb_io_string2 - NULL");
 852                 depth++;
 853                 memset((char *)str2, '\0', sizeof(*str2));
 854
 855         }
 856
 857         return True;
 858 }
 859
 860 /*******************************************************************
 861  Inits a UNISTR2 structure.
 862 ********************************************************************/
 863
 864 void init_unistr2(UNISTR2 *str, const char *buf, size_t len)
 865 {
 866         ZERO_STRUCTP(str);
 867
 868         /* set up string lengths. */
 869         str->uni_max_len = (uint32)len;
 870         str->undoc       = 0;
 871         str->uni_str_len = (uint32)len;
 872
 873         if (!parse_misc_talloc)
 874                 parse_misc_talloc = talloc_init();
 875
 876         if (len < MAX_UNISTRLEN)
 877                 len = MAX_UNISTRLEN;
 878         len *= sizeof(uint16);
 879
 880         str->buffer = (uint16 *)talloc(parse_misc_talloc, len);
 881         if ((str->buffer == NULL) && (len > 0))
 882         {
 883                 smb_panic("init_unistr2: malloc fail\n");
 884                 return;
 885         }
 886
 887         /* store the string (null-terminated 8 bit chars into 16 bit chars) */
 888         dos_struni2((char *)str->buffer, buf, len);
 889 }
 890
 891 /*******************************************************************
 892  Inits a UNISTR2 structure from a UNISTR
 893 ********************************************************************/
 894 void init_unistr2_from_unistr (UNISTR2 *to, UNISTR *from)
 895 {
 896
 897         uint32 i;
 898
 899         /* the destination UNISTR2 should never be NULL.
 900            if it is it is a programming error */
 901
 902         /* if the source UNISTR is NULL, then zero out
 903            the destination string and return */
 904         ZERO_STRUCTP (to);
 905         if ((from == NULL) || (from->buffer == NULL))
 906                 return;
 907
 908         /* get the length; UNISTR must be NULL terminated */
 909         i = 0;
 910         while ((from->buffer)[i]!='\0')
 911                 i++;
 912         i++;    /* one more to catch the terminating NULL */
 913                 /* is this necessary -- jerry?  I need to think */
 914
 915         /* set up string lengths; uni_max_len is set to i+1
 916            because we need to account for the final NULL termination */
 917         to->uni_max_len = i;
 918         to->undoc       = 0;
 919         to->uni_str_len = i;
 920
 921         if (!parse_misc_talloc)
 922                 parse_misc_talloc = talloc_init();
 923
 924         /* allocate the space and copy the string buffer */
 925         to->buffer = (uint16 *)talloc(parse_misc_talloc, sizeof(uint16)*(to->uni_str_len));
 926         if (to->buffer == NULL)
 927                 smb_panic("init_unistr2_from_unistr: malloc fail\n");
 928         memcpy(to->buffer, from->buffer, to->uni_max_len*sizeof(uint16));
 929
 930         return;
 931 }
 932
 933
 934 /*******************************************************************
 935  Reads or writes a UNISTR2 structure.
 936  XXXX NOTE: UNISTR2 structures need NOT be null-terminated.
 937    the uni_str_len member tells you how long the string is;
 938    the uni_max_len member tells you how large the buffer is.
 939 ********************************************************************/
 940
 941 BOOL smb_io_unistr2(char *desc, UNISTR2 *uni2, uint32 buffer, prs_struct *ps, int depth)
 942 {
 943         if (uni2 == NULL)
 944                 return False;
 945
 946         if (buffer) {
 947
 948                 prs_debug(ps, depth, desc, "smb_io_unistr2");
 949                 depth++;
 950
 951                 if(!prs_align(ps))
 952                         return False;
 953
 954                 if(!prs_uint32("uni_max_len", ps, depth, &uni2->uni_max_len))
 955                         return False;
 956                 if(!prs_uint32("undoc      ", ps, depth, &uni2->undoc))
 957                         return False;
 958                 if(!prs_uint32("uni_str_len", ps, depth, &uni2->uni_str_len))
 959                         return False;
 960
 961                 /* buffer advanced by indicated length of string
 962                    NOT by searching for null-termination */
 963                 if(!prs_unistr2(True, "buffer     ", ps, depth, uni2))
 964                         return False;
 965
 966         } else {
 967
 968                 prs_debug(ps, depth, desc, "smb_io_unistr2 - NULL");
 969                 depth++;
 970                 memset((char *)uni2, '\0', sizeof(*uni2));
 971
 972         }
 973
 974         return True;
 975 }
 976
 977 /*******************************************************************
 978  Inits a DOM_RID2 structure.
 979 ********************************************************************/
 980
 981 void init_dom_rid2(DOM_RID2 *rid2, uint32 rid, uint8 type, uint32 idx)
 982 {
 983         rid2->type    = type;
 984         rid2->rid     = rid;
 985         rid2->rid_idx = idx;
 986 }
 987
 988 /*******************************************************************
 989  Reads or writes a DOM_RID2 structure.
 990 ********************************************************************/
 991
 992 BOOL smb_io_dom_rid2(char *desc, DOM_RID2 *rid2, prs_struct *ps, int depth)
 993 {
 994         if (rid2 == NULL)
 995                 return False;
 996
 997         prs_debug(ps, depth, desc, "smb_io_dom_rid2");
 998         depth++;
 999
1000         if(!prs_align(ps))
1001                 return False;
1002
1003         if(!prs_uint8("type   ", ps, depth, &rid2->type))
1004                 return False;
1005         if(!prs_align(ps))
1006                 return False;
1007         if(!prs_uint32("rid    ", ps, depth, &rid2->rid))
1008                 return False;
1009         if(!prs_uint32("rid_idx", ps, depth, &rid2->rid_idx))
1010                 return False;
1011
1012         return True;
1013 }
1014
1015 /*******************************************************************
1016 creates a DOM_RID3 structure.
1017 ********************************************************************/
1018
1019 void init_dom_rid3(DOM_RID3 *rid3, uint32 rid, uint8 type)
1020 {
1021     rid3->rid      = rid;
1022     rid3->type1    = type;
1023     rid3->ptr_type = 0x1; /* non-zero, basically. */
1024     rid3->type2    = 0x1;
1025     rid3->unk      = type;
1026 }
1027
1028 /*******************************************************************
1029 reads or writes a DOM_RID3 structure.
1030 ********************************************************************/
1031
1032 BOOL smb_io_dom_rid3(char *desc, DOM_RID3 *rid3, prs_struct *ps, int depth)
1033 {
1034         if (rid3 == NULL)
1035                 return False;
1036
1037         prs_debug(ps, depth, desc, "smb_io_dom_rid3");
1038         depth++;
1039
1040         if(!prs_align(ps))
1041                 return False;
1042
1043         if(!prs_uint32("rid     ", ps, depth, &rid3->rid))
1044                 return False;
1045         if(!prs_uint32("type1   ", ps, depth, &rid3->type1))
1046                 return False;
1047         if(!prs_uint32("ptr_type", ps, depth, &rid3->ptr_type))
1048                 return False;
1049         if(!prs_uint32("type2   ", ps, depth, &rid3->type2))
1050                 return False;
1051         if(!prs_uint32("unk     ", ps, depth, &rid3->unk))
1052                 return False;
1053
1054         return True;
1055 }
1056
1057 /*******************************************************************
1058  Inits a DOM_RID4 structure.
1059 ********************************************************************/
1060
1061 void init_dom_rid4(DOM_RID4 *rid4, uint16 unknown, uint16 attr, uint32 rid)
1062 {
1063     rid4->unknown = unknown;
1064     rid4->attr    = attr;
1065     rid4->rid     = rid;
1066 }
1067
1068 /*******************************************************************
1069  Inits a DOM_CLNT_SRV structure.
1070 ********************************************************************/
1071
1072 static void init_clnt_srv(DOM_CLNT_SRV *log, char *logon_srv, char *comp_name)
1073 {
1074         DEBUG(5,("init_clnt_srv: %d\n", __LINE__));
1075
1076         if (logon_srv != NULL) {
1077                 log->undoc_buffer = 1;
1078                 init_unistr2(&log->uni_logon_srv, logon_srv, strlen(logon_srv)+1);
1079         } else {
1080                 log->undoc_buffer = 0;
1081         }
1082
1083         if (comp_name != NULL) {
1084                 log->undoc_buffer2 = 1;
1085                 init_unistr2(&log->uni_comp_name, comp_name, strlen(comp_name)+1);
1086         } else {
1087                 log->undoc_buffer2 = 0;
1088         }
1089 }
1090
1091 /*******************************************************************
1092  Inits or writes a DOM_CLNT_SRV structure.
1093 ********************************************************************/
1094
1095 static BOOL smb_io_clnt_srv(char *desc, DOM_CLNT_SRV *log, prs_struct *ps, int depth)
1096 {
1097         if (log == NULL)
1098                 return False;
1099
1100         prs_debug(ps, depth, desc, "smb_io_clnt_srv");
1101         depth++;
1102
1103         if(!prs_align(ps))
1104                 return False;
1105
1106         if(!prs_uint32("undoc_buffer ", ps, depth, &log->undoc_buffer))
1107                 return False;
1108
1109         if (log->undoc_buffer != 0) {
1110                 if(!smb_io_unistr2("unistr2", &log->uni_logon_srv, log->undoc_buffer, ps, depth))
1111                         return False;
1112         }
1113
1114         if(!prs_align(ps))
1115                 return False;
1116
1117         if(!prs_uint32("undoc_buffer2", ps, depth, &log->undoc_buffer2))
1118                 return False;
1119
1120         if (log->undoc_buffer2 != 0) {
1121                 if(!smb_io_unistr2("unistr2", &log->uni_comp_name, log->undoc_buffer2, ps, depth))
1122                         return False;
1123         }
1124
1125         return True;
1126 }
1127
1128 /*******************************************************************
1129  Inits a DOM_LOG_INFO structure.
1130 ********************************************************************/
1131
1132 void init_log_info(DOM_LOG_INFO *log, char *logon_srv, char *acct_name,
1133                 uint16 sec_chan, char *comp_name)
1134 {
1135         DEBUG(5,("make_log_info %d\n", __LINE__));
1136
1137         log->undoc_buffer = 1;
1138
1139         init_unistr2(&log->uni_logon_srv, logon_srv, strlen(logon_srv)+1);
1140         init_unistr2(&log->uni_acct_name, acct_name, strlen(acct_name)+1);
1141
1142         log->sec_chan = sec_chan;
1143
1144         init_unistr2(&log->uni_comp_name, comp_name, strlen(comp_name)+1);
1145 }
1146
1147 /*******************************************************************
1148  Reads or writes a DOM_LOG_INFO structure.
1149 ********************************************************************/
1150
1151 BOOL smb_io_log_info(char *desc, DOM_LOG_INFO *log, prs_struct *ps, int depth)
1152 {
1153         if (log == NULL)
1154                 return False;
1155
1156         prs_debug(ps, depth, desc, "smb_io_log_info");
1157         depth++;
1158
1159         if(!prs_align(ps))
1160                 return False;
1161
1162         if(!prs_uint32("undoc_buffer", ps, depth, &log->undoc_buffer))
1163                 return False;
1164
1165         if(!smb_io_unistr2("unistr2", &log->uni_logon_srv, True, ps, depth))
1166                 return False;
1167         if(!smb_io_unistr2("unistr2", &log->uni_acct_name, True, ps, depth))
1168                 return False;
1169
1170         if(!prs_uint16("sec_chan", ps, depth, &log->sec_chan))
1171                 return False;
1172
1173         if(!smb_io_unistr2("unistr2", &log->uni_comp_name, True, ps, depth))
1174                 return False;
1175
1176         return True;
1177 }
1178
1179 /*******************************************************************
1180  Reads or writes a DOM_CHAL structure.
1181 ********************************************************************/
1182
1183 BOOL smb_io_chal(char *desc, DOM_CHAL *chal, prs_struct *ps, int depth)
1184 {
1185         if (chal == NULL)
1186                 return False;
1187
1188         prs_debug(ps, depth, desc, "smb_io_chal");
1189         depth++;
1190
1191         if(!prs_align(ps))
1192                 return False;
1193
1194         if(!prs_uint8s (False, "data", ps, depth, chal->data, 8))
1195                 return False;
1196
1197         return True;
1198 }
1199
1200 /*******************************************************************
1201  Reads or writes a DOM_CRED structure.
1202 ********************************************************************/
1203
1204 BOOL smb_io_cred(char *desc,  DOM_CRED *cred, prs_struct *ps, int depth)
1205 {
1206         if (cred == NULL)
1207                 return False;
1208
1209         prs_debug(ps, depth, desc, "smb_io_cred");
1210         depth++;
1211
1212         if(!prs_align(ps))
1213                 return False;
1214
1215         if(!smb_io_chal ("", &cred->challenge, ps, depth))
1216                 return False;
1217         if(!smb_io_utime("", &cred->timestamp, ps, depth))
1218                 return False;
1219
1220         return True;
1221 }
1222
1223 /*******************************************************************
1224  Inits a DOM_CLNT_INFO2 structure.
1225 ********************************************************************/
1226
1227 void init_clnt_info2(DOM_CLNT_INFO2 *clnt,
1228                                 char *logon_srv, char *comp_name,
1229                                 DOM_CRED *clnt_cred)
1230 {
1231         DEBUG(5,("make_clnt_info: %d\n", __LINE__));
1232
1233         init_clnt_srv(&(clnt->login), logon_srv, comp_name);
1234
1235         if (clnt_cred != NULL) {
1236                 clnt->ptr_cred = 1;
1237                 memcpy(&(clnt->cred), clnt_cred, sizeof(clnt->cred));
1238         } else {
1239                 clnt->ptr_cred = 0;
1240         }
1241 }
1242
1243 /*******************************************************************
1244  Reads or writes a DOM_CLNT_INFO2 structure.
1245 ********************************************************************/
1246
1247 BOOL smb_io_clnt_info2(char *desc, DOM_CLNT_INFO2 *clnt, prs_struct *ps, int depth)
1248 {
1249         if (clnt == NULL)
1250                 return False;
1251
1252         prs_debug(ps, depth, desc, "smb_io_clnt_info2");
1253         depth++;
1254
1255         if(!prs_align(ps))
1256                 return False;
1257
1258         if(!smb_io_clnt_srv("", &clnt->login, ps, depth))
1259                 return False;
1260
1261         if(!prs_align(ps))
1262                 return False;
1263
1264         if(!prs_uint32("ptr_cred", ps, depth, &clnt->ptr_cred))
1265                 return False;
1266         if(!smb_io_cred("", &clnt->cred, ps, depth))
1267                 return False;
1268
1269         return True;
1270 }
1271
1272 /*******************************************************************
1273  Inits a DOM_CLNT_INFO structure.
1274 ********************************************************************/
1275
1276 void init_clnt_info(DOM_CLNT_INFO *clnt,
1277                 char *logon_srv, char *acct_name,
1278                 uint16 sec_chan, char *comp_name,
1279                                 DOM_CRED *cred)
1280 {
1281         DEBUG(5,("make_clnt_info\n"));
1282
1283         init_log_info(&clnt->login, logon_srv, acct_name, sec_chan, comp_name);
1284         memcpy(&clnt->cred, cred, sizeof(clnt->cred));
1285 }
1286
1287 /*******************************************************************
1288  Reads or writes a DOM_CLNT_INFO structure.
1289 ********************************************************************/
1290
1291 BOOL smb_io_clnt_info(char *desc,  DOM_CLNT_INFO *clnt, prs_struct *ps, int depth)
1292 {
1293         if (clnt == NULL)
1294                 return False;
1295
1296         prs_debug(ps, depth, desc, "smb_io_clnt_info");
1297         depth++;
1298
1299         if(!prs_align(ps))
1300                 return False;
1301
1302         if(!smb_io_log_info("", &clnt->login, ps, depth))
1303                 return False;
1304         if(!smb_io_cred("", &clnt->cred, ps, depth))
1305                 return False;
1306
1307         return True;
1308 }
1309
1310 /*******************************************************************
1311  Inits a DOM_LOGON_ID structure.
1312 ********************************************************************/
1313
1314 void init_logon_id(DOM_LOGON_ID *log, uint32 log_id_low, uint32 log_id_high)
1315 {
1316         DEBUG(5,("make_logon_id: %d\n", __LINE__));
1317
1318         log->low  = log_id_low;
1319         log->high = log_id_high;
1320 }
1321
1322 /*******************************************************************
1323  Reads or writes a DOM_LOGON_ID structure.
1324 ********************************************************************/
1325
1326 BOOL smb_io_logon_id(char *desc, DOM_LOGON_ID *log, prs_struct *ps, int depth)
1327 {
1328         if (log == NULL)
1329                 return False;
1330
1331         prs_debug(ps, depth, desc, "smb_io_logon_id");
1332         depth++;
1333
1334         if(!prs_align(ps))
1335                 return False;
1336
1337         if(!prs_uint32("low ", ps, depth, &log->low ))
1338                 return False;
1339         if(!prs_uint32("high", ps, depth, &log->high))
1340                 return False;
1341
1342         return True;
1343 }
1344
1345 /*******************************************************************
1346  Inits an OWF_INFO structure.
1347 ********************************************************************/
1348
1349 void init_owf_info(OWF_INFO *hash, uint8 data[16])
1350 {
1351         DEBUG(5,("init_owf_info: %d\n", __LINE__));
1352
1353         if (data != NULL)
1354                 memcpy(hash->data, data, sizeof(hash->data));
1355         else
1356                 memset((char *)hash->data, '\0', sizeof(hash->data));
1357 }
1358
1359 /*******************************************************************
1360  Reads or writes an OWF_INFO structure.
1361 ********************************************************************/
1362
1363 BOOL smb_io_owf_info(char *desc, OWF_INFO *hash, prs_struct *ps, int depth)
1364 {
1365         if (hash == NULL)
1366                 return False;
1367
1368         prs_debug(ps, depth, desc, "smb_io_owf_info");
1369         depth++;
1370
1371         if(!prs_align(ps))
1372                 return False;
1373
1374         if(!prs_uint8s (False, "data", ps, depth, hash->data, 16))
1375                 return False;
1376
1377         return True;
1378 }
1379
1380 /*******************************************************************
1381  Reads or writes a DOM_GID structure.
1382 ********************************************************************/
1383
1384 BOOL smb_io_gid(char *desc,  DOM_GID *gid, prs_struct *ps, int depth)
1385 {
1386         if (gid == NULL)
1387                 return False;
1388
1389         prs_debug(ps, depth, desc, "smb_io_gid");
1390         depth++;
1391
1392         if(!prs_align(ps))
1393                 return False;
1394
1395         if(!prs_uint32("g_rid", ps, depth, &gid->g_rid))
1396                 return False;
1397         if(!prs_uint32("attr ", ps, depth, &gid->attr))
1398                 return False;
1399
1400         return True;
1401 }
1402
1403 /*******************************************************************
1404  Reads or writes an POLICY_HND structure.
1405 ********************************************************************/
1406
1407 BOOL smb_io_pol_hnd(char *desc, POLICY_HND *pol, prs_struct *ps, int depth)
1408 {
1409         if (pol == NULL)
1410                 return False;
1411
1412         prs_debug(ps, depth, desc, "smb_io_pol_hnd");
1413         depth++;
1414
1415         if(!prs_align(ps))
1416                 return False;
1417
1418         if(!prs_uint8s (False, "data", ps, depth, pol->data, POL_HND_SIZE))
1419                 return False;
1420
1421         return True;
1422 }
1423
1424 /*******************************************************************
1425  Reads or writes a dom query structure.
1426 ********************************************************************/
1427
1428 static BOOL smb_io_dom_query(char *desc, DOM_QUERY *d_q, prs_struct *ps, int depth)
1429 {
1430         if (d_q == NULL)
1431                 return False;
1432
1433         prs_debug(ps, depth, desc, "smb_io_dom_query");
1434         depth++;
1435
1436         if(!prs_align(ps))
1437                 return False;
1438
1439         if(!prs_uint16("uni_dom_max_len", ps, depth, &d_q->uni_dom_max_len)) /* domain name string length * 2 */
1440                 return False;
1441         if(!prs_uint16("uni_dom_str_len", ps, depth, &d_q->uni_dom_str_len)) /* domain name string length * 2 */
1442                 return False;
1443
1444         if(!prs_uint32("buffer_dom_name", ps, depth, &d_q->buffer_dom_name)) /* undocumented domain name string buffer pointer */
1445                 return False;
1446         if(!prs_uint32("buffer_dom_sid ", ps, depth, &d_q->buffer_dom_sid)) /* undocumented domain SID string buffer pointer */
1447                 return False;
1448
1449         if(!smb_io_unistr2("unistr2", &d_q->uni_domain_name, d_q->buffer_dom_name, ps, depth)) /* domain name (unicode string) */
1450                 return False;
1451
1452         if(!prs_align(ps))
1453                 return False;
1454
1455         if (d_q->buffer_dom_sid != 0) {
1456                 if(!smb_io_dom_sid2("", &d_q->dom_sid, ps, depth)) /* domain SID */
1457                         return False;
1458         } else {
1459                 memset((char *)&d_q->dom_sid, '\0', sizeof(d_q->dom_sid));
1460         }
1461
1462         return True;
1463 }
1464
1465 /*******************************************************************
1466  Reads or writes a dom query structure.
1467 ********************************************************************/
1468
1469 BOOL smb_io_dom_query_3(char *desc, DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
1470 {
1471         return smb_io_dom_query("", d_q, ps, depth);
1472 }
1473
1474 /*******************************************************************
1475  Reads or writes a dom query structure.
1476 ********************************************************************/
1477
1478 BOOL smb_io_dom_query_5(char *desc, DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
1479 {
1480         return smb_io_dom_query("", d_q, ps, depth);
1481 }
1482
1483
1484 /*******************************************************************
1485  Reads or writes a UNISTR3 structure.
1486 ********************************************************************/
1487
1488 BOOL smb_io_unistr3(char *desc, UNISTR3 *name, prs_struct *ps, int depth)
1489 {
1490         if (name == NULL)
1491                 return False;
1492
1493         prs_debug(ps, depth, desc, "smb_io_unistr3");
1494         depth++;
1495
1496         if(!prs_align(ps))
1497                 return False;
1498
1499         if(!prs_uint32("uni_str_len", ps, depth, &name->uni_str_len))
1500                 return False;
1501
1502         /* don't know if len is specified by uni_str_len member... */
1503         /* assume unicode string is unicode-null-terminated, instead */
1504
1505         if(!prs_unistr3(True, "unistr", name, ps, depth))
1506                 return False;
1507
1508         return True;
1509 }
1510
1511
1512 /*******************************************************************
1513  Stream a uint64_struct
1514  ********************************************************************/
1515 BOOL prs_uint64(char *name, prs_struct *ps, int depth, UINT64_S *data64)
1516 {
1517         return prs_uint32(name, ps, depth+1, &data64->low) &&
1518                 prs_uint32(name, ps, depth+1, &data64->high);
1519 }
1520
1521