source/rpc_parse/parse_misc.c

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