source3/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, const char *str_sid)
 248 {
 249         pstring domsid;
 250         int identauth;
 251         char *p;
 252
 253         if (str_sid == NULL) {
 254                 DEBUG(4,("netlogon domain SID: none\n"));
 255                 sid->sid_rev_num = 0;
 256                 sid->num_auths = 0;
 257                 return;
 258         }
 259
 260         pstrcpy(domsid, str_sid);
 261
 262         DEBUG(4,("init_dom_sid %d SID:  %s\n", __LINE__, domsid));
 263
 264         /* assume, but should check, that domsid starts "S-" */
 265         p = strtok(domsid+2,"-");
 266         sid->sid_rev_num = atoi(p);
 267
 268         /* identauth in decimal should be <  2^32 */
 269         /* identauth in hex     should be >= 2^32 */
 270         identauth = atoi(strtok(0,"-"));
 271
 272         DEBUG(4,("netlogon rev %d\n", sid->sid_rev_num));
 273         DEBUG(4,("netlogon %s ia %d\n", p, identauth));
 274
 275         sid->id_auth[0] = 0;
 276         sid->id_auth[1] = 0;
 277         sid->id_auth[2] = (identauth & 0xff000000) >> 24;
 278         sid->id_auth[3] = (identauth & 0x00ff0000) >> 16;
 279         sid->id_auth[4] = (identauth & 0x0000ff00) >> 8;
 280         sid->id_auth[5] = (identauth & 0x000000ff);
 281
 282         sid->num_auths = 0;
 283
 284         while ((p = strtok(0, "-")) != NULL && sid->num_auths < MAXSUBAUTHS)
 285                 sid->sub_auths[sid->num_auths++] = atoi(p);
 286
 287         DEBUG(4,("init_dom_sid: %d SID:  %s\n", __LINE__, domsid));
 288 }
 289
 290 /*******************************************************************
 291  Inits a DOM_SID2 structure.
 292 ********************************************************************/
 293
 294 void init_dom_sid2(DOM_SID2 *sid2, const DOM_SID *sid)
 295 {
 296         sid2->sid = *sid;
 297         sid2->num_auths = sid2->sid.num_auths;
 298 }
 299
 300 /*******************************************************************
 301  Reads or writes a DOM_SID2 structure.
 302 ********************************************************************/
 303
 304 BOOL smb_io_dom_sid2(char *desc, DOM_SID2 *sid, prs_struct *ps, int depth)
 305 {
 306         if (sid == NULL)
 307                 return False;
 308
 309         prs_debug(ps, depth, desc, "smb_io_dom_sid2");
 310         depth++;
 311
 312         if(!prs_align(ps))
 313                 return False;
 314
 315         if(!prs_uint32("num_auths", ps, depth, &sid->num_auths))
 316                 return False;
 317
 318         if(!smb_io_dom_sid("sid", &sid->sid, ps, depth))
 319                 return False;
 320
 321         return True;
 322 }
 323
 324 /*******************************************************************
 325 creates a STRHDR structure.
 326 ********************************************************************/
 327
 328 void init_str_hdr(STRHDR *hdr, int max_len, int len, uint32 buffer)
 329 {
 330         hdr->str_max_len = max_len;
 331         hdr->str_str_len = len;
 332         hdr->buffer      = buffer;
 333 }
 334
 335 /*******************************************************************
 336  Reads or writes a STRHDR structure.
 337 ********************************************************************/
 338
 339 BOOL smb_io_strhdr(char *desc,  STRHDR *hdr, prs_struct *ps, int depth)
 340 {
 341         if (hdr == NULL)
 342                 return False;
 343
 344         prs_debug(ps, depth, desc, "smb_io_strhdr");
 345         depth++;
 346
 347         prs_align(ps);
 348
 349         if(!prs_uint16("str_str_len", ps, depth, &hdr->str_str_len))
 350                 return False;
 351         if(!prs_uint16("str_max_len", ps, depth, &hdr->str_max_len))
 352                 return False;
 353         if(!prs_uint32("buffer     ", ps, depth, &hdr->buffer))
 354                 return False;
 355
 356         return True;
 357 }
 358
 359 /*******************************************************************
 360  Inits a UNIHDR structure.
 361 ********************************************************************/
 362
 363 void init_uni_hdr(UNIHDR *hdr, int len)
 364 {
 365         hdr->uni_str_len = 2 * len;
 366         hdr->uni_max_len = 2 * len;
 367         hdr->buffer      = len != 0 ? 1 : 0;
 368 }
 369
 370 /*******************************************************************
 371  Reads or writes a UNIHDR structure.
 372 ********************************************************************/
 373
 374 BOOL smb_io_unihdr(char *desc, UNIHDR *hdr, prs_struct *ps, int depth)
 375 {
 376         if (hdr == NULL)
 377                 return False;
 378
 379         prs_debug(ps, depth, desc, "smb_io_unihdr");
 380         depth++;
 381
 382         if(!prs_align(ps))
 383                 return False;
 384
 385         if(!prs_uint16("uni_str_len", ps, depth, &hdr->uni_str_len))
 386                 return False;
 387         if(!prs_uint16("uni_max_len", ps, depth, &hdr->uni_max_len))
 388                 return False;
 389         if(!prs_uint32("buffer     ", ps, depth, &hdr->buffer))
 390                 return False;
 391
 392         return True;
 393 }
 394
 395 /*******************************************************************
 396  Inits a BUFHDR structure.
 397 ********************************************************************/
 398
 399 void init_buf_hdr(BUFHDR *hdr, int max_len, int len)
 400 {
 401         hdr->buf_max_len = max_len;
 402         hdr->buf_len     = len;
 403 }
 404
 405 /*******************************************************************
 406  prs_uint16 wrapper. Call this and it sets up a pointer to where the
 407  uint16 should be stored, or gets the size if reading.
 408  ********************************************************************/
 409
 410 BOOL smb_io_hdrbuf_pre(char *desc, BUFHDR *hdr, prs_struct *ps, int depth, uint32 *offset)
 411 {
 412         (*offset) = prs_offset(ps);
 413         if (ps->io) {
 414
 415                 /* reading. */
 416
 417                 if(!smb_io_hdrbuf(desc, hdr, ps, depth))
 418                         return False;
 419
 420         } else {
 421
 422                 /* writing. */
 423
 424                 if(!prs_set_offset(ps, prs_offset(ps) + (sizeof(uint32) * 2)))
 425                         return False;
 426         }
 427
 428         return True;
 429 }
 430
 431 /*******************************************************************
 432  smb_io_hdrbuf wrapper. Call this and it retrospectively stores the size.
 433  Does nothing on reading, as that is already handled by ...._pre()
 434  ********************************************************************/
 435
 436 BOOL smb_io_hdrbuf_post(char *desc, BUFHDR *hdr, prs_struct *ps, int depth,
 437                                 uint32 ptr_hdrbuf, uint32 max_len, uint32 len)
 438 {
 439         if (!ps->io) {
 440                 /* writing: go back and do a retrospective job.  i hate this */
 441
 442                 uint32 old_offset = prs_offset(ps);
 443
 444                 init_buf_hdr(hdr, max_len, len);
 445                 if(!prs_set_offset(ps, ptr_hdrbuf))
 446                         return False;
 447                 if(!smb_io_hdrbuf(desc, hdr, ps, depth))
 448                         return False;
 449
 450                 if(!prs_set_offset(ps, old_offset))
 451                         return False;
 452         }
 453
 454         return True;
 455 }
 456
 457 /*******************************************************************
 458  Reads or writes a BUFHDR structure.
 459 ********************************************************************/
 460
 461 BOOL smb_io_hdrbuf(char *desc, BUFHDR *hdr, prs_struct *ps, int depth)
 462 {
 463         if (hdr == NULL)
 464                 return False;
 465
 466         prs_debug(ps, depth, desc, "smb_io_hdrbuf");
 467         depth++;
 468
 469         if(!prs_align(ps))
 470                 return False;
 471
 472         if(!prs_uint32("buf_max_len", ps, depth, &hdr->buf_max_len))
 473                 return False;
 474         if(!prs_uint32("buf_len    ", ps, depth, &hdr->buf_len))
 475                 return False;
 476
 477         return True;
 478 }
 479
 480 /*******************************************************************
 481 creates a UNIHDR2 structure.
 482 ********************************************************************/
 483
 484 void init_uni_hdr2(UNIHDR2 *hdr, int len)
 485 {
 486         init_uni_hdr(&hdr->unihdr, len);
 487         hdr->buffer = (len > 0) ? 1 : 0;
 488 }
 489
 490 /*******************************************************************
 491  Reads or writes a UNIHDR2 structure.
 492 ********************************************************************/
 493
 494 BOOL smb_io_unihdr2(char *desc, UNIHDR2 *hdr2, prs_struct *ps, int depth)
 495 {
 496         if (hdr2 == NULL)
 497                 return False;
 498
 499         prs_debug(ps, depth, desc, "smb_io_unihdr2");
 500         depth++;
 501
 502         if(!prs_align(ps))
 503                 return False;
 504
 505         if(!smb_io_unihdr("hdr", &hdr2->unihdr, ps, depth))
 506                 return False;
 507         if(!prs_uint32("buffer", ps, depth, &hdr2->buffer))
 508                 return False;
 509
 510         return True;
 511 }
 512
 513 /*******************************************************************
 514  Inits a UNISTR structure.
 515 ********************************************************************/
 516
 517 void init_unistr(UNISTR *str, const char *buf)
 518 {
 519         size_t len;
 520
 521         if (buf == NULL) {
 522                 str->buffer = NULL;
 523                 return;
 524         }
 525
 526
 527         len = strlen(buf) + 1;
 528
 529         if (len < MAX_UNISTRLEN)
 530                 len = MAX_UNISTRLEN;
 531         len *= sizeof(uint16);
 532
 533         str->buffer = (uint16 *)talloc_zero(get_talloc_ctx(), len);
 534         if (str->buffer == NULL)
 535                 smb_panic("init_unistr: malloc fail\n");
 536
 537         rpcstr_push(str->buffer, buf, len, STR_TERMINATE);
 538 }
 539
 540 /*******************************************************************
 541 reads or writes a UNISTR structure.
 542 XXXX NOTE: UNISTR structures NEED to be null-terminated.
 543 ********************************************************************/
 544
 545 BOOL smb_io_unistr(char *desc, UNISTR *uni, prs_struct *ps, int depth)
 546 {
 547         if (uni == NULL)
 548                 return False;
 549
 550         prs_debug(ps, depth, desc, "smb_io_unistr");
 551         depth++;
 552
 553         if(!prs_unistr("unistr", ps, depth, uni))
 554                 return False;
 555
 556         return True;
 557 }
 558
 559 /*******************************************************************
 560  Allocate the BUFFER3 memory.
 561 ********************************************************************/
 562
 563 static void create_buffer3(BUFFER3 *str, size_t len)
 564 {
 565         if (len < MAX_BUFFERLEN)
 566                 len = MAX_BUFFERLEN;
 567
 568     str->buffer = talloc_zero(get_talloc_ctx(), len);
 569         if (str->buffer == NULL)
 570                 smb_panic("create_buffer3: talloc fail\n");
 571
 572 }
 573
 574 /*******************************************************************
 575  Inits a BUFFER3 structure from a uint32
 576 ********************************************************************/
 577
 578 void init_buffer3_uint32(BUFFER3 *str, uint32 val)
 579 {
 580         ZERO_STRUCTP(str);
 581
 582         /* set up string lengths. */
 583         str->buf_max_len = sizeof(uint32);
 584         str->buf_len     = sizeof(uint32);
 585
 586         create_buffer3(str, sizeof(uint32));
 587         SIVAL(str->buffer, 0, val);
 588 }
 589
 590 /*******************************************************************
 591  Inits a BUFFER3 structure.
 592 ********************************************************************/
 593
 594 void init_buffer3_str(BUFFER3 *str, const char *buf, int len)
 595 {
 596         ZERO_STRUCTP(str);
 597
 598         /* set up string lengths. */
 599         str->buf_max_len = len * 2;
 600         str->buf_len = len * 2;
 601
 602         create_buffer3(str, str->buf_max_len);
 603
 604         rpcstr_push(str->buffer, buf, str->buf_max_len, STR_TERMINATE);
 605
 606 }
 607
 608 /*******************************************************************
 609  Inits a BUFFER3 structure from a hex string.
 610 ********************************************************************/
 611
 612 void init_buffer3_hex(BUFFER3 *str, const char *buf)
 613 {
 614         ZERO_STRUCTP(str);
 615         create_buffer3(str, strlen(buf));
 616         str->buf_max_len = str->buf_len = strhex_to_str((char *)str->buffer, sizeof(str->buffer), buf);
 617 }
 618
 619 /*******************************************************************
 620  Inits a BUFFER3 structure.
 621 ********************************************************************/
 622
 623 void init_buffer3_bytes(BUFFER3 *str, uint8 *buf, int len)
 624 {
 625         ZERO_STRUCTP(str);
 626
 627         /* max buffer size (allocated size) */
 628         str->buf_max_len = len;
 629         if (buf != NULL) {
 630                 create_buffer3(str, len);
 631                 memcpy(str->buffer, buf, len);
 632         }
 633         str->buf_len = buf != NULL ? len : 0;
 634 }
 635
 636 /*******************************************************************
 637  Reads or writes a BUFFER3 structure.
 638    the uni_max_len member tells you how large the buffer is.
 639    the uni_str_len member tells you how much of the buffer is really used.
 640 ********************************************************************/
 641
 642 BOOL smb_io_buffer3(char *desc, BUFFER3 *buf3, prs_struct *ps, int depth)
 643 {
 644         if (buf3 == NULL)
 645                 return False;
 646
 647         prs_debug(ps, depth, desc, "smb_io_buffer3");
 648         depth++;
 649
 650         if(!prs_align(ps))
 651                 return False;
 652
 653         if(!prs_uint32("uni_max_len", ps, depth, &buf3->buf_max_len))
 654                 return False;
 655
 656         if (UNMARSHALLING(ps)) {
 657                 buf3->buffer = (unsigned char *)prs_alloc_mem(ps, buf3->buf_max_len);
 658                 if (buf3->buffer == NULL)
 659                         return False;
 660         }
 661
 662         if(!prs_uint8s(True, "buffer     ", ps, depth, buf3->buffer, buf3->buf_max_len))
 663                 return False;
 664
 665         if(!prs_uint32("buf_len    ", ps, depth, &buf3->buf_len))
 666                 return False;
 667
 668         return True;
 669 }
 670
 671 /*******************************************************************
 672 reads or writes a BUFFER5 structure.
 673 the buf_len member tells you how large the buffer is.
 674 ********************************************************************/
 675 BOOL smb_io_buffer5(char *desc, BUFFER5 *buf5, prs_struct *ps, int depth)
 676 {
 677         prs_debug(ps, depth, desc, "smb_io_buffer5");
 678         depth++;
 679
 680         if (buf5 == NULL) return False;
 681
 682         if(!prs_align(ps))
 683                 return False;
 684         if(!prs_uint32("buf_len", ps, depth, &buf5->buf_len))
 685                 return False;
 686
 687         if(buf5->buf_len) {
 688                 if(!prs_buffer5(True, "buffer" , ps, depth, buf5))
 689                         return False;
 690         }
 691
 692         return True;
 693 }
 694
 695 /*******************************************************************
 696  Inits a BUFFER2 structure.
 697 ********************************************************************/
 698
 699 void init_buffer2(BUFFER2 *str, const 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, const 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, const char *logon_srv, const 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_uint8s (False, "data", ps, depth, chal->data, 8))
1260                 return False;
1261
1262         return True;
1263 }
1264
1265 /*******************************************************************
1266  Reads or writes a DOM_CRED structure.
1267 ********************************************************************/
1268
1269 BOOL smb_io_cred(char *desc,  DOM_CRED *cred, prs_struct *ps, int depth)
1270 {
1271         if (cred == NULL)
1272                 return False;
1273
1274         prs_debug(ps, depth, desc, "smb_io_cred");
1275         depth++;
1276
1277         if(!prs_align(ps))
1278                 return False;
1279
1280         if(!smb_io_chal ("", &cred->challenge, ps, depth))
1281                 return False;
1282
1283         if(!smb_io_utime("", &cred->timestamp, ps, depth))
1284                 return False;
1285
1286         return True;
1287 }
1288
1289 /*******************************************************************
1290  Inits a DOM_CLNT_INFO2 structure.
1291 ********************************************************************/
1292
1293 void init_clnt_info2(DOM_CLNT_INFO2 *clnt,
1294                                 const char *logon_srv, const char *comp_name,
1295                                 const DOM_CRED *clnt_cred)
1296 {
1297         DEBUG(5,("make_clnt_info: %d\n", __LINE__));
1298
1299         init_clnt_srv(&clnt->login, logon_srv, comp_name);
1300
1301         if (clnt_cred != NULL) {
1302                 clnt->ptr_cred = 1;
1303                 memcpy(&clnt->cred, clnt_cred, sizeof(clnt->cred));
1304         } else {
1305                 clnt->ptr_cred = 0;
1306         }
1307 }
1308
1309 /*******************************************************************
1310  Reads or writes a DOM_CLNT_INFO2 structure.
1311 ********************************************************************/
1312
1313 BOOL smb_io_clnt_info2(char *desc, DOM_CLNT_INFO2 *clnt, prs_struct *ps, int depth)
1314 {
1315         if (clnt == NULL)
1316                 return False;
1317
1318         prs_debug(ps, depth, desc, "smb_io_clnt_info2");
1319         depth++;
1320
1321         if(!prs_align(ps))
1322                 return False;
1323
1324         if(!smb_io_clnt_srv("", &clnt->login, ps, depth))
1325                 return False;
1326
1327         if(!prs_align(ps))
1328                 return False;
1329
1330         if(!prs_uint32("ptr_cred", ps, depth, &clnt->ptr_cred))
1331                 return False;
1332         if(!smb_io_cred("", &clnt->cred, ps, depth))
1333                 return False;
1334
1335         return True;
1336 }
1337
1338 /*******************************************************************
1339  Inits a DOM_CLNT_INFO structure.
1340 ********************************************************************/
1341
1342 void init_clnt_info(DOM_CLNT_INFO *clnt,
1343                 const char *logon_srv, const char *acct_name,
1344                 uint16 sec_chan, const char *comp_name,
1345                 const DOM_CRED *cred)
1346 {
1347         DEBUG(5,("make_clnt_info\n"));
1348
1349         init_log_info(&clnt->login, logon_srv, acct_name, sec_chan, comp_name);
1350         memcpy(&clnt->cred, cred, sizeof(clnt->cred));
1351 }
1352
1353 /*******************************************************************
1354  Reads or writes a DOM_CLNT_INFO structure.
1355 ********************************************************************/
1356
1357 BOOL smb_io_clnt_info(char *desc,  DOM_CLNT_INFO *clnt, prs_struct *ps, int depth)
1358 {
1359         if (clnt == NULL)
1360                 return False;
1361
1362         prs_debug(ps, depth, desc, "smb_io_clnt_info");
1363         depth++;
1364
1365         if(!prs_align(ps))
1366                 return False;
1367
1368         if(!smb_io_log_info("", &clnt->login, ps, depth))
1369                 return False;
1370         if(!smb_io_cred("", &clnt->cred, ps, depth))
1371                 return False;
1372
1373         return True;
1374 }
1375
1376 /*******************************************************************
1377  Inits a DOM_LOGON_ID structure.
1378 ********************************************************************/
1379
1380 void init_logon_id(DOM_LOGON_ID *log, uint32 log_id_low, uint32 log_id_high)
1381 {
1382         DEBUG(5,("make_logon_id: %d\n", __LINE__));
1383
1384         log->low  = log_id_low;
1385         log->high = log_id_high;
1386 }
1387
1388 /*******************************************************************
1389  Reads or writes a DOM_LOGON_ID structure.
1390 ********************************************************************/
1391
1392 BOOL smb_io_logon_id(char *desc, DOM_LOGON_ID *log, prs_struct *ps, int depth)
1393 {
1394         if (log == NULL)
1395                 return False;
1396
1397         prs_debug(ps, depth, desc, "smb_io_logon_id");
1398         depth++;
1399
1400         if(!prs_align(ps))
1401                 return False;
1402
1403         if(!prs_uint32("low ", ps, depth, &log->low ))
1404                 return False;
1405         if(!prs_uint32("high", ps, depth, &log->high))
1406                 return False;
1407
1408         return True;
1409 }
1410
1411 /*******************************************************************
1412  Inits an OWF_INFO structure.
1413 ********************************************************************/
1414
1415 void init_owf_info(OWF_INFO *hash, const uint8 data[16])
1416 {
1417         DEBUG(5,("init_owf_info: %d\n", __LINE__));
1418
1419         if (data != NULL)
1420                 memcpy(hash->data, data, sizeof(hash->data));
1421         else
1422                 memset((char *)hash->data, '\0', sizeof(hash->data));
1423 }
1424
1425 /*******************************************************************
1426  Reads or writes an OWF_INFO structure.
1427 ********************************************************************/
1428
1429 BOOL smb_io_owf_info(char *desc, OWF_INFO *hash, prs_struct *ps, int depth)
1430 {
1431         if (hash == NULL)
1432                 return False;
1433
1434         prs_debug(ps, depth, desc, "smb_io_owf_info");
1435         depth++;
1436
1437         if(!prs_align(ps))
1438                 return False;
1439
1440         if(!prs_uint8s (False, "data", ps, depth, hash->data, 16))
1441                 return False;
1442
1443         return True;
1444 }
1445
1446 /*******************************************************************
1447  Reads or writes a DOM_GID structure.
1448 ********************************************************************/
1449
1450 BOOL smb_io_gid(char *desc,  DOM_GID *gid, prs_struct *ps, int depth)
1451 {
1452         if (gid == NULL)
1453                 return False;
1454
1455         prs_debug(ps, depth, desc, "smb_io_gid");
1456         depth++;
1457
1458         if(!prs_align(ps))
1459                 return False;
1460
1461         if(!prs_uint32("g_rid", ps, depth, &gid->g_rid))
1462                 return False;
1463         if(!prs_uint32("attr ", ps, depth, &gid->attr))
1464                 return False;
1465
1466         return True;
1467 }
1468
1469 /*******************************************************************
1470  Reads or writes an POLICY_HND structure.
1471 ********************************************************************/
1472
1473 BOOL smb_io_pol_hnd(char *desc, POLICY_HND *pol, prs_struct *ps, int depth)
1474 {
1475         if (pol == NULL)
1476                 return False;
1477
1478         prs_debug(ps, depth, desc, "smb_io_pol_hnd");
1479         depth++;
1480
1481         if(!prs_align(ps))
1482                 return False;
1483
1484         if(UNMARSHALLING(ps))
1485                 ZERO_STRUCTP(pol);
1486
1487         if (!prs_uint32("data1", ps, depth, &pol->data1))
1488                 return False;
1489         if (!prs_uint32("data2", ps, depth, &pol->data2))
1490                 return False;
1491         if (!prs_uint16("data3", ps, depth, &pol->data3))
1492                 return False;
1493         if (!prs_uint16("data4", ps, depth, &pol->data4))
1494                 return False;
1495         if(!prs_uint8s (False, "data5", ps, depth, pol->data5, sizeof(pol->data5)))
1496                 return False;
1497
1498         return True;
1499 }
1500
1501 /*******************************************************************
1502  Create a UNISTR3.
1503 ********************************************************************/
1504
1505 void init_unistr3(UNISTR3 *str, const char *buf)
1506 {
1507         size_t len;
1508
1509         if (buf == NULL) {
1510                 str->uni_str_len=0;
1511                 str->str.buffer = NULL;
1512                 return;
1513         }
1514
1515         len = strlen(buf) + 1;
1516
1517         str->uni_str_len=len;
1518
1519         if (len < MAX_UNISTRLEN)
1520                 len = MAX_UNISTRLEN;
1521
1522         len *= sizeof(uint16);
1523
1524         str->str.buffer = (uint16 *)talloc_zero(get_talloc_ctx(), len);
1525         if (str->str.buffer == NULL)
1526                 smb_panic("init_unistr3: malloc fail\n");
1527
1528         rpcstr_push((char *)str->str.buffer, buf, len, STR_TERMINATE);
1529 }
1530
1531 /*******************************************************************
1532  Reads or writes a UNISTR3 structure.
1533 ********************************************************************/
1534
1535 BOOL smb_io_unistr3(char *desc, UNISTR3 *name, prs_struct *ps, int depth)
1536 {
1537         if (name == NULL)
1538                 return False;
1539
1540         prs_debug(ps, depth, desc, "smb_io_unistr3");
1541         depth++;
1542
1543         if(!prs_align(ps))
1544                 return False;
1545
1546         if(!prs_uint32("uni_str_len", ps, depth, &name->uni_str_len))
1547                 return False;
1548
1549         /* don't know if len is specified by uni_str_len member... */
1550         /* assume unicode string is unicode-null-terminated, instead */
1551
1552         if(!prs_unistr3(True, "unistr", name, ps, depth))
1553                 return False;
1554
1555         return True;
1556 }
1557
1558
1559 /*******************************************************************
1560  Stream a uint64_struct
1561  ********************************************************************/
1562 BOOL prs_uint64(char *name, prs_struct *ps, int depth, UINT64_S *data64)
1563 {
1564         return prs_uint32(name, ps, depth+1, &data64->low) &&
1565                 prs_uint32(name, ps, depth+1, &data64->high);
1566 }
1567
1568 /*******************************************************************
1569 reads or writes a BUFHDR2 structure.
1570 ********************************************************************/
1571 BOOL smb_io_bufhdr2(char *desc, BUFHDR2 *hdr, prs_struct *ps, int depth)
1572 {
1573         prs_debug(ps, depth, desc, "smb_io_bufhdr2");
1574         depth++;
1575
1576         prs_align(ps);
1577         prs_uint32("info_level", ps, depth, &(hdr->info_level));
1578         prs_uint32("length    ", ps, depth, &(hdr->length    ));
1579         prs_uint32("buffer    ", ps, depth, &(hdr->buffer    ));
1580
1581         return True;
1582 }
1583
1584 /*******************************************************************
1585 reads or writes a BUFFER4 structure.
1586 ********************************************************************/
1587 BOOL smb_io_buffer4(char *desc, BUFFER4 *buf4, uint32 buffer, prs_struct *ps, int depth)
1588 {
1589         prs_debug(ps, depth, desc, "smb_io_buffer4");
1590         depth++;
1591
1592         prs_align(ps);
1593         prs_uint32("buf_len", ps, depth, &(buf4->buf_len));
1594
1595         if (buf4->buf_len > MAX_BUFFERLEN)
1596         {
1597                 buf4->buf_len = MAX_BUFFERLEN;
1598         }
1599
1600         prs_uint8s(True, "buffer", ps, depth, buf4->buffer, buf4->buf_len);
1601
1602         return True;
1603 }
1604
1605 /*******************************************************************
1606 creates a UNIHDR structure.
1607 ********************************************************************/
1608
1609 BOOL make_uni_hdr(UNIHDR *hdr, int len)
1610 {
1611         if (hdr == NULL)
1612         {
1613                 return False;
1614         }
1615         hdr->uni_str_len = 2 * len;
1616         hdr->uni_max_len = 2 * len;
1617         hdr->buffer      = len != 0 ? 1 : 0;
1618
1619         return True;
1620 }
1621
1622 /*******************************************************************
1623 creates a BUFHDR2 structure.
1624 ********************************************************************/
1625 BOOL make_bufhdr2(BUFHDR2 *hdr, uint32 info_level, uint32 length, uint32 buffer)
1626 {
1627         hdr->info_level = info_level;
1628         hdr->length     = length;
1629         hdr->buffer     = buffer;
1630
1631         return True;
1632 }