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         {
 480                 str->buffer = NULL;
 481                 return;
 482         }
 483
 484
 485         len = strlen(buf) + 1;
 486
 487         if (!parse_misc_talloc)
 488                 parse_misc_talloc = talloc_init();
 489
 490         if (len < MAX_UNISTRLEN)
 491                 len = MAX_UNISTRLEN;
 492         len *= sizeof(uint16);
 493
 494         str->buffer = (uint16 *)talloc(parse_misc_talloc, len);
 495         if (str->buffer == NULL)
 496                 smb_panic("init_unistr2: malloc fail\n");
 497
 498         /* store the string (null-terminated copy) */
 499         dos_struni2((char *)str->buffer, buf, len);
 500
 501         return;
 502 }
 503
 504 /*******************************************************************
 505 reads or writes a UNISTR structure.
 506 XXXX NOTE: UNISTR structures NEED to be null-terminated.
 507 ********************************************************************/
 508
 509 BOOL smb_io_unistr(char *desc, UNISTR *uni, prs_struct *ps, int depth)
 510 {
 511         if (uni == NULL)
 512                 return False;
 513
 514         prs_debug(ps, depth, desc, "smb_io_unistr");
 515         depth++;
 516
 517         if(!prs_align(ps))
 518                 return False;
 519         if(!prs_unistr("unistr", ps, depth, uni))
 520                 return False;
 521
 522         return True;
 523 }
 524
 525 /*******************************************************************
 526  Allocate the BUFFER3 memory.
 527 ********************************************************************/
 528
 529 static void create_buffer3(BUFFER3 *str, size_t len)
 530 {
 531     if (!parse_misc_talloc)
 532                 parse_misc_talloc = talloc_init();
 533
 534         if (len < MAX_BUFFERLEN)
 535                 len = MAX_BUFFERLEN;
 536
 537     str->buffer = talloc(parse_misc_talloc, len);
 538         if (str->buffer == NULL)
 539                 smb_panic("create_buffer3: malloc fail\n");
 540
 541 }
 542
 543 /*******************************************************************
 544  Inits a BUFFER3 structure from a uint32
 545 ********************************************************************/
 546
 547 void init_buffer3_uint32(BUFFER3 *str, uint32 val)
 548 {
 549         ZERO_STRUCTP(str);
 550
 551         /* set up string lengths. */
 552         str->buf_max_len = sizeof(uint32);
 553         str->buf_len     = sizeof(uint32);
 554
 555         create_buffer3(str, sizeof(uint32));
 556         SIVAL(str->buffer, 0, val);
 557 }
 558
 559 /*******************************************************************
 560  Inits a BUFFER3 structure.
 561 ********************************************************************/
 562
 563 void init_buffer3_str(BUFFER3 *str, char *buf, int len)
 564 {
 565         ZERO_STRUCTP(str);
 566
 567         /* set up string lengths. */
 568         str->buf_max_len = len * 2;
 569         str->buf_len     = len * 2;
 570
 571         create_buffer3(str, str->buf_max_len);
 572
 573         /* store the string (null-terminated 8 bit chars into 16 bit chars) */
 574         dos_struni2((char *)str->buffer, buf, str->buf_max_len);
 575 }
 576
 577 /*******************************************************************
 578  Inits a BUFFER3 structure from a hex string.
 579 ********************************************************************/
 580
 581 void init_buffer3_hex(BUFFER3 *str, char *buf)
 582 {
 583         ZERO_STRUCTP(str);
 584         create_buffer3(str, strlen(buf));
 585         str->buf_max_len = str->buf_len = strhex_to_str((char *)str->buffer, sizeof(str->buffer), buf);
 586 }
 587
 588 /*******************************************************************
 589  Inits a BUFFER3 structure.
 590 ********************************************************************/
 591
 592 void init_buffer3_bytes(BUFFER3 *str, uint8 *buf, int len)
 593 {
 594         ZERO_STRUCTP(str);
 595
 596         /* max buffer size (allocated size) */
 597         str->buf_max_len = len;
 598         if (buf != NULL) {
 599                 create_buffer3(str, len);
 600                 memcpy(str->buffer, buf, len);
 601         }
 602         str->buf_len = buf != NULL ? len : 0;
 603 }
 604
 605 /*******************************************************************
 606  Reads or writes a BUFFER3 structure.
 607    the uni_max_len member tells you how large the buffer is.
 608    the uni_str_len member tells you how much of the buffer is really used.
 609 ********************************************************************/
 610
 611 BOOL smb_io_buffer3(char *desc, BUFFER3 *buf3, prs_struct *ps, int depth)
 612 {
 613         if (buf3 == NULL)
 614                 return False;
 615
 616         prs_debug(ps, depth, desc, "smb_io_buffer3");
 617         depth++;
 618
 619         if(!prs_align(ps))
 620                 return False;
 621
 622         if(!prs_uint32("uni_max_len", ps, depth, &buf3->buf_max_len))
 623                 return False;
 624
 625         if (UNMARSHALLING(ps)) {
 626                 buf3->buffer = prs_alloc_mem(ps, buf3->buf_max_len);
 627                 if (buf3->buffer == NULL)
 628                         return False;
 629         }
 630
 631         if(!prs_uint8s(True, "buffer     ", ps, depth, buf3->buffer, buf3->buf_max_len))
 632                 return False;
 633
 634         if(!prs_uint32("buf_len    ", ps, depth, &buf3->buf_len))
 635                 return False;
 636
 637         return True;
 638 }
 639
 640 /*******************************************************************
 641 reads or writes a BUFFER5 structure.
 642 the buf_len member tells you how large the buffer is.
 643 ********************************************************************/
 644 BOOL smb_io_buffer5(char *desc, BUFFER5 *buf5, prs_struct *ps, int depth)
 645 {
 646         prs_debug(ps, depth, desc, "smb_io_buffer5");
 647         depth++;
 648
 649         if (buf5 == NULL) return False;
 650
 651         prs_align(ps);
 652         prs_uint32("buf_len", ps, depth, &(buf5->buf_len));
 653
 654         /* reading: alloc the buffer first */
 655         if ( UNMARSHALLING(ps) ) {
 656                 buf5->buffer=(uint16 *)prs_alloc_mem(ps, sizeof(uint16)*buf5->buf_len );
 657                 if (buf5->buffer == NULL)
 658                         return False;
 659         }
 660
 661         prs_uint16s(True, "buffer", ps, depth, buf5->buffer, buf5->buf_len);
 662
 663         return True;
 664 }
 665
 666 /*******************************************************************
 667  Inits a BUFFER2 structure.
 668 ********************************************************************/
 669
 670 void init_buffer2(BUFFER2 *str, uint8 *buf, int len)
 671 {
 672         ZERO_STRUCTP(str);
 673
 674         /* max buffer size (allocated size) */
 675         str->buf_max_len = len;
 676         str->undoc       = 0;
 677         str->buf_len = buf != NULL ? len : 0;
 678
 679         if (buf != NULL) {
 680                 if (!parse_misc_talloc)
 681                         parse_misc_talloc = talloc_init();
 682
 683                 if (len < MAX_BUFFERLEN)
 684                         len = MAX_BUFFERLEN;
 685                 str->buffer = talloc(parse_misc_talloc, len);
 686                 if (str->buffer == NULL)
 687                         smb_panic("init_buffer2: malloc fail\n");
 688                 memcpy(str->buffer, buf, MIN(str->buf_len, len));
 689         }
 690 }
 691
 692 /*******************************************************************
 693  Reads or writes a BUFFER2 structure.
 694    the uni_max_len member tells you how large the buffer is.
 695    the uni_str_len member tells you how much of the buffer is really used.
 696 ********************************************************************/
 697
 698 BOOL smb_io_buffer2(char *desc, BUFFER2 *buf2, uint32 buffer, prs_struct *ps, int depth)
 699 {
 700         if (buf2 == NULL)
 701                 return False;
 702
 703         if (buffer) {
 704
 705                 prs_debug(ps, depth, desc, "smb_io_buffer2");
 706                 depth++;
 707
 708                 if(!prs_align(ps))
 709                         return False;
 710
 711                 if(!prs_uint32("uni_max_len", ps, depth, &buf2->buf_max_len))
 712                         return False;
 713                 if(!prs_uint32("undoc      ", ps, depth, &buf2->undoc))
 714                         return False;
 715                 if(!prs_uint32("buf_len    ", ps, depth, &buf2->buf_len))
 716                         return False;
 717
 718                 /* buffer advanced by indicated length of string
 719                    NOT by searching for null-termination */
 720
 721                 if(!prs_buffer2(True, "buffer     ", ps, depth, buf2))
 722                         return False;
 723
 724         } else {
 725
 726                 prs_debug(ps, depth, desc, "smb_io_buffer2 - NULL");
 727                 depth++;
 728                 memset((char *)buf2, '\0', sizeof(*buf2));
 729
 730         }
 731         return True;
 732 }
 733
 734 /*******************************************************************
 735 creates a UNISTR2 structure: sets up the buffer, too
 736 ********************************************************************/
 737
 738 void init_buf_unistr2(UNISTR2 *str, uint32 *ptr, const char *buf)
 739 {
 740         if (buf != NULL) {
 741
 742                 *ptr = 1;
 743                 init_unistr2(str, buf, strlen(buf)+1);
 744
 745         } else {
 746
 747                 *ptr = 0;
 748                 init_unistr2(str, "", 0);
 749
 750         }
 751 }
 752
 753 /*******************************************************************
 754  Copies a UNISTR2 structure.
 755 ********************************************************************/
 756
 757 void copy_unistr2(UNISTR2 *str, UNISTR2 *from)
 758 {
 759         /* set up string lengths. add one if string is not null-terminated */
 760         str->uni_max_len = from->uni_max_len;
 761         str->undoc       = from->undoc;
 762         str->uni_str_len = from->uni_str_len;
 763
 764         if (str->buffer == NULL) {
 765                 size_t len = from->uni_max_len * 2;
 766
 767         if (!parse_misc_talloc)
 768                         parse_misc_talloc = talloc_init();
 769
 770                 if (len < MAX_UNISTRLEN)
 771                         len = MAX_UNISTRLEN;
 772                 len *= sizeof(uint16);
 773
 774                 str->buffer = (uint16 *)talloc(parse_misc_talloc, len);
 775                 if (str->buffer == NULL)
 776                         smb_panic("copy_unistr2: malloc fail\n");
 777         }
 778
 779         /* copy the string */
 780         memcpy(str->buffer, from->buffer, sizeof(from->buffer));
 781 }
 782
 783 /*******************************************************************
 784  Creates a STRING2 structure.
 785 ********************************************************************/
 786
 787 void init_string2(STRING2 *str, char *buf, int len)
 788 {
 789         int alloc_len = 0;
 790
 791         /* set up string lengths. */
 792         str->str_max_len = len;
 793         str->undoc       = 0;
 794         str->str_str_len = len;
 795
 796         /* store the string */
 797         if(len != 0) {
 798                 if (!parse_misc_talloc)
 799                         parse_misc_talloc = talloc_init();
 800
 801                 if (len < MAX_STRINGLEN)
 802                         alloc_len = MAX_STRINGLEN;
 803                 str->buffer = talloc(parse_misc_talloc, alloc_len);
 804                 if (str->buffer == NULL)
 805                         smb_panic("init_string2: malloc fail\n");
 806                 memcpy(str->buffer, buf, len);
 807   }
 808 }
 809
 810 /*******************************************************************
 811  Reads or writes a STRING2 structure.
 812  XXXX NOTE: STRING2 structures need NOT be null-terminated.
 813    the str_str_len member tells you how long the string is;
 814    the str_max_len member tells you how large the buffer is.
 815 ********************************************************************/
 816
 817 BOOL smb_io_string2(char *desc, STRING2 *str2, uint32 buffer, prs_struct *ps, int depth)
 818 {
 819         if (str2 == NULL)
 820                 return False;
 821
 822         if (buffer) {
 823
 824                 prs_debug(ps, depth, desc, "smb_io_string2");
 825                 depth++;
 826
 827                 if(!prs_align(ps))
 828                         return False;
 829
 830                 if(!prs_uint32("str_max_len", ps, depth, &str2->str_max_len))
 831                         return False;
 832                 if(!prs_uint32("undoc      ", ps, depth, &str2->undoc))
 833                         return False;
 834                 if(!prs_uint32("str_str_len", ps, depth, &str2->str_str_len))
 835                         return False;
 836
 837                 /* buffer advanced by indicated length of string
 838                    NOT by searching for null-termination */
 839                 if(!prs_string2(True, "buffer     ", ps, depth, str2))
 840                         return False;
 841
 842         } else {
 843
 844                 prs_debug(ps, depth, desc, "smb_io_string2 - NULL");
 845                 depth++;
 846                 memset((char *)str2, '\0', sizeof(*str2));
 847
 848         }
 849
 850         return True;
 851 }
 852
 853 /*******************************************************************
 854  Inits a UNISTR2 structure.
 855 ********************************************************************/
 856
 857 void init_unistr2(UNISTR2 *str, const char *buf, size_t len)
 858 {
 859         ZERO_STRUCTP(str);
 860
 861         /* set up string lengths. */
 862         str->uni_max_len = (uint32)len;
 863         str->undoc       = 0;
 864         str->uni_str_len = (uint32)len;
 865
 866         if (!parse_misc_talloc)
 867                 parse_misc_talloc = talloc_init();
 868
 869         if (len < MAX_UNISTRLEN)
 870                 len = MAX_UNISTRLEN;
 871         len *= sizeof(uint16);
 872
 873         str->buffer = (uint16 *)talloc(parse_misc_talloc, len);
 874         if (str->buffer == NULL)
 875                 smb_panic("init_unistr2: malloc fail\n");
 876
 877         /* store the string (null-terminated 8 bit chars into 16 bit chars) */
 878         dos_struni2((char *)str->buffer, buf, len);
 879 }
 880
 881 /*******************************************************************
 882  Inits a UNISTR2 structure from a UNISTR
 883 ********************************************************************/
 884 void init_unistr2_from_unistr (UNISTR2 *to, UNISTR *from)
 885 {
 886
 887         uint32 i;
 888
 889         /* the destination UNISTR2 should never be NULL.
 890            if it is it is a programming error */
 891
 892         /* if the source UNISTR is NULL, then zero out
 893            the destination string and return */
 894         ZERO_STRUCTP (to);
 895         if ((from == NULL) || (from->buffer == NULL))
 896                 return;
 897
 898         /* get the length; UNISTR must be NULL terminated */
 899         i = 0;
 900         while ((from->buffer)[i]!='\0')
 901                 i++;
 902
 903         /* set up string lengths; uni_max_len is set to i+1
 904            because we need to account for the final NULL termination */
 905         to->uni_max_len = i+1;
 906         to->undoc       = 0;
 907         to->uni_str_len = i+1;
 908
 909         if (!parse_misc_talloc)
 910                 parse_misc_talloc = talloc_init();
 911
 912         /* allocate the space and copy the string buffer */
 913         to->buffer = (uint16 *)talloc(parse_misc_talloc, sizeof(uint16)*(to->uni_str_len));
 914         if (to->buffer == NULL)
 915                 smb_panic("init_unistr2_from_unistr: malloc fail\n");
 916         memcpy(to->buffer, from->buffer, to->uni_max_len*sizeof(uint16));
 917
 918         return;
 919 }
 920
 921
 922 /*******************************************************************
 923  Reads or writes a UNISTR2 structure.
 924  XXXX NOTE: UNISTR2 structures need NOT be null-terminated.
 925    the uni_str_len member tells you how long the string is;
 926    the uni_max_len member tells you how large the buffer is.
 927 ********************************************************************/
 928
 929 BOOL smb_io_unistr2(char *desc, UNISTR2 *uni2, uint32 buffer, prs_struct *ps, int depth)
 930 {
 931         if (uni2 == NULL)
 932                 return False;
 933
 934         if (buffer) {
 935
 936                 prs_debug(ps, depth, desc, "smb_io_unistr2");
 937                 depth++;
 938
 939                 if(!prs_align(ps))
 940                         return False;
 941
 942                 if(!prs_uint32("uni_max_len", ps, depth, &uni2->uni_max_len))
 943                         return False;
 944                 if(!prs_uint32("undoc      ", ps, depth, &uni2->undoc))
 945                         return False;
 946                 if(!prs_uint32("uni_str_len", ps, depth, &uni2->uni_str_len))
 947                         return False;
 948
 949                 /* buffer advanced by indicated length of string
 950                    NOT by searching for null-termination */
 951                 if(!prs_unistr2(True, "buffer     ", ps, depth, uni2))
 952                         return False;
 953
 954         } else {
 955
 956                 prs_debug(ps, depth, desc, "smb_io_unistr2 - NULL");
 957                 depth++;
 958                 memset((char *)uni2, '\0', sizeof(*uni2));
 959
 960         }
 961
 962         return True;
 963 }
 964
 965 /*******************************************************************
 966  Inits a DOM_RID2 structure.
 967 ********************************************************************/
 968
 969 void init_dom_rid2(DOM_RID2 *rid2, uint32 rid, uint8 type, uint32 idx)
 970 {
 971         rid2->type    = type;
 972         rid2->rid     = rid;
 973         rid2->rid_idx = idx;
 974 }
 975
 976 /*******************************************************************
 977  Reads or writes a DOM_RID2 structure.
 978 ********************************************************************/
 979
 980 BOOL smb_io_dom_rid2(char *desc, DOM_RID2 *rid2, prs_struct *ps, int depth)
 981 {
 982         if (rid2 == NULL)
 983                 return False;
 984
 985         prs_debug(ps, depth, desc, "smb_io_dom_rid2");
 986         depth++;
 987
 988         if(!prs_align(ps))
 989                 return False;
 990
 991         if(!prs_uint8("type   ", ps, depth, &rid2->type))
 992                 return False;
 993         if(!prs_align(ps))
 994                 return False;
 995         if(!prs_uint32("rid    ", ps, depth, &rid2->rid))
 996                 return False;
 997         if(!prs_uint32("rid_idx", ps, depth, &rid2->rid_idx))
 998                 return False;
 999
1000         return True;
1001 }
1002
1003 /*******************************************************************
1004 creates a DOM_RID3 structure.
1005 ********************************************************************/
1006
1007 void init_dom_rid3(DOM_RID3 *rid3, uint32 rid, uint8 type)
1008 {
1009     rid3->rid      = rid;
1010     rid3->type1    = type;
1011     rid3->ptr_type = 0x1; /* non-zero, basically. */
1012     rid3->type2    = 0x1;
1013     rid3->unk      = type;
1014 }
1015
1016 /*******************************************************************
1017 reads or writes a DOM_RID3 structure.
1018 ********************************************************************/
1019
1020 BOOL smb_io_dom_rid3(char *desc, DOM_RID3 *rid3, prs_struct *ps, int depth)
1021 {
1022         if (rid3 == NULL)
1023                 return False;
1024
1025         prs_debug(ps, depth, desc, "smb_io_dom_rid3");
1026         depth++;
1027
1028         if(!prs_align(ps))
1029                 return False;
1030
1031         if(!prs_uint32("rid     ", ps, depth, &rid3->rid))
1032                 return False;
1033         if(!prs_uint32("type1   ", ps, depth, &rid3->type1))
1034                 return False;
1035         if(!prs_uint32("ptr_type", ps, depth, &rid3->ptr_type))
1036                 return False;
1037         if(!prs_uint32("type2   ", ps, depth, &rid3->type2))
1038                 return False;
1039         if(!prs_uint32("unk     ", ps, depth, &rid3->unk))
1040                 return False;
1041
1042         return True;
1043 }
1044
1045 /*******************************************************************
1046  Inits a DOM_RID4 structure.
1047 ********************************************************************/
1048
1049 void init_dom_rid4(DOM_RID4 *rid4, uint16 unknown, uint16 attr, uint32 rid)
1050 {
1051     rid4->unknown = unknown;
1052     rid4->attr    = attr;
1053     rid4->rid     = rid;
1054 }
1055
1056 /*******************************************************************
1057  Inits a DOM_CLNT_SRV structure.
1058 ********************************************************************/
1059
1060 static void init_clnt_srv(DOM_CLNT_SRV *log, char *logon_srv, char *comp_name)
1061 {
1062         DEBUG(5,("init_clnt_srv: %d\n", __LINE__));
1063
1064         if (logon_srv != NULL) {
1065                 log->undoc_buffer = 1;
1066                 init_unistr2(&log->uni_logon_srv, logon_srv, strlen(logon_srv)+1);
1067         } else {
1068                 log->undoc_buffer = 0;
1069         }
1070
1071         if (comp_name != NULL) {
1072                 log->undoc_buffer2 = 1;
1073                 init_unistr2(&log->uni_comp_name, comp_name, strlen(comp_name)+1);
1074         } else {
1075                 log->undoc_buffer2 = 0;
1076         }
1077 }
1078
1079 /*******************************************************************
1080  Inits or writes a DOM_CLNT_SRV structure.
1081 ********************************************************************/
1082
1083 static BOOL smb_io_clnt_srv(char *desc, DOM_CLNT_SRV *log, prs_struct *ps, int depth)
1084 {
1085         if (log == NULL)
1086                 return False;
1087
1088         prs_debug(ps, depth, desc, "smb_io_clnt_srv");
1089         depth++;
1090
1091         if(!prs_align(ps))
1092                 return False;
1093
1094         if(!prs_uint32("undoc_buffer ", ps, depth, &log->undoc_buffer))
1095                 return False;
1096
1097         if (log->undoc_buffer != 0) {
1098                 if(!smb_io_unistr2("unistr2", &log->uni_logon_srv, log->undoc_buffer, ps, depth))
1099                         return False;
1100         }
1101
1102         if(!prs_align(ps))
1103                 return False;
1104
1105         if(!prs_uint32("undoc_buffer2", ps, depth, &log->undoc_buffer2))
1106                 return False;
1107
1108         if (log->undoc_buffer2 != 0) {
1109                 if(!smb_io_unistr2("unistr2", &log->uni_comp_name, log->undoc_buffer2, ps, depth))
1110                         return False;
1111         }
1112
1113         return True;
1114 }
1115
1116 /*******************************************************************
1117  Inits a DOM_LOG_INFO structure.
1118 ********************************************************************/
1119
1120 void init_log_info(DOM_LOG_INFO *log, char *logon_srv, char *acct_name,
1121                 uint16 sec_chan, char *comp_name)
1122 {
1123         DEBUG(5,("make_log_info %d\n", __LINE__));
1124
1125         log->undoc_buffer = 1;
1126
1127         init_unistr2(&log->uni_logon_srv, logon_srv, strlen(logon_srv)+1);
1128         init_unistr2(&log->uni_acct_name, acct_name, strlen(acct_name)+1);
1129
1130         log->sec_chan = sec_chan;
1131
1132         init_unistr2(&log->uni_comp_name, comp_name, strlen(comp_name)+1);
1133 }
1134
1135 /*******************************************************************
1136  Reads or writes a DOM_LOG_INFO structure.
1137 ********************************************************************/
1138
1139 BOOL smb_io_log_info(char *desc, DOM_LOG_INFO *log, prs_struct *ps, int depth)
1140 {
1141         if (log == NULL)
1142                 return False;
1143
1144         prs_debug(ps, depth, desc, "smb_io_log_info");
1145         depth++;
1146
1147         if(!prs_align(ps))
1148                 return False;
1149
1150         if(!prs_uint32("undoc_buffer", ps, depth, &log->undoc_buffer))
1151                 return False;
1152
1153         if(!smb_io_unistr2("unistr2", &log->uni_logon_srv, True, ps, depth))
1154                 return False;
1155         if(!smb_io_unistr2("unistr2", &log->uni_acct_name, True, ps, depth))
1156                 return False;
1157
1158         if(!prs_uint16("sec_chan", ps, depth, &log->sec_chan))
1159                 return False;
1160
1161         if(!smb_io_unistr2("unistr2", &log->uni_comp_name, True, ps, depth))
1162                 return False;
1163
1164         return True;
1165 }
1166
1167 /*******************************************************************
1168  Reads or writes a DOM_CHAL structure.
1169 ********************************************************************/
1170
1171 BOOL smb_io_chal(char *desc, DOM_CHAL *chal, prs_struct *ps, int depth)
1172 {
1173         if (chal == NULL)
1174                 return False;
1175
1176         prs_debug(ps, depth, desc, "smb_io_chal");
1177         depth++;
1178
1179         if(!prs_align(ps))
1180                 return False;
1181
1182         if(!prs_uint8s (False, "data", ps, depth, chal->data, 8))
1183                 return False;
1184
1185         return True;
1186 }
1187
1188 /*******************************************************************
1189  Reads or writes a DOM_CRED structure.
1190 ********************************************************************/
1191
1192 BOOL smb_io_cred(char *desc,  DOM_CRED *cred, prs_struct *ps, int depth)
1193 {
1194         if (cred == NULL)
1195                 return False;
1196
1197         prs_debug(ps, depth, desc, "smb_io_cred");
1198         depth++;
1199
1200         if(!prs_align(ps))
1201                 return False;
1202
1203         if(!smb_io_chal ("", &cred->challenge, ps, depth))
1204                 return False;
1205         if(!smb_io_utime("", &cred->timestamp, ps, depth))
1206                 return False;
1207
1208         return True;
1209 }
1210
1211 /*******************************************************************
1212  Inits a DOM_CLNT_INFO2 structure.
1213 ********************************************************************/
1214
1215 void init_clnt_info2(DOM_CLNT_INFO2 *clnt,
1216                                 char *logon_srv, char *comp_name,
1217                                 DOM_CRED *clnt_cred)
1218 {
1219         DEBUG(5,("make_clnt_info: %d\n", __LINE__));
1220
1221         init_clnt_srv(&(clnt->login), logon_srv, comp_name);
1222
1223         if (clnt_cred != NULL) {
1224                 clnt->ptr_cred = 1;
1225                 memcpy(&(clnt->cred), clnt_cred, sizeof(clnt->cred));
1226         } else {
1227                 clnt->ptr_cred = 0;
1228         }
1229 }
1230
1231 /*******************************************************************
1232  Reads or writes a DOM_CLNT_INFO2 structure.
1233 ********************************************************************/
1234
1235 BOOL smb_io_clnt_info2(char *desc, DOM_CLNT_INFO2 *clnt, prs_struct *ps, int depth)
1236 {
1237         if (clnt == NULL)
1238                 return False;
1239
1240         prs_debug(ps, depth, desc, "smb_io_clnt_info2");
1241         depth++;
1242
1243         if(!prs_align(ps))
1244                 return False;
1245
1246         if(!smb_io_clnt_srv("", &clnt->login, ps, depth))
1247                 return False;
1248
1249         if(!prs_align(ps))
1250                 return False;
1251
1252         if(!prs_uint32("ptr_cred", ps, depth, &clnt->ptr_cred))
1253                 return False;
1254         if(!smb_io_cred("", &clnt->cred, ps, depth))
1255                 return False;
1256
1257         return True;
1258 }
1259
1260 /*******************************************************************
1261  Inits a DOM_CLNT_INFO structure.
1262 ********************************************************************/
1263
1264 void init_clnt_info(DOM_CLNT_INFO *clnt,
1265                 char *logon_srv, char *acct_name,
1266                 uint16 sec_chan, char *comp_name,
1267                                 DOM_CRED *cred)
1268 {
1269         DEBUG(5,("make_clnt_info\n"));
1270
1271         init_log_info(&clnt->login, logon_srv, acct_name, sec_chan, comp_name);
1272         memcpy(&clnt->cred, cred, sizeof(clnt->cred));
1273 }
1274
1275 /*******************************************************************
1276  Reads or writes a DOM_CLNT_INFO structure.
1277 ********************************************************************/
1278
1279 BOOL smb_io_clnt_info(char *desc,  DOM_CLNT_INFO *clnt, prs_struct *ps, int depth)
1280 {
1281         if (clnt == NULL)
1282                 return False;
1283
1284         prs_debug(ps, depth, desc, "smb_io_clnt_info");
1285         depth++;
1286
1287         if(!prs_align(ps))
1288                 return False;
1289
1290         if(!smb_io_log_info("", &clnt->login, ps, depth))
1291                 return False;
1292         if(!smb_io_cred("", &clnt->cred, ps, depth))
1293                 return False;
1294
1295         return True;
1296 }
1297
1298 /*******************************************************************
1299  Inits a DOM_LOGON_ID structure.
1300 ********************************************************************/
1301
1302 void init_logon_id(DOM_LOGON_ID *log, uint32 log_id_low, uint32 log_id_high)
1303 {
1304         DEBUG(5,("make_logon_id: %d\n", __LINE__));
1305
1306         log->low  = log_id_low;
1307         log->high = log_id_high;
1308 }
1309
1310 /*******************************************************************
1311  Reads or writes a DOM_LOGON_ID structure.
1312 ********************************************************************/
1313
1314 BOOL smb_io_logon_id(char *desc, DOM_LOGON_ID *log, prs_struct *ps, int depth)
1315 {
1316         if (log == NULL)
1317                 return False;
1318
1319         prs_debug(ps, depth, desc, "smb_io_logon_id");
1320         depth++;
1321
1322         if(!prs_align(ps))
1323                 return False;
1324
1325         if(!prs_uint32("low ", ps, depth, &log->low ))
1326                 return False;
1327         if(!prs_uint32("high", ps, depth, &log->high))
1328                 return False;
1329
1330         return True;
1331 }
1332
1333 /*******************************************************************
1334  Inits an OWF_INFO structure.
1335 ********************************************************************/
1336
1337 void init_owf_info(OWF_INFO *hash, uint8 data[16])
1338 {
1339         DEBUG(5,("init_owf_info: %d\n", __LINE__));
1340
1341         if (data != NULL)
1342                 memcpy(hash->data, data, sizeof(hash->data));
1343         else
1344                 memset((char *)hash->data, '\0', sizeof(hash->data));
1345 }
1346
1347 /*******************************************************************
1348  Reads or writes an OWF_INFO structure.
1349 ********************************************************************/
1350
1351 BOOL smb_io_owf_info(char *desc, OWF_INFO *hash, prs_struct *ps, int depth)
1352 {
1353         if (hash == NULL)
1354                 return False;
1355
1356         prs_debug(ps, depth, desc, "smb_io_owf_info");
1357         depth++;
1358
1359         if(!prs_align(ps))
1360                 return False;
1361
1362         if(!prs_uint8s (False, "data", ps, depth, hash->data, 16))
1363                 return False;
1364
1365         return True;
1366 }
1367
1368 /*******************************************************************
1369  Reads or writes a DOM_GID structure.
1370 ********************************************************************/
1371
1372 BOOL smb_io_gid(char *desc,  DOM_GID *gid, prs_struct *ps, int depth)
1373 {
1374         if (gid == NULL)
1375                 return False;
1376
1377         prs_debug(ps, depth, desc, "smb_io_gid");
1378         depth++;
1379
1380         if(!prs_align(ps))
1381                 return False;
1382
1383         if(!prs_uint32("g_rid", ps, depth, &gid->g_rid))
1384                 return False;
1385         if(!prs_uint32("attr ", ps, depth, &gid->attr))
1386                 return False;
1387
1388         return True;
1389 }
1390
1391 /*******************************************************************
1392  Reads or writes an POLICY_HND structure.
1393 ********************************************************************/
1394
1395 BOOL smb_io_pol_hnd(char *desc, POLICY_HND *pol, prs_struct *ps, int depth)
1396 {
1397         if (pol == NULL)
1398                 return False;
1399
1400         prs_debug(ps, depth, desc, "smb_io_pol_hnd");
1401         depth++;
1402
1403         if(!prs_align(ps))
1404                 return False;
1405
1406         if(!prs_uint8s (False, "data", ps, depth, pol->data, POL_HND_SIZE))
1407                 return False;
1408
1409         return True;
1410 }
1411
1412 /*******************************************************************
1413  Reads or writes a dom query structure.
1414 ********************************************************************/
1415
1416 static BOOL smb_io_dom_query(char *desc, DOM_QUERY *d_q, prs_struct *ps, int depth)
1417 {
1418         if (d_q == NULL)
1419                 return False;
1420
1421         prs_debug(ps, depth, desc, "smb_io_dom_query");
1422         depth++;
1423
1424         if(!prs_align(ps))
1425                 return False;
1426
1427         if(!prs_uint16("uni_dom_max_len", ps, depth, &d_q->uni_dom_max_len)) /* domain name string length * 2 */
1428                 return False;
1429         if(!prs_uint16("uni_dom_str_len", ps, depth, &d_q->uni_dom_str_len)) /* domain name string length * 2 */
1430                 return False;
1431
1432         if(!prs_uint32("buffer_dom_name", ps, depth, &d_q->buffer_dom_name)) /* undocumented domain name string buffer pointer */
1433                 return False;
1434         if(!prs_uint32("buffer_dom_sid ", ps, depth, &d_q->buffer_dom_sid)) /* undocumented domain SID string buffer pointer */
1435                 return False;
1436
1437         if(!smb_io_unistr2("unistr2", &d_q->uni_domain_name, d_q->buffer_dom_name, ps, depth)) /* domain name (unicode string) */
1438                 return False;
1439
1440         if(!prs_align(ps))
1441                 return False;
1442
1443         if (d_q->buffer_dom_sid != 0) {
1444                 if(!smb_io_dom_sid2("", &d_q->dom_sid, ps, depth)) /* domain SID */
1445                         return False;
1446         } else {
1447                 memset((char *)&d_q->dom_sid, '\0', sizeof(d_q->dom_sid));
1448         }
1449
1450         return True;
1451 }
1452
1453 /*******************************************************************
1454  Reads or writes a dom query structure.
1455 ********************************************************************/
1456
1457 BOOL smb_io_dom_query_3(char *desc, DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
1458 {
1459         return smb_io_dom_query("", d_q, ps, depth);
1460 }
1461
1462 /*******************************************************************
1463  Reads or writes a dom query structure.
1464 ********************************************************************/
1465
1466 BOOL smb_io_dom_query_5(char *desc, DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
1467 {
1468         return smb_io_dom_query("", d_q, ps, depth);
1469 }
1470
1471
1472 /*******************************************************************
1473  Reads or writes a UNISTR3 structure.
1474 ********************************************************************/
1475
1476 BOOL smb_io_unistr3(char *desc, UNISTR3 *name, prs_struct *ps, int depth)
1477 {
1478         if (name == NULL)
1479                 return False;
1480
1481         prs_debug(ps, depth, desc, "smb_io_unistr3");
1482         depth++;
1483
1484         if(!prs_align(ps))
1485                 return False;
1486
1487         if(!prs_uint32("uni_str_len", ps, depth, &name->uni_str_len))
1488                 return False;
1489
1490         /* don't know if len is specified by uni_str_len member... */
1491         /* assume unicode string is unicode-null-terminated, instead */
1492
1493         if(!prs_unistr3(True, "unistr", name, ps, depth))
1494                 return False;
1495
1496         return True;
1497 }
1498
1499
1500 /*******************************************************************
1501  Stream a uint64_struct
1502  ********************************************************************/
1503 BOOL prs_uint64(char *name, prs_struct *ps, int depth, UINT64_S *data64)
1504 {
1505         return prs_uint32(name, ps, depth+1, &data64->low) &&
1506                 prs_uint32(name, ps, depth+1, &data64->high);
1507 }
1508
1509