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  *  Copyright (C) Gerald (Jerry) Carter             2005
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include "includes.h"
  25
  26 #undef DBGC_CLASS
  27 #define DBGC_CLASS DBGC_RPC_PARSE
  28
  29 /****************************************************************************
  30  A temporary TALLOC context for things like unistrs, that is valid for
  31  the life of a complete RPC call.
  32 ****************************************************************************/
  33
  34 static TALLOC_CTX *current_rpc_talloc = NULL;
  35
  36 static TALLOC_CTX *get_current_rpc_talloc(void)
  37 {
  38     return current_rpc_talloc;
  39 }
  40
  41 void set_current_rpc_talloc( TALLOC_CTX *ctx)
  42 {
  43         current_rpc_talloc = ctx;
  44 }
  45
  46 static TALLOC_CTX *main_loop_talloc = NULL;
  47
  48 /*******************************************************************
  49 free up temporary memory - called from the main loop
  50 ********************************************************************/
  51
  52 void main_loop_TALLOC_FREE(void)
  53 {
  54     if (!main_loop_talloc)
  55         return;
  56     talloc_destroy(main_loop_talloc);
  57     main_loop_talloc = NULL;
  58 }
  59
  60 /*******************************************************************
  61  Get a talloc context that is freed in the main loop...
  62 ********************************************************************/
  63
  64 TALLOC_CTX *main_loop_talloc_get(void)
  65 {
  66     if (!main_loop_talloc) {
  67         main_loop_talloc = talloc_init("main loop talloc (mainly parse_misc)");
  68         if (!main_loop_talloc)
  69             smb_panic("main_loop_talloc: malloc fail\n");
  70     }
  71
  72     return main_loop_talloc;
  73 }
  74
  75 /*******************************************************************
  76  Try and get a talloc context. Get the rpc one if possible, else
  77  get the main loop one. The main loop one is more dangerous as it
  78  goes away between packets, the rpc one will stay around for as long
  79  as a current RPC lasts.
  80 ********************************************************************/
  81
  82 TALLOC_CTX *get_talloc_ctx(void)
  83 {
  84         TALLOC_CTX *tc = get_current_rpc_talloc();
  85
  86         if (tc)
  87                 return tc;
  88         return main_loop_talloc_get();
  89 }
  90
  91 /*******************************************************************
  92  Reads or writes a UTIME type.
  93 ********************************************************************/
  94
  95 static BOOL smb_io_utime(const char *desc, UTIME *t, prs_struct *ps, int depth)
  96 {
  97         if (t == NULL)
  98                 return False;
  99
 100         prs_debug(ps, depth, desc, "smb_io_utime");
 101         depth++;
 102
 103         if(!prs_align(ps))
 104                 return False;
 105
 106         if(!prs_uint32 ("time", ps, depth, &t->time))
 107                 return False;
 108
 109         return True;
 110 }
 111
 112 /*******************************************************************
 113  Reads or writes an NTTIME structure.
 114 ********************************************************************/
 115
 116 BOOL smb_io_time(const char *desc, NTTIME *nttime, prs_struct *ps, int depth)
 117 {
 118         uint32 low, high;
 119         if (nttime == NULL)
 120                 return False;
 121
 122         prs_debug(ps, depth, desc, "smb_io_time");
 123         depth++;
 124
 125         if(!prs_align(ps))
 126                 return False;
 127
 128         if (MARSHALLING(ps)) {
 129                 low = *nttime & 0xFFFFFFFF;
 130                 high = *nttime >> 32;
 131         }
 132
 133         if(!prs_uint32("low ", ps, depth, &low)) /* low part */
 134                 return False;
 135         if(!prs_uint32("high", ps, depth, &high)) /* high part */
 136                 return False;
 137
 138         if (UNMARSHALLING(ps)) {
 139                 *nttime = (((uint64_t)high << 32) + low);
 140         }
 141
 142         return True;
 143 }
 144
 145 /*******************************************************************
 146  Reads or writes an NTTIME structure.
 147 ********************************************************************/
 148
 149 BOOL smb_io_nttime(const char *desc, prs_struct *ps, int depth, NTTIME *nttime)
 150 {
 151         return smb_io_time( desc, nttime, ps, depth );
 152 }
 153
 154 /*******************************************************************
 155  Gets an enumeration handle from an ENUM_HND structure.
 156 ********************************************************************/
 157
 158 uint32 get_enum_hnd(ENUM_HND *enh)
 159 {
 160         return (enh && enh->ptr_hnd != 0) ? enh->handle : 0;
 161 }
 162
 163 /*******************************************************************
 164  Inits an ENUM_HND structure.
 165 ********************************************************************/
 166
 167 void init_enum_hnd(ENUM_HND *enh, uint32 hnd)
 168 {
 169         DEBUG(5,("smb_io_enum_hnd\n"));
 170
 171         enh->ptr_hnd = (hnd != 0) ? 1 : 0;
 172         enh->handle = hnd;
 173 }
 174
 175 /*******************************************************************
 176  Reads or writes an ENUM_HND structure.
 177 ********************************************************************/
 178
 179 BOOL smb_io_enum_hnd(const char *desc, ENUM_HND *hnd, prs_struct *ps, int depth)
 180 {
 181         if (hnd == NULL)
 182                 return False;
 183
 184         prs_debug(ps, depth, desc, "smb_io_enum_hnd");
 185         depth++;
 186
 187         if(!prs_align(ps))
 188                 return False;
 189
 190         if(!prs_uint32("ptr_hnd", ps, depth, &hnd->ptr_hnd)) /* pointer */
 191                 return False;
 192
 193         if (hnd->ptr_hnd != 0) {
 194                 if(!prs_uint32("handle ", ps, depth, &hnd->handle )) /* enum handle */
 195                         return False;
 196         }
 197
 198         return True;
 199 }
 200
 201 /*******************************************************************
 202  Reads or writes a DOM_SID structure.
 203 ********************************************************************/
 204
 205 BOOL smb_io_dom_sid(const char *desc, DOM_SID *sid, prs_struct *ps, int depth)
 206 {
 207         int i;
 208
 209         if (sid == NULL)
 210                 return False;
 211
 212         prs_debug(ps, depth, desc, "smb_io_dom_sid");
 213         depth++;
 214
 215         if(!prs_uint8 ("sid_rev_num", ps, depth, &sid->sid_rev_num))
 216                 return False;
 217
 218         if(!prs_uint8 ("num_auths  ", ps, depth, &sid->num_auths))
 219                 return False;
 220
 221         for (i = 0; i < 6; i++)
 222         {
 223                 fstring tmp;
 224                 slprintf(tmp, sizeof(tmp) - 1, "id_auth[%d] ", i);
 225                 if(!prs_uint8 (tmp, ps, depth, &sid->id_auth[i]))
 226                         return False;
 227         }
 228
 229         /* oops! XXXX should really issue a warning here... */
 230         if (sid->num_auths > MAXSUBAUTHS)
 231                 sid->num_auths = MAXSUBAUTHS;
 232
 233         if(!prs_uint32s(False, "sub_auths ", ps, depth, sid->sub_auths, sid->num_auths))
 234                 return False;
 235
 236         return True;
 237 }
 238
 239 /*******************************************************************
 240  Inits a DOM_SID2 structure.
 241 ********************************************************************/
 242
 243 void init_dom_sid2(DOM_SID2 *sid2, const DOM_SID *sid)
 244 {
 245         sid2->sid = *sid;
 246         sid2->num_auths = sid2->sid.num_auths;
 247 }
 248
 249 /*******************************************************************
 250  Reads or writes a DOM_SID2 structure.
 251 ********************************************************************/
 252
 253 BOOL smb_io_dom_sid2_p(const char *desc, prs_struct *ps, int depth, DOM_SID2 **sid2)
 254 {
 255         uint32 data_p;
 256
 257         /* caputure the pointer value to stream */
 258
 259         data_p = *sid2 ? 0xf000baaa : 0;
 260
 261         if ( !prs_uint32("dom_sid2_p", ps, depth, &data_p ))
 262                 return False;
 263
 264         /* we're done if there is no data */
 265
 266         if ( !data_p )
 267                 return True;
 268
 269         if (UNMARSHALLING(ps)) {
 270                 if ( !(*sid2 = PRS_ALLOC_MEM(ps, DOM_SID2, 1)) )
 271                         return False;
 272         }
 273
 274         return True;
 275 }
 276 /*******************************************************************
 277  Reads or writes a DOM_SID2 structure.
 278 ********************************************************************/
 279
 280 BOOL smb_io_dom_sid2(const char *desc, DOM_SID2 *sid, prs_struct *ps, int depth)
 281 {
 282         if (sid == NULL)
 283                 return False;
 284
 285         prs_debug(ps, depth, desc, "smb_io_dom_sid2");
 286         depth++;
 287
 288         if(!prs_align(ps))
 289                 return False;
 290
 291         if(!prs_uint32("num_auths", ps, depth, &sid->num_auths))
 292                 return False;
 293
 294         if(!smb_io_dom_sid("sid", &sid->sid, ps, depth))
 295                 return False;
 296
 297         return True;
 298 }
 299
 300 /*******************************************************************
 301  Reads or writes a struct GUID
 302 ********************************************************************/
 303
 304 BOOL smb_io_uuid(const char *desc, struct GUID *uuid,
 305                  prs_struct *ps, int depth)
 306 {
 307         if (uuid == NULL)
 308                 return False;
 309
 310         prs_debug(ps, depth, desc, "smb_io_uuid");
 311         depth++;
 312
 313         if(!prs_uint32 ("data   ", ps, depth, &uuid->time_low))
 314                 return False;
 315         if(!prs_uint16 ("data   ", ps, depth, &uuid->time_mid))
 316                 return False;
 317         if(!prs_uint16 ("data   ", ps, depth, &uuid->time_hi_and_version))
 318                 return False;
 319
 320         if(!prs_uint8s (False, "data   ", ps, depth, uuid->clock_seq, sizeof(uuid->clock_seq)))
 321                 return False;
 322         if(!prs_uint8s (False, "data   ", ps, depth, uuid->node, sizeof(uuid->node)))
 323                 return False;
 324
 325         return True;
 326 }
 327
 328 /*******************************************************************
 329 creates a STRHDR structure.
 330 ********************************************************************/
 331
 332 void init_str_hdr(STRHDR *hdr, int max_len, int len, uint32 buffer)
 333 {
 334         hdr->str_max_len = max_len;
 335         hdr->str_str_len = len;
 336         hdr->buffer      = buffer;
 337 }
 338
 339 /*******************************************************************
 340  Reads or writes a STRHDR structure.
 341 ********************************************************************/
 342
 343 BOOL smb_io_strhdr(const char *desc,  STRHDR *hdr, prs_struct *ps, int depth)
 344 {
 345         if (hdr == NULL)
 346                 return False;
 347
 348         prs_debug(ps, depth, desc, "smb_io_strhdr");
 349         depth++;
 350
 351         prs_align(ps);
 352
 353         if(!prs_uint16("str_str_len", ps, depth, &hdr->str_str_len))
 354                 return False;
 355         if(!prs_uint16("str_max_len", ps, depth, &hdr->str_max_len))
 356                 return False;
 357         if(!prs_uint32("buffer     ", ps, depth, &hdr->buffer))
 358                 return False;
 359
 360         return True;
 361 }
 362
 363 /*******************************************************************
 364  Inits a UNIHDR structure.
 365 ********************************************************************/
 366
 367 void init_uni_hdr(UNIHDR *hdr, UNISTR2 *str2)
 368 {
 369         hdr->uni_str_len = 2 * (str2->uni_str_len);
 370         hdr->uni_max_len = 2 * (str2->uni_max_len);
 371         hdr->buffer = (str2->uni_str_len != 0) ? 1 : 0;
 372 }
 373
 374 /*******************************************************************
 375  Reads or writes a UNIHDR structure.
 376 ********************************************************************/
 377
 378 BOOL smb_io_unihdr(const char *desc, UNIHDR *hdr, prs_struct *ps, int depth)
 379 {
 380         if (hdr == NULL)
 381                 return False;
 382
 383         prs_debug(ps, depth, desc, "smb_io_unihdr");
 384         depth++;
 385
 386         if(!prs_align(ps))
 387                 return False;
 388
 389         if(!prs_uint16("uni_str_len", ps, depth, &hdr->uni_str_len))
 390                 return False;
 391         if(!prs_uint16("uni_max_len", ps, depth, &hdr->uni_max_len))
 392                 return False;
 393         if(!prs_uint32("buffer     ", ps, depth, &hdr->buffer))
 394                 return False;
 395
 396         return True;
 397 }
 398
 399 /*******************************************************************
 400  Inits a BUFHDR structure.
 401 ********************************************************************/
 402
 403 void init_buf_hdr(BUFHDR *hdr, int max_len, int len)
 404 {
 405         hdr->buf_max_len = max_len;
 406         hdr->buf_len     = len;
 407 }
 408
 409 /*******************************************************************
 410  prs_uint16 wrapper. Call this and it sets up a pointer to where the
 411  uint16 should be stored, or gets the size if reading.
 412  ********************************************************************/
 413
 414 BOOL smb_io_hdrbuf_pre(const char *desc, BUFHDR *hdr, prs_struct *ps, int depth, uint32 *offset)
 415 {
 416         (*offset) = prs_offset(ps);
 417         if (ps->io) {
 418
 419                 /* reading. */
 420
 421                 if(!smb_io_hdrbuf(desc, hdr, ps, depth))
 422                         return False;
 423
 424         } else {
 425
 426                 /* writing. */
 427
 428                 if(!prs_set_offset(ps, prs_offset(ps) + (sizeof(uint32) * 2)))
 429                         return False;
 430         }
 431
 432         return True;
 433 }
 434
 435 /*******************************************************************
 436  smb_io_hdrbuf wrapper. Call this and it retrospectively stores the size.
 437  Does nothing on reading, as that is already handled by ...._pre()
 438  ********************************************************************/
 439
 440 BOOL smb_io_hdrbuf_post(const char *desc, BUFHDR *hdr, prs_struct *ps, int depth,
 441                                 uint32 ptr_hdrbuf, uint32 max_len, uint32 len)
 442 {
 443         if (!ps->io) {
 444                 /* writing: go back and do a retrospective job.  i hate this */
 445
 446                 uint32 old_offset = prs_offset(ps);
 447
 448                 init_buf_hdr(hdr, max_len, len);
 449                 if(!prs_set_offset(ps, ptr_hdrbuf))
 450                         return False;
 451                 if(!smb_io_hdrbuf(desc, hdr, ps, depth))
 452                         return False;
 453
 454                 if(!prs_set_offset(ps, old_offset))
 455                         return False;
 456         }
 457
 458         return True;
 459 }
 460
 461 /*******************************************************************
 462  Reads or writes a BUFHDR structure.
 463 ********************************************************************/
 464
 465 BOOL smb_io_hdrbuf(const char *desc, BUFHDR *hdr, prs_struct *ps, int depth)
 466 {
 467         if (hdr == NULL)
 468                 return False;
 469
 470         prs_debug(ps, depth, desc, "smb_io_hdrbuf");
 471         depth++;
 472
 473         if(!prs_align(ps))
 474                 return False;
 475
 476         if(!prs_uint32("buf_max_len", ps, depth, &hdr->buf_max_len))
 477                 return False;
 478         if(!prs_uint32("buf_len    ", ps, depth, &hdr->buf_len))
 479                 return False;
 480
 481         return True;
 482 }
 483
 484 /*******************************************************************
 485  Inits a UNISTR structure.
 486 ********************************************************************/
 487
 488 void init_unistr(UNISTR *str, const char *buf)
 489 {
 490         size_t len;
 491
 492         if (buf == NULL) {
 493                 str->buffer = NULL;
 494                 return;
 495         }
 496
 497         len = strlen(buf) + 1;
 498
 499         if (len) {
 500                 str->buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, len);
 501                 if (str->buffer == NULL)
 502                         smb_panic("init_unistr: malloc fail\n");
 503
 504                 rpcstr_push(str->buffer, buf, len*sizeof(uint16), STR_TERMINATE);
 505         } else {
 506                 str->buffer = NULL;
 507         }
 508 }
 509
 510 /*******************************************************************
 511 reads or writes a UNISTR structure.
 512 XXXX NOTE: UNISTR structures NEED to be null-terminated.
 513 ********************************************************************/
 514
 515 BOOL smb_io_unistr(const char *desc, UNISTR *uni, prs_struct *ps, int depth)
 516 {
 517         if (uni == NULL)
 518                 return False;
 519
 520         prs_debug(ps, depth, desc, "smb_io_unistr");
 521         depth++;
 522
 523         if(!prs_unistr("unistr", ps, depth, uni))
 524                 return False;
 525
 526         return True;
 527 }
 528
 529 /*******************************************************************
 530  Allocate the RPC_DATA_BLOB memory.
 531 ********************************************************************/
 532
 533 static void create_rpc_blob(RPC_DATA_BLOB *str, size_t len)
 534 {
 535         if (len) {
 536                 str->buffer = (uint8 *)TALLOC_ZERO(get_talloc_ctx(), len);
 537                 if (str->buffer == NULL)
 538                         smb_panic("create_rpc_blob: talloc fail\n");
 539                 str->buf_len = len;
 540         } else {
 541                 str->buffer = NULL;
 542                 str->buf_len = 0;
 543         }
 544 }
 545
 546 /*******************************************************************
 547  Inits a RPC_DATA_BLOB structure from a uint32
 548 ********************************************************************/
 549
 550 void init_rpc_blob_uint32(RPC_DATA_BLOB *str, uint32 val)
 551 {
 552         ZERO_STRUCTP(str);
 553
 554         /* set up string lengths. */
 555         create_rpc_blob(str, sizeof(uint32));
 556         SIVAL(str->buffer, 0, val);
 557 }
 558
 559 /*******************************************************************
 560  Inits a RPC_DATA_BLOB structure.
 561 ********************************************************************/
 562
 563 void init_rpc_blob_str(RPC_DATA_BLOB *str, const char *buf, int len)
 564 {
 565         ZERO_STRUCTP(str);
 566
 567         /* set up string lengths. */
 568         if (len) {
 569                 create_rpc_blob(str, len*2);
 570                 rpcstr_push(str->buffer, buf, (size_t)str->buf_len, STR_TERMINATE);
 571         }
 572 }
 573
 574 /*******************************************************************
 575  Inits a RPC_DATA_BLOB structure from a hex string.
 576 ********************************************************************/
 577
 578 void init_rpc_blob_hex(RPC_DATA_BLOB *str, const char *buf)
 579 {
 580         ZERO_STRUCTP(str);
 581         if (buf && *buf) {
 582                 create_rpc_blob(str, strlen(buf));
 583                 str->buf_len = strhex_to_str((char *)str->buffer, str->buf_len, buf);
 584         }
 585 }
 586
 587 /*******************************************************************
 588  Inits a RPC_DATA_BLOB structure.
 589 ********************************************************************/
 590
 591 void init_rpc_blob_bytes(RPC_DATA_BLOB *str, uint8 *buf, size_t len)
 592 {
 593         ZERO_STRUCTP(str);
 594
 595         /* max buffer size (allocated size) */
 596         if (buf != NULL && len) {
 597                 create_rpc_blob(str, len);
 598                 memcpy(str->buffer, buf, len);
 599         }
 600         str->buf_len = len;
 601 }
 602
 603 /*******************************************************************
 604 reads or writes a BUFFER5 structure.
 605 the buf_len member tells you how large the buffer is.
 606 ********************************************************************/
 607 BOOL smb_io_buffer5(const char *desc, BUFFER5 *buf5, prs_struct *ps, int depth)
 608 {
 609         prs_debug(ps, depth, desc, "smb_io_buffer5");
 610         depth++;
 611
 612         if (buf5 == NULL) return False;
 613
 614         if(!prs_align(ps))
 615                 return False;
 616         if(!prs_uint32("buf_len", ps, depth, &buf5->buf_len))
 617                 return False;
 618
 619         if(buf5->buf_len) {
 620                 if(!prs_buffer5(True, "buffer" , ps, depth, buf5))
 621                         return False;
 622         }
 623
 624         return True;
 625 }
 626
 627 /*******************************************************************
 628  Inits a REGVAL_BUFFER structure.
 629 ********************************************************************/
 630
 631 void init_regval_buffer(REGVAL_BUFFER *str, const uint8 *buf, size_t len)
 632 {
 633         ZERO_STRUCTP(str);
 634
 635         /* max buffer size (allocated size) */
 636         str->buf_max_len = len;
 637         str->offset = 0;
 638         str->buf_len = buf != NULL ? len : 0;
 639
 640         if (buf != NULL) {
 641                 SMB_ASSERT(str->buf_max_len >= str->buf_len);
 642                 str->buffer = (uint16 *)TALLOC_ZERO(get_talloc_ctx(),
 643                                                     str->buf_max_len);
 644                 if (str->buffer == NULL)
 645                         smb_panic("init_regval_buffer: talloc fail\n");
 646                 memcpy(str->buffer, buf, str->buf_len);
 647         }
 648 }
 649
 650 /*******************************************************************
 651  Reads or writes a REGVAL_BUFFER structure.
 652    the uni_max_len member tells you how large the buffer is.
 653    the uni_str_len member tells you how much of the buffer is really used.
 654 ********************************************************************/
 655
 656 BOOL smb_io_regval_buffer(const char *desc, prs_struct *ps, int depth, REGVAL_BUFFER *buf2)
 657 {
 658
 659         prs_debug(ps, depth, desc, "smb_io_regval_buffer");
 660         depth++;
 661
 662         if(!prs_align(ps))
 663                 return False;
 664
 665         if(!prs_uint32("buf_max_len", ps, depth, &buf2->buf_max_len))
 666                 return False;
 667         if(!prs_uint32("offset     ", ps, depth, &buf2->offset))
 668                 return False;
 669         if(!prs_uint32("buf_len    ", ps, depth, &buf2->buf_len))
 670                 return False;
 671
 672         /* buffer advanced by indicated length of string
 673            NOT by searching for null-termination */
 674
 675         if(!prs_regval_buffer(True, "buffer     ", ps, depth, buf2))
 676                 return False;
 677
 678         return True;
 679 }
 680
 681 /*******************************************************************
 682 creates a UNISTR2 structure: sets up the buffer, too
 683 ********************************************************************/
 684
 685 void init_buf_unistr2(UNISTR2 *str, uint32 *ptr, const char *buf)
 686 {
 687         if (buf != NULL) {
 688                 *ptr = 1;
 689                 init_unistr2(str, buf, UNI_STR_TERMINATE);
 690         } else {
 691                 *ptr = 0;
 692                 init_unistr2(str, NULL, UNI_FLAGS_NONE);
 693
 694         }
 695 }
 696
 697 /*******************************************************************
 698  Copies a UNISTR2 structure.
 699 ********************************************************************/
 700
 701 void copy_unistr2(UNISTR2 *str, const UNISTR2 *from)
 702 {
 703         if (from->buffer == NULL) {
 704                 ZERO_STRUCTP(str);
 705                 return;
 706         }
 707
 708         SMB_ASSERT(from->uni_max_len >= from->uni_str_len);
 709
 710         str->uni_max_len = from->uni_max_len;
 711         str->offset      = from->offset;
 712         str->uni_str_len = from->uni_str_len;
 713
 714         /* the string buffer is allocated to the maximum size
 715            (the the length of the source string) to prevent
 716            reallocation of memory. */
 717         if (str->buffer == NULL) {
 718                 if (str->uni_max_len) {
 719                         str->buffer = (uint16 *)TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, str->uni_max_len);
 720                         if ((str->buffer == NULL)) {
 721                                 smb_panic("copy_unistr2: talloc fail\n");
 722                                 return;
 723                         }
 724                         /* copy the string */
 725                         memcpy(str->buffer, from->buffer, str->uni_max_len*sizeof(uint16));
 726                 } else {
 727                         str->buffer = NULL;
 728                 }
 729         }
 730 }
 731
 732 /*******************************************************************
 733  Creates a STRING2 structure.
 734 ********************************************************************/
 735
 736 void init_string2(STRING2 *str, const char *buf, size_t max_len, size_t str_len)
 737 {
 738         /* set up string lengths. */
 739         SMB_ASSERT(max_len >= str_len);
 740
 741         /* Ensure buf is valid if str_len was set. Coverity check. */
 742         if (str_len && !buf) {
 743                 return;
 744         }
 745
 746         str->str_max_len = max_len;
 747         str->offset = 0;
 748         str->str_str_len = str_len;
 749
 750         /* store the string */
 751         if(str_len != 0) {
 752                 str->buffer = (uint8 *)TALLOC_ZERO(get_talloc_ctx(),
 753                                                    str->str_max_len);
 754                 if (str->buffer == NULL)
 755                         smb_panic("init_string2: malloc fail\n");
 756                 memcpy(str->buffer, buf, str_len);
 757         }
 758 }
 759
 760 /*******************************************************************
 761  Reads or writes a STRING2 structure.
 762  XXXX NOTE: STRING2 structures need NOT be null-terminated.
 763    the str_str_len member tells you how long the string is;
 764    the str_max_len member tells you how large the buffer is.
 765 ********************************************************************/
 766
 767 BOOL smb_io_string2(const char *desc, STRING2 *str2, uint32 buffer, prs_struct *ps, int depth)
 768 {
 769         if (str2 == NULL)
 770                 return False;
 771
 772         if (buffer) {
 773
 774                 prs_debug(ps, depth, desc, "smb_io_string2");
 775                 depth++;
 776
 777                 if(!prs_align(ps))
 778                         return False;
 779
 780                 if(!prs_uint32("str_max_len", ps, depth, &str2->str_max_len))
 781                         return False;
 782                 if(!prs_uint32("offset     ", ps, depth, &str2->offset))
 783                         return False;
 784                 if(!prs_uint32("str_str_len", ps, depth, &str2->str_str_len))
 785                         return False;
 786
 787                 /* buffer advanced by indicated length of string
 788                    NOT by searching for null-termination */
 789                 if(!prs_string2(True, "buffer     ", ps, depth, str2))
 790                         return False;
 791
 792         } else {
 793
 794                 prs_debug(ps, depth, desc, "smb_io_string2 - NULL");
 795                 depth++;
 796                 memset((char *)str2, '\0', sizeof(*str2));
 797
 798         }
 799
 800         return True;
 801 }
 802
 803 /*******************************************************************
 804  Inits a UNISTR2 structure.
 805 ********************************************************************/
 806
 807 void init_unistr2(UNISTR2 *str, const char *buf, enum unistr2_term_codes flags)
 808 {
 809         size_t len = 0;
 810         uint32 num_chars = 0;
 811
 812         if (buf) {
 813                 /* We always null terminate the copy. */
 814                 len = strlen(buf) + 1;
 815                 if ( flags == UNI_STR_DBLTERMINATE )
 816                         len++;
 817         }
 818
 819         if (buf == NULL || len == 0) {
 820                 /* no buffer -- nothing to do */
 821                 str->uni_max_len = 0;
 822                 str->offset = 0;
 823                 str->uni_str_len = 0;
 824
 825                 return;
 826         }
 827
 828
 829         str->buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, len);
 830         if (str->buffer == NULL) {
 831                 smb_panic("init_unistr2: malloc fail\n");
 832                 return;
 833         }
 834
 835         /* Ensure len is the length in *bytes* */
 836         len *= sizeof(uint16);
 837
 838         /*
 839          * The UNISTR2 must be initialized !!!
 840          * jfm, 7/7/2001.
 841          */
 842         if (buf) {
 843                 rpcstr_push((char *)str->buffer, buf, len, STR_TERMINATE);
 844                 num_chars = strlen_w(str->buffer);
 845                 if (flags == UNI_STR_TERMINATE || flags == UNI_MAXLEN_TERMINATE) {
 846                         num_chars++;
 847                 }
 848                 if ( flags == UNI_STR_DBLTERMINATE )
 849                         num_chars += 2;
 850         }
 851
 852         str->uni_max_len = num_chars;
 853         str->offset = 0;
 854         str->uni_str_len = num_chars;
 855         if ( num_chars && ((flags == UNI_MAXLEN_TERMINATE) || (flags == UNI_BROKEN_NON_NULL)) )
 856                 str->uni_max_len++;
 857 }
 858
 859 /*******************************************************************
 860  Inits a UNISTR4 structure.
 861 ********************************************************************/
 862
 863 void init_unistr4(UNISTR4 *uni4, const char *buf, enum unistr2_term_codes flags)
 864 {
 865         uni4->string = TALLOC_P( get_talloc_ctx(), UNISTR2 );
 866         if (!uni4->string) {
 867                 smb_panic("init_unistr4: talloc fail\n");
 868                 return;
 869         }
 870         init_unistr2( uni4->string, buf, flags );
 871
 872         uni4->length = 2 * (uni4->string->uni_str_len);
 873         uni4->size   = 2 * (uni4->string->uni_max_len);
 874 }
 875
 876 void init_unistr4_w( TALLOC_CTX *ctx, UNISTR4 *uni4, const smb_ucs2_t *buf )
 877 {
 878         uni4->string = TALLOC_P( ctx, UNISTR2 );
 879         if (!uni4->string) {
 880                 smb_panic("init_unistr4_w: talloc fail\n");
 881                 return;
 882         }
 883         init_unistr2_w( ctx, uni4->string, buf );
 884
 885         uni4->length = 2 * (uni4->string->uni_str_len);
 886         uni4->size   = 2 * (uni4->string->uni_max_len);
 887 }
 888
 889 /**
 890  *  Inits a UNISTR2 structure.
 891  *  @param  ctx talloc context to allocate string on
 892  *  @param  str pointer to string to create
 893  *  @param  buf UCS2 null-terminated buffer to init from
 894 */
 895
 896 void init_unistr2_w(TALLOC_CTX *ctx, UNISTR2 *str, const smb_ucs2_t *buf)
 897 {
 898         uint32 len = buf ? strlen_w(buf) : 0;
 899
 900         ZERO_STRUCTP(str);
 901
 902         /* set up string lengths. */
 903         str->uni_max_len = len;
 904         str->offset = 0;
 905         str->uni_str_len = len;
 906
 907         if (len + 1) {
 908                 str->buffer = TALLOC_ZERO_ARRAY(ctx, uint16, len + 1);
 909                 if (str->buffer == NULL) {
 910                         smb_panic("init_unistr2_w: talloc fail\n");
 911                         return;
 912                 }
 913         } else {
 914                 str->buffer = NULL;
 915         }
 916
 917         /*
 918          * don't move this test above ! The UNISTR2 must be initialized !!!
 919          * jfm, 7/7/2001.
 920          */
 921         if (buf==NULL)
 922                 return;
 923
 924         /* Yes, this is a strncpy( foo, bar, strlen(bar)) - but as
 925            long as the buffer above is talloc()ed correctly then this
 926            is the correct thing to do */
 927         if (len+1) {
 928                 strncpy_w(str->buffer, buf, len + 1);
 929         }
 930 }
 931
 932 /*******************************************************************
 933  Inits a UNISTR2 structure from a UNISTR
 934 ********************************************************************/
 935
 936 void init_unistr2_from_unistr(UNISTR2 *to, const UNISTR *from)
 937 {
 938         uint32 i;
 939
 940         /* the destination UNISTR2 should never be NULL.
 941            if it is it is a programming error */
 942
 943         /* if the source UNISTR is NULL, then zero out
 944            the destination string and return */
 945         ZERO_STRUCTP (to);
 946         if ((from == NULL) || (from->buffer == NULL))
 947                 return;
 948
 949         /* get the length; UNISTR must be NULL terminated */
 950         i = 0;
 951         while ((from->buffer)[i]!='\0')
 952                 i++;
 953         i++;    /* one more to catch the terminating NULL */
 954                 /* is this necessary -- jerry?  I need to think */
 955
 956         /* set up string lengths; uni_max_len is set to i+1
 957            because we need to account for the final NULL termination */
 958         to->uni_max_len = i;
 959         to->offset = 0;
 960         to->uni_str_len = i;
 961
 962         /* allocate the space and copy the string buffer */
 963         if (i) {
 964                 to->buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, i);
 965                 if (to->buffer == NULL)
 966                         smb_panic("init_unistr2_from_unistr: malloc fail\n");
 967                 memcpy(to->buffer, from->buffer, i*sizeof(uint16));
 968         } else {
 969                 to->buffer = NULL;
 970         }
 971         return;
 972 }
 973
 974 /*******************************************************************
 975   Inits a UNISTR2 structure from a DATA_BLOB.
 976   The length of the data_blob must count the bytes of the buffer.
 977   Copies the blob data.
 978 ********************************************************************/
 979
 980 void init_unistr2_from_datablob(UNISTR2 *str, DATA_BLOB *blob)
 981 {
 982         /* Allocs the unistring */
 983         init_unistr2(str, NULL, UNI_FLAGS_NONE);
 984
 985         /* Sets the values */
 986         str->uni_str_len = blob->length / sizeof(uint16);
 987         str->uni_max_len = str->uni_str_len;
 988         str->offset = 0;
 989         if (blob->length) {
 990                 str->buffer = (uint16 *) memdup(blob->data, blob->length);
 991         } else {
 992                 str->buffer = NULL;
 993         }
 994         if ((str->buffer == NULL) && (blob->length > 0)) {
 995                 smb_panic("init_unistr2_from_datablob: malloc fail\n");
 996         }
 997 }
 998
 999 /*******************************************************************
1000  UNISTR2* are a little different in that the pointer and the UNISTR2
1001  are not necessarily read/written back to back.  So we break it up
1002  into 2 separate functions.
1003  See SPOOL_USER_1 in include/rpc_spoolss.h for an example.
1004 ********************************************************************/
1005
1006 BOOL prs_io_unistr2_p(const char *desc, prs_struct *ps, int depth, UNISTR2 **uni2)
1007 {
1008         uint32 data_p;
1009
1010         /* caputure the pointer value to stream */
1011
1012         data_p = *uni2 ? 0xf000baaa : 0;
1013
1014         if ( !prs_uint32("ptr", ps, depth, &data_p ))
1015                 return False;
1016
1017         /* we're done if there is no data */
1018
1019         if ( !data_p )
1020                 return True;
1021
1022         if (UNMARSHALLING(ps)) {
1023                 if ( !(*uni2 = PRS_ALLOC_MEM(ps, UNISTR2, 1)) )
1024                         return False;
1025         }
1026
1027         return True;
1028 }
1029
1030 /*******************************************************************
1031  now read/write the actual UNISTR2.  Memory for the UNISTR2 (but
1032  not UNISTR2.buffer) has been allocated previously by prs_unistr2_p()
1033 ********************************************************************/
1034
1035 BOOL prs_io_unistr2(const char *desc, prs_struct *ps, int depth, UNISTR2 *uni2 )
1036 {
1037         /* just return true if there is no pointer to deal with.
1038            the memory must have been previously allocated on unmarshalling
1039            by prs_unistr2_p() */
1040
1041         if ( !uni2 )
1042                 return True;
1043
1044         /* just pass off to smb_io_unstr2() passing the uni2 address as
1045            the pointer (like you would expect) */
1046
1047         return smb_io_unistr2( desc, uni2, uni2 ? 1 : 0, ps, depth );
1048 }
1049
1050 /*******************************************************************
1051  Reads or writes a UNISTR2 structure.
1052  XXXX NOTE: UNISTR2 structures need NOT be null-terminated.
1053    the uni_str_len member tells you how long the string is;
1054    the uni_max_len member tells you how large the buffer is.
1055 ********************************************************************/
1056
1057 BOOL smb_io_unistr2(const char *desc, UNISTR2 *uni2, uint32 buffer, prs_struct *ps, int depth)
1058 {
1059         if (uni2 == NULL)
1060                 return False;
1061
1062         if (buffer) {
1063
1064                 prs_debug(ps, depth, desc, "smb_io_unistr2");
1065                 depth++;
1066
1067                 if(!prs_align(ps))
1068                         return False;
1069
1070                 if(!prs_uint32("uni_max_len", ps, depth, &uni2->uni_max_len))
1071                         return False;
1072                 if(!prs_uint32("offset     ", ps, depth, &uni2->offset))
1073                         return False;
1074                 if(!prs_uint32("uni_str_len", ps, depth, &uni2->uni_str_len))
1075                         return False;
1076
1077                 /* buffer advanced by indicated length of string
1078                    NOT by searching for null-termination */
1079                 if(!prs_unistr2(True, "buffer     ", ps, depth, uni2))
1080                         return False;
1081
1082         } else {
1083
1084                 prs_debug(ps, depth, desc, "smb_io_unistr2 - NULL");
1085                 depth++;
1086                 memset((char *)uni2, '\0', sizeof(*uni2));
1087
1088         }
1089
1090         return True;
1091 }
1092
1093 /*******************************************************************
1094  now read/write UNISTR4
1095 ********************************************************************/
1096
1097 BOOL prs_unistr4(const char *desc, prs_struct *ps, int depth, UNISTR4 *uni4)
1098 {
1099         void *ptr;
1100         prs_debug(ps, depth, desc, "prs_unistr4");
1101         depth++;
1102
1103         if ( !prs_uint16("length", ps, depth, &uni4->length ))
1104                 return False;
1105         if ( !prs_uint16("size", ps, depth, &uni4->size ))
1106                 return False;
1107
1108         ptr = uni4->string;
1109
1110         if ( !prs_pointer( desc, ps, depth, &ptr, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2 ) )
1111                 return False;
1112
1113         uni4->string = (UNISTR2 *)ptr;
1114
1115         return True;
1116 }
1117
1118 /*******************************************************************
1119  now read/write UNISTR4 header
1120 ********************************************************************/
1121
1122 BOOL prs_unistr4_hdr(const char *desc, prs_struct *ps, int depth, UNISTR4 *uni4)
1123 {
1124         prs_debug(ps, depth, desc, "prs_unistr4_hdr");
1125         depth++;
1126
1127         if ( !prs_uint16("length", ps, depth, &uni4->length) )
1128                 return False;
1129         if ( !prs_uint16("size", ps, depth, &uni4->size) )
1130                 return False;
1131         if ( !prs_io_unistr2_p(desc, ps, depth, &uni4->string) )
1132                 return False;
1133
1134         return True;
1135 }
1136
1137 /*******************************************************************
1138  now read/write UNISTR4 string
1139 ********************************************************************/
1140
1141 BOOL prs_unistr4_str(const char *desc, prs_struct *ps, int depth, UNISTR4 *uni4)
1142 {
1143         prs_debug(ps, depth, desc, "prs_unistr4_str");
1144         depth++;
1145
1146         if ( !prs_io_unistr2(desc, ps, depth, uni4->string) )
1147                 return False;
1148
1149         return True;
1150 }
1151
1152 /*******************************************************************
1153  Reads or writes a UNISTR4_ARRAY structure.
1154 ********************************************************************/
1155
1156 BOOL prs_unistr4_array(const char *desc, prs_struct *ps, int depth, UNISTR4_ARRAY *array )
1157 {
1158         unsigned int i;
1159
1160         prs_debug(ps, depth, desc, "prs_unistr4_array");
1161         depth++;
1162
1163         if(!prs_uint32("count", ps, depth, &array->count))
1164                 return False;
1165
1166         if (UNMARSHALLING(ps)) {
1167                 if (array->count) {
1168                         if ( !(array->strings = TALLOC_ZERO_ARRAY( get_talloc_ctx(), UNISTR4, array->count)) )
1169                                 return False;
1170                 } else {
1171                         array->strings = NULL;
1172                 }
1173         }
1174
1175         /* write the headers and then the actual string buffer */
1176
1177         for ( i=0; i<array->count; i++ ) {
1178                 if ( !prs_unistr4_hdr( "string", ps, depth, &array->strings[i]) )
1179                         return False;
1180         }
1181
1182         for (i=0;i<array->count;i++) {
1183                 if ( !prs_unistr4_str("string", ps, depth, &array->strings[i]) )
1184                         return False;
1185         }
1186
1187         return True;
1188 }
1189
1190 /********************************************************************
1191   initialise a UNISTR_ARRAY from a char**
1192 ********************************************************************/
1193
1194 BOOL init_unistr4_array( UNISTR4_ARRAY *array, uint32 count, const char **strings )
1195 {
1196         unsigned int i;
1197
1198         array->count = count;
1199
1200         /* allocate memory for the array of UNISTR4 objects */
1201
1202         if (array->count) {
1203                 if ( !(array->strings = TALLOC_ZERO_ARRAY(get_talloc_ctx(), UNISTR4, count )) )
1204                         return False;
1205         } else {
1206                 array->strings = NULL;
1207         }
1208
1209         for ( i=0; i<count; i++ )
1210                 init_unistr4( &array->strings[i], strings[i], UNI_STR_TERMINATE );
1211
1212         return True;
1213 }
1214
1215 BOOL smb_io_lockout_string_hdr(const char *desc, HDR_LOCKOUT_STRING *hdr_account_lockout, prs_struct *ps, int depth)
1216 {
1217         prs_debug(ps, depth, desc, "smb_io_lockout_string_hdr");
1218         depth++;
1219
1220         if(!prs_align(ps))
1221                 return False;
1222
1223         if(!prs_uint16("size", ps, depth, &hdr_account_lockout->size))
1224                 return False;
1225         if(!prs_uint16("length", ps, depth, &hdr_account_lockout->length))
1226                 return False;
1227         if(!prs_uint32("buffer", ps, depth, &hdr_account_lockout->buffer))
1228                 return False;
1229
1230         return True;
1231 }
1232
1233 BOOL smb_io_account_lockout_str(const char *desc, LOCKOUT_STRING *account_lockout, uint32 buffer, prs_struct *ps, int depth)
1234 {
1235         prs_debug(ps, depth, desc, "smb_io_account_lockout_string");
1236         depth++;
1237
1238         if(!prs_uint32("array_size", ps, depth, &account_lockout->array_size))
1239                 return False;
1240
1241         if(!prs_uint32("offset", ps, depth, &account_lockout->offset))
1242                 return False;
1243         if(!prs_uint32("length", ps, depth, &account_lockout->length))
1244                 return False;
1245
1246         if (!prs_uint64("lockout_duration", ps, depth, &account_lockout->lockout_duration))
1247                 return False;
1248         if (!prs_uint64("reset_count", ps, depth, &account_lockout->reset_count))
1249                 return False;
1250         if (!prs_uint32("bad_attempt_lockout", ps, depth, &account_lockout->bad_attempt_lockout))
1251                 return False;
1252         if (!prs_uint32("dummy", ps, depth, &account_lockout->dummy))
1253                 return False;
1254 #if 0
1255         if(!prs_uint16s (False, "bindata", ps, depth, &account_lockout->bindata, length))
1256                 return False;
1257 #endif
1258
1259         return True;
1260 }
1261
1262 /*******************************************************************
1263  Inits a DOM_RID structure.
1264 ********************************************************************/
1265
1266 void init_dom_rid(DOM_RID *prid, uint32 rid, uint16 type, uint32 idx)
1267 {
1268         prid->type    = type;
1269         prid->rid     = rid;
1270         prid->rid_idx = idx;
1271 }
1272
1273 /*******************************************************************
1274  Reads or writes a DOM_RID structure.
1275 ********************************************************************/
1276
1277 BOOL smb_io_dom_rid(const char *desc, DOM_RID *rid, prs_struct *ps, int depth)
1278 {
1279         if (rid == NULL)
1280                 return False;
1281
1282         prs_debug(ps, depth, desc, "smb_io_dom_rid");
1283         depth++;
1284
1285         if(!prs_align(ps))
1286                 return False;
1287
1288         if(!prs_uint16("type   ", ps, depth, &rid->type))
1289                 return False;
1290         if(!prs_align(ps))
1291                 return False;
1292         if(!prs_uint32("rid    ", ps, depth, &rid->rid))
1293                 return False;
1294         if(!prs_uint32("rid_idx", ps, depth, &rid->rid_idx))
1295                 return False;
1296
1297         return True;
1298 }
1299
1300 /*******************************************************************
1301  Reads or writes a DOM_RID2 structure.
1302 ********************************************************************/
1303
1304 BOOL smb_io_dom_rid2(const char *desc, DOM_RID2 *rid, prs_struct *ps, int depth)
1305 {
1306         if (rid == NULL)
1307                 return False;
1308
1309         prs_debug(ps, depth, desc, "smb_io_dom_rid2");
1310         depth++;
1311
1312         if(!prs_align(ps))
1313                 return False;
1314
1315         if(!prs_uint16("type   ", ps, depth, &rid->type))
1316                 return False;
1317         if(!prs_align(ps))
1318                 return False;
1319         if(!prs_uint32("rid    ", ps, depth, &rid->rid))
1320                 return False;
1321         if(!prs_uint32("rid_idx", ps, depth, &rid->rid_idx))
1322                 return False;
1323         if(!prs_uint32("unknown", ps, depth, &rid->unknown))
1324                 return False;
1325
1326         return True;
1327 }
1328
1329
1330 /*******************************************************************
1331 creates a DOM_RID3 structure.
1332 ********************************************************************/
1333
1334 void init_dom_rid3(DOM_RID3 *rid3, uint32 rid, uint8 type)
1335 {
1336     rid3->rid      = rid;
1337     rid3->type1    = type;
1338     rid3->ptr_type = 0x1; /* non-zero, basically. */
1339     rid3->type2    = 0x1;
1340     rid3->unk      = type;
1341 }
1342
1343 /*******************************************************************
1344 reads or writes a DOM_RID3 structure.
1345 ********************************************************************/
1346
1347 BOOL smb_io_dom_rid3(const char *desc, DOM_RID3 *rid3, prs_struct *ps, int depth)
1348 {
1349         if (rid3 == NULL)
1350                 return False;
1351
1352         prs_debug(ps, depth, desc, "smb_io_dom_rid3");
1353         depth++;
1354
1355         if(!prs_align(ps))
1356                 return False;
1357
1358         if(!prs_uint32("rid     ", ps, depth, &rid3->rid))
1359                 return False;
1360         if(!prs_uint32("type1   ", ps, depth, &rid3->type1))
1361                 return False;
1362         if(!prs_uint32("ptr_type", ps, depth, &rid3->ptr_type))
1363                 return False;
1364         if(!prs_uint32("type2   ", ps, depth, &rid3->type2))
1365                 return False;
1366         if(!prs_uint32("unk     ", ps, depth, &rid3->unk))
1367                 return False;
1368
1369         return True;
1370 }
1371
1372 /*******************************************************************
1373  Inits a DOM_RID4 structure.
1374 ********************************************************************/
1375
1376 void init_dom_rid4(DOM_RID4 *rid4, uint16 unknown, uint16 attr, uint32 rid)
1377 {
1378     rid4->unknown = unknown;
1379     rid4->attr    = attr;
1380     rid4->rid     = rid;
1381 }
1382
1383 /*******************************************************************
1384  Inits a DOM_CLNT_SRV structure.
1385 ********************************************************************/
1386
1387 static void init_clnt_srv(DOM_CLNT_SRV *logcln, const char *logon_srv, const char *comp_name)
1388 {
1389         DEBUG(5,("init_clnt_srv: %d\n", __LINE__));
1390
1391         if (logon_srv != NULL) {
1392                 logcln->undoc_buffer = 1;
1393                 init_unistr2(&logcln->uni_logon_srv, logon_srv, UNI_STR_TERMINATE);
1394         } else {
1395                 logcln->undoc_buffer = 0;
1396         }
1397
1398         if (comp_name != NULL) {
1399                 logcln->undoc_buffer2 = 1;
1400                 init_unistr2(&logcln->uni_comp_name, comp_name, UNI_STR_TERMINATE);
1401         } else {
1402                 logcln->undoc_buffer2 = 0;
1403         }
1404 }
1405
1406 /*******************************************************************
1407  Inits or writes a DOM_CLNT_SRV structure.
1408 ********************************************************************/
1409
1410 BOOL smb_io_clnt_srv(const char *desc, DOM_CLNT_SRV *logcln, prs_struct *ps, int depth)
1411 {
1412         if (logcln == NULL)
1413                 return False;
1414
1415         prs_debug(ps, depth, desc, "smb_io_clnt_srv");
1416         depth++;
1417
1418         if(!prs_align(ps))
1419                 return False;
1420
1421         if(!prs_uint32("undoc_buffer ", ps, depth, &logcln->undoc_buffer))
1422                 return False;
1423
1424         if (logcln->undoc_buffer != 0) {
1425                 if(!smb_io_unistr2("unistr2", &logcln->uni_logon_srv, logcln->undoc_buffer, ps, depth))
1426                         return False;
1427         }
1428
1429         if(!prs_align(ps))
1430                 return False;
1431
1432         if(!prs_uint32("undoc_buffer2", ps, depth, &logcln->undoc_buffer2))
1433                 return False;
1434
1435         if (logcln->undoc_buffer2 != 0) {
1436                 if(!smb_io_unistr2("unistr2", &logcln->uni_comp_name, logcln->undoc_buffer2, ps, depth))
1437                         return False;
1438         }
1439
1440         return True;
1441 }
1442
1443 /*******************************************************************
1444  Inits a DOM_LOG_INFO structure.
1445 ********************************************************************/
1446
1447 void init_log_info(DOM_LOG_INFO *loginfo, const char *logon_srv, const char *acct_name,
1448                 uint16 sec_chan, const char *comp_name)
1449 {
1450         DEBUG(5,("make_log_info %d\n", __LINE__));
1451
1452         loginfo->undoc_buffer = 1;
1453
1454         init_unistr2(&loginfo->uni_logon_srv, logon_srv, UNI_STR_TERMINATE);
1455         init_unistr2(&loginfo->uni_acct_name, acct_name, UNI_STR_TERMINATE);
1456
1457         loginfo->sec_chan = sec_chan;
1458
1459         init_unistr2(&loginfo->uni_comp_name, comp_name, UNI_STR_TERMINATE);
1460 }
1461
1462 /*******************************************************************
1463  Reads or writes a DOM_LOG_INFO structure.
1464 ********************************************************************/
1465
1466 BOOL smb_io_log_info(const char *desc, DOM_LOG_INFO *loginfo, prs_struct *ps, int depth)
1467 {
1468         if (loginfo == NULL)
1469                 return False;
1470
1471         prs_debug(ps, depth, desc, "smb_io_log_info");
1472         depth++;
1473
1474         if(!prs_align(ps))
1475                 return False;
1476
1477         if(!prs_uint32("undoc_buffer", ps, depth, &loginfo->undoc_buffer))
1478                 return False;
1479
1480         if(!smb_io_unistr2("unistr2", &loginfo->uni_logon_srv, True, ps, depth))
1481                 return False;
1482         if(!smb_io_unistr2("unistr2", &loginfo->uni_acct_name, True, ps, depth))
1483                 return False;
1484
1485         if(!prs_uint16("sec_chan", ps, depth, &loginfo->sec_chan))
1486                 return False;
1487
1488         if(!smb_io_unistr2("unistr2", &loginfo->uni_comp_name, True, ps, depth))
1489                 return False;
1490
1491         return True;
1492 }
1493
1494 /*******************************************************************
1495  Reads or writes a DOM_CHAL structure.
1496 ********************************************************************/
1497
1498 BOOL smb_io_chal(const char *desc, DOM_CHAL *chal, prs_struct *ps, int depth)
1499 {
1500         if (chal == NULL)
1501                 return False;
1502
1503         prs_debug(ps, depth, desc, "smb_io_chal");
1504         depth++;
1505
1506         if(!prs_uint8s (False, "data", ps, depth, chal->data, 8))
1507                 return False;
1508
1509         return True;
1510 }
1511
1512 /*******************************************************************
1513  Reads or writes a DOM_CRED structure.
1514 ********************************************************************/
1515
1516 BOOL smb_io_cred(const char *desc,  DOM_CRED *cred, prs_struct *ps, int depth)
1517 {
1518         if (cred == NULL)
1519                 return False;
1520
1521         prs_debug(ps, depth, desc, "smb_io_cred");
1522         depth++;
1523
1524         if(!prs_align(ps))
1525                 return False;
1526
1527         if(!smb_io_chal ("", &cred->challenge, ps, depth))
1528                 return False;
1529
1530         if(!smb_io_utime("", &cred->timestamp, ps, depth))
1531                 return False;
1532
1533         return True;
1534 }
1535
1536 /*******************************************************************
1537  Inits a DOM_CLNT_INFO2 structure.
1538 ********************************************************************/
1539
1540 void init_clnt_info2(DOM_CLNT_INFO2 *clnt,
1541                                 const char *logon_srv, const char *comp_name,
1542                                 const DOM_CRED *clnt_cred)
1543 {
1544         DEBUG(5,("make_clnt_info: %d\n", __LINE__));
1545
1546         init_clnt_srv(&clnt->login, logon_srv, comp_name);
1547
1548         if (clnt_cred != NULL) {
1549                 clnt->ptr_cred = 1;
1550                 memcpy(&clnt->cred, clnt_cred, sizeof(clnt->cred));
1551         } else {
1552                 clnt->ptr_cred = 0;
1553         }
1554 }
1555
1556 /*******************************************************************
1557  Reads or writes a DOM_CLNT_INFO2 structure.
1558 ********************************************************************/
1559
1560 BOOL smb_io_clnt_info2(const char *desc, DOM_CLNT_INFO2 *clnt, prs_struct *ps, int depth)
1561 {
1562         if (clnt == NULL)
1563                 return False;
1564
1565         prs_debug(ps, depth, desc, "smb_io_clnt_info2");
1566         depth++;
1567
1568         if(!prs_align(ps))
1569                 return False;
1570
1571         if(!smb_io_clnt_srv("", &clnt->login, ps, depth))
1572                 return False;
1573
1574         if(!prs_align(ps))
1575                 return False;
1576
1577         if(!prs_uint32("ptr_cred", ps, depth, &clnt->ptr_cred))
1578                 return False;
1579         if(!smb_io_cred("", &clnt->cred, ps, depth))
1580                 return False;
1581
1582         return True;
1583 }
1584
1585 /*******************************************************************
1586  Inits a DOM_CLNT_INFO structure.
1587 ********************************************************************/
1588
1589 void init_clnt_info(DOM_CLNT_INFO *clnt,
1590                 const char *logon_srv, const char *acct_name,
1591                 uint16 sec_chan, const char *comp_name,
1592                 const DOM_CRED *cred)
1593 {
1594         DEBUG(5,("make_clnt_info\n"));
1595
1596         init_log_info(&clnt->login, logon_srv, acct_name, sec_chan, comp_name);
1597         memcpy(&clnt->cred, cred, sizeof(clnt->cred));
1598 }
1599
1600 /*******************************************************************
1601  Reads or writes a DOM_CLNT_INFO structure.
1602 ********************************************************************/
1603
1604 BOOL smb_io_clnt_info(const char *desc,  DOM_CLNT_INFO *clnt, prs_struct *ps, int depth)
1605 {
1606         if (clnt == NULL)
1607                 return False;
1608
1609         prs_debug(ps, depth, desc, "smb_io_clnt_info");
1610         depth++;
1611
1612         if(!prs_align(ps))
1613                 return False;
1614
1615         if(!smb_io_log_info("", &clnt->login, ps, depth))
1616                 return False;
1617         if(!smb_io_cred("", &clnt->cred, ps, depth))
1618                 return False;
1619
1620         return True;
1621 }
1622
1623 /*******************************************************************
1624  Inits a DOM_LOGON_ID structure.
1625 ********************************************************************/
1626
1627 void init_logon_id(DOM_LOGON_ID *logonid, uint32 log_id_low, uint32 log_id_high)
1628 {
1629         DEBUG(5,("make_logon_id: %d\n", __LINE__));
1630
1631         logonid->low  = log_id_low;
1632         logonid->high = log_id_high;
1633 }
1634
1635 /*******************************************************************
1636  Reads or writes a DOM_LOGON_ID structure.
1637 ********************************************************************/
1638
1639 BOOL smb_io_logon_id(const char *desc, DOM_LOGON_ID *logonid, prs_struct *ps, int depth)
1640 {
1641         if (logonid == NULL)
1642                 return False;
1643
1644         prs_debug(ps, depth, desc, "smb_io_logon_id");
1645         depth++;
1646
1647         if(!prs_align(ps))
1648                 return False;
1649
1650         if(!prs_uint32("low ", ps, depth, &logonid->low ))
1651                 return False;
1652         if(!prs_uint32("high", ps, depth, &logonid->high))
1653                 return False;
1654
1655         return True;
1656 }
1657
1658 /*******************************************************************
1659  Inits an OWF_INFO structure.
1660 ********************************************************************/
1661
1662 void init_owf_info(OWF_INFO *hash, const uint8 data[16])
1663 {
1664         DEBUG(5,("init_owf_info: %d\n", __LINE__));
1665
1666         if (data != NULL)
1667                 memcpy(hash->data, data, sizeof(hash->data));
1668         else
1669                 memset((char *)hash->data, '\0', sizeof(hash->data));
1670 }
1671
1672 /*******************************************************************
1673  Reads or writes an OWF_INFO structure.
1674 ********************************************************************/
1675
1676 BOOL smb_io_owf_info(const char *desc, OWF_INFO *hash, prs_struct *ps, int depth)
1677 {
1678         if (hash == NULL)
1679                 return False;
1680
1681         prs_debug(ps, depth, desc, "smb_io_owf_info");
1682         depth++;
1683
1684         if(!prs_align(ps))
1685                 return False;
1686
1687         if(!prs_uint8s (False, "data", ps, depth, hash->data, 16))
1688                 return False;
1689
1690         return True;
1691 }
1692
1693 /*******************************************************************
1694  Reads or writes a DOM_GID structure.
1695 ********************************************************************/
1696
1697 BOOL smb_io_gid(const char *desc,  DOM_GID *gid, prs_struct *ps, int depth)
1698 {
1699         if (gid == NULL)
1700                 return False;
1701
1702         prs_debug(ps, depth, desc, "smb_io_gid");
1703         depth++;
1704
1705         if(!prs_align(ps))
1706                 return False;
1707
1708         if(!prs_uint32("g_rid", ps, depth, &gid->g_rid))
1709                 return False;
1710         if(!prs_uint32("attr ", ps, depth, &gid->attr))
1711                 return False;
1712
1713         return True;
1714 }
1715
1716 /*******************************************************************
1717  Reads or writes an POLICY_HND structure.
1718 ********************************************************************/
1719
1720 BOOL smb_io_pol_hnd(const char *desc, POLICY_HND *pol, prs_struct *ps, int depth)
1721 {
1722         if (pol == NULL)
1723                 return False;
1724
1725         prs_debug(ps, depth, desc, "smb_io_pol_hnd");
1726         depth++;
1727
1728         if(!prs_align(ps))
1729                 return False;
1730
1731         if(UNMARSHALLING(ps))
1732                 ZERO_STRUCTP(pol);
1733
1734         if (!prs_uint32("handle_type", ps, depth, &pol->handle_type))
1735                 return False;
1736         if (!smb_io_uuid("uuid", (struct GUID*)&pol->uuid, ps, depth))
1737                 return False;
1738
1739         return True;
1740 }
1741
1742 /*******************************************************************
1743  Create a UNISTR3.
1744 ********************************************************************/
1745
1746 void init_unistr3(UNISTR3 *str, const char *buf)
1747 {
1748         if (buf == NULL) {
1749                 str->uni_str_len=0;
1750                 str->str.buffer = NULL;
1751                 return;
1752         }
1753
1754         str->uni_str_len = strlen(buf) + 1;
1755
1756         if (str->uni_str_len) {
1757                 str->str.buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, str->uni_str_len);
1758                 if (str->str.buffer == NULL)
1759                         smb_panic("init_unistr3: malloc fail\n");
1760
1761                 rpcstr_push((char *)str->str.buffer, buf, str->uni_str_len * sizeof(uint16), STR_TERMINATE);
1762         } else {
1763                 str->str.buffer = NULL;
1764         }
1765 }
1766
1767 /*******************************************************************
1768  Reads or writes a UNISTR3 structure.
1769 ********************************************************************/
1770
1771 BOOL smb_io_unistr3(const char *desc, UNISTR3 *name, prs_struct *ps, int depth)
1772 {
1773         if (name == NULL)
1774                 return False;
1775
1776         prs_debug(ps, depth, desc, "smb_io_unistr3");
1777         depth++;
1778
1779         if(!prs_align(ps))
1780                 return False;
1781
1782         if(!prs_uint32("uni_str_len", ps, depth, &name->uni_str_len))
1783                 return False;
1784
1785         /* we're done if there is no string */
1786
1787         if ( name->uni_str_len == 0 )
1788                 return True;
1789
1790         /* don't know if len is specified by uni_str_len member... */
1791         /* assume unicode string is unicode-null-terminated, instead */
1792
1793         if(!prs_unistr3(True, "unistr", name, ps, depth))
1794                 return False;
1795
1796         return True;
1797 }
1798
1799 /*******************************************************************
1800  Stream a uint64_struct
1801  ********************************************************************/
1802 BOOL prs_uint64(const char *name, prs_struct *ps, int depth, uint64 *data64)
1803 {
1804         if (UNMARSHALLING(ps)) {
1805                 uint32 high, low;
1806
1807                 if (!prs_uint32(name, ps, depth+1, &low))
1808                         return False;
1809
1810                 if (!prs_uint32(name, ps, depth+1, &high))
1811                         return False;
1812
1813                 *data64 = ((uint64_t)high << 32) + low;
1814
1815                 return True;
1816         } else {
1817                 uint32 high = (*data64) >> 32, low = (*data64) & 0xFFFFFFFF;
1818                 return prs_uint32(name, ps, depth+1, &low) &&
1819                            prs_uint32(name, ps, depth+1, &high);
1820         }
1821 }
1822
1823 /*******************************************************************
1824 reads or writes a BUFHDR2 structure.
1825 ********************************************************************/
1826 BOOL smb_io_bufhdr2(const char *desc, BUFHDR2 *hdr, prs_struct *ps, int depth)
1827 {
1828         prs_debug(ps, depth, desc, "smb_io_bufhdr2");
1829         depth++;
1830
1831         prs_align(ps);
1832         prs_uint32("info_level", ps, depth, &(hdr->info_level));
1833         prs_uint32("length    ", ps, depth, &(hdr->length    ));
1834         prs_uint32("buffer    ", ps, depth, &(hdr->buffer    ));
1835
1836         return True;
1837 }
1838
1839 /*******************************************************************
1840 reads or writes a BUFHDR4 structure.
1841 ********************************************************************/
1842 BOOL smb_io_bufhdr4(const char *desc, BUFHDR4 *hdr, prs_struct *ps, int depth)
1843 {
1844         prs_debug(ps, depth, desc, "smb_io_bufhdr4");
1845         depth++;
1846
1847         prs_align(ps);
1848         prs_uint32("size", ps, depth, &hdr->size);
1849         prs_uint32("buffer", ps, depth, &hdr->buffer);
1850
1851         return True;
1852 }
1853
1854 /*******************************************************************
1855 reads or writes a RPC_DATA_BLOB structure.
1856 ********************************************************************/
1857
1858 BOOL smb_io_rpc_blob(const char *desc, RPC_DATA_BLOB *blob, prs_struct *ps, int depth)
1859 {
1860         prs_debug(ps, depth, desc, "smb_io_rpc_blob");
1861         depth++;
1862
1863         prs_align(ps);
1864         if ( !prs_uint32("buf_len", ps, depth, &blob->buf_len) )
1865                 return False;
1866
1867         if ( blob->buf_len == 0 )
1868                 return True;
1869
1870         if (UNMARSHALLING(ps)) {
1871                 blob->buffer = PRS_ALLOC_MEM(ps, uint8, blob->buf_len);
1872                 if (!blob->buffer) {
1873                         return False;
1874                 }
1875         }
1876
1877         if ( !prs_uint8s(True, "buffer", ps, depth, blob->buffer, blob->buf_len) )
1878                 return False;
1879
1880         return True;
1881 }
1882
1883 /*******************************************************************
1884 creates a UNIHDR structure.
1885 ********************************************************************/
1886
1887 BOOL make_uni_hdr(UNIHDR *hdr, int len)
1888 {
1889         if (hdr == NULL)
1890         {
1891                 return False;
1892         }
1893         hdr->uni_str_len = 2 * len;
1894         hdr->uni_max_len = 2 * len;
1895         hdr->buffer      = len != 0 ? 1 : 0;
1896
1897         return True;
1898 }
1899
1900 /*******************************************************************
1901 creates a BUFHDR2 structure.
1902 ********************************************************************/
1903 BOOL make_bufhdr2(BUFHDR2 *hdr, uint32 info_level, uint32 length, uint32 buffer)
1904 {
1905         hdr->info_level = info_level;
1906         hdr->length     = length;
1907         hdr->buffer     = buffer;
1908
1909         return True;
1910 }
1911
1912 /*******************************************************************
1913 return the length of a UNISTR string.
1914 ********************************************************************/
1915
1916 uint32 str_len_uni(UNISTR *source)
1917 {
1918         uint32 i=0;
1919
1920         if (!source->buffer)
1921                 return 0;
1922
1923         while (source->buffer[i])
1924                 i++;
1925
1926         return i;
1927 }
1928
1929