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