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