source/rpc_parse/parse_misc.c

   1
   2 /*
   3  *  Unix SMB/Netbios implementation.
   4  *  Version 1.9.
   5  *  RPC Pipe client / server routines
   6  *  Copyright (C) Andrew Tridgell              1992-1997,
   7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   8  *  Copyright (C) Paul Ashton                       1997.
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25
  26 #include "includes.h"
  27
  28 extern int DEBUGLEVEL;
  29
  30
  31 /*******************************************************************
  32 reads or writes a BIGINT structure.
  33 ********************************************************************/
  34 BOOL smb_io_bigint(char *desc, BIGINT *bigint, prs_struct *ps, int depth)
  35 {
  36         if (bigint == NULL) return False;
  37
  38         prs_debug(ps, depth, desc, "smb_io_bigint");
  39         depth++;
  40
  41         prs_align(ps);
  42
  43         prs_uint32("low ", ps, depth, &(bigint->low ));
  44         prs_uint32("high", ps, depth, &(bigint->high));
  45
  46         return True;
  47 }
  48
  49 /*******************************************************************
  50 reads or writes a UTIME type.
  51 ********************************************************************/
  52 static BOOL smb_io_utime(char *desc,  UTIME *t, prs_struct *ps, int depth)
  53 {
  54         if (t == NULL) return False;
  55
  56         prs_debug(ps, depth, desc, "smb_io_utime");
  57         depth++;
  58
  59         prs_align(ps);
  60
  61         prs_uint32 ("time", ps, depth, &(t->time));
  62
  63         return True;
  64 }
  65
  66 /*******************************************************************
  67 reads or writes an NTTIME structure.
  68 ********************************************************************/
  69 BOOL smb_io_time(char *desc,  NTTIME *nttime, prs_struct *ps, int depth)
  70 {
  71         if (nttime == NULL) return False;
  72
  73         prs_debug(ps, depth, desc, "smb_io_time");
  74         depth++;
  75
  76         prs_align(ps);
  77
  78         prs_uint32("low ", ps, depth, &(nttime->low )); /* low part */
  79         prs_uint32("high", ps, depth, &(nttime->high)); /* high part */
  80
  81         return True;
  82 }
  83
  84 /*******************************************************************
  85 reads or writes a LOOKUP_LEVEL structure.
  86 ********************************************************************/
  87 BOOL smb_io_lookup_level(char *desc, LOOKUP_LEVEL *level, prs_struct *ps, int depth)
  88 {
  89         if (level == NULL) return False;
  90
  91         prs_debug(ps, depth, desc, "smb_io_lookup_level");
  92         depth++;
  93
  94         prs_align(ps);
  95         prs_uint16("value", ps, depth, &(level->value));
  96         prs_align(ps);
  97
  98         return True;
  99 }
 100
 101 /*******************************************************************
 102 gets an enumeration handle from an ENUM_HND structure.
 103 ********************************************************************/
 104 uint32 get_enum_hnd(ENUM_HND *enh)
 105 {
 106         return (enh && enh->ptr_hnd != 0) ? enh->handle : 0;
 107
 108         return True;
 109 }
 110
 111 /*******************************************************************
 112 makes an ENUM_HND structure.
 113 ********************************************************************/
 114 BOOL make_enum_hnd(ENUM_HND *enh, uint32 hnd)
 115 {
 116         if (enh == NULL) return False;
 117
 118         DEBUG(5,("smb_io_enum_hnd\n"));
 119
 120         enh->ptr_hnd = (hnd != 0) ? 1 : 0;
 121         enh->handle = hnd;
 122
 123         return True;
 124 }
 125
 126 /*******************************************************************
 127 reads or writes an ENUM_HND structure.
 128 ********************************************************************/
 129 BOOL smb_io_enum_hnd(char *desc,  ENUM_HND *hnd, prs_struct *ps, int depth)
 130 {
 131         if (hnd == NULL) return False;
 132
 133         prs_debug(ps, depth, desc, "smb_io_enum_hnd");
 134         depth++;
 135
 136         prs_align(ps);
 137
 138         prs_uint32("ptr_hnd", ps, depth, &(hnd->ptr_hnd)); /* pointer */
 139         if (hnd->ptr_hnd != 0)
 140         {
 141                 prs_uint32("handle ", ps, depth, &(hnd->handle )); /* enum handle */
 142         }
 143
 144         return True;
 145 }
 146
 147 /*******************************************************************
 148 reads or writes a DOM_SID structure.
 149 ********************************************************************/
 150 BOOL smb_io_dom_sid(char *desc,  DOM_SID *sid, prs_struct *ps, int depth)
 151 {
 152         int i;
 153
 154         if (sid == NULL) return False;
 155
 156         prs_debug(ps, depth, desc, "smb_io_dom_sid");
 157         depth++;
 158
 159         prs_align(ps);
 160
 161         prs_uint8 ("sid_rev_num", ps, depth, &(sid->sid_rev_num));
 162         prs_uint8 ("num_auths  ", ps, depth, &(sid->num_auths));
 163
 164         for (i = 0; i < 6; i++)
 165         {
 166                 fstring tmp;
 167                 slprintf(tmp, sizeof(tmp) - 1, "id_auth[%d] ", i);
 168                 prs_uint8 (tmp, ps, depth, &(sid->id_auth[i]));
 169         }
 170
 171         /* oops! XXXX should really issue a warning here... */
 172         if (sid->num_auths > MAXSUBAUTHS) sid->num_auths = MAXSUBAUTHS;
 173
 174         prs_uint32s(False, "sub_auths ", ps, depth, sid->sub_auths, sid->num_auths);
 175
 176         return True;
 177 }
 178
 179 /*******************************************************************
 180 creates a DOM_SID2 structure.
 181 ********************************************************************/
 182 BOOL make_dom_sid2(DOM_SID2 *sid2, const DOM_SID *sid)
 183 {
 184         sid_copy(&sid2->sid, sid);
 185         sid2->num_auths = sid2->sid.num_auths;
 186
 187         return True;
 188 }
 189
 190 /*******************************************************************
 191 reads or writes a DOM_SID2 structure.
 192 ********************************************************************/
 193 BOOL smb_io_dom_sid2(char *desc,  DOM_SID2 *sid, prs_struct *ps, int depth)
 194 {
 195         if (sid == NULL) return False;
 196
 197         prs_debug(ps, depth, desc, "smb_io_dom_sid2");
 198         depth++;
 199
 200         prs_align(ps);
 201
 202         prs_uint32("num_auths", ps, depth, &(sid->num_auths));
 203
 204         smb_io_dom_sid("sid", &(sid->sid), ps, depth);
 205
 206         return True;
 207 }
 208
 209 /*******************************************************************
 210 creates a STRHDR structure.
 211 ********************************************************************/
 212 BOOL make_str_hdr(STRHDR *hdr, int max_len, int len, uint32 buffer)
 213 {
 214         hdr->str_max_len = max_len;
 215         hdr->str_str_len = len;
 216         hdr->buffer      = buffer;
 217
 218         return True;
 219 }
 220
 221 /*******************************************************************
 222 reads or writes a STRHDR structure.
 223 ********************************************************************/
 224 BOOL smb_io_strhdr(char *desc,  STRHDR *hdr, prs_struct *ps, int depth)
 225 {
 226         if (hdr == NULL) return False;
 227
 228         prs_debug(ps, depth, desc, "smb_io_strhdr");
 229         depth++;
 230
 231         prs_align(ps);
 232
 233         prs_uint16("str_str_len", ps, depth, &(hdr->str_str_len));
 234         prs_uint16("str_max_len", ps, depth, &(hdr->str_max_len));
 235         prs_uint32("buffer     ", ps, depth, &(hdr->buffer     ));
 236
 237         /* oops! XXXX maybe issue a warning that this is happening... */
 238         if (hdr->str_max_len > MAX_STRINGLEN) hdr->str_max_len = MAX_STRINGLEN;
 239         if (hdr->str_str_len > MAX_STRINGLEN) hdr->str_str_len = MAX_STRINGLEN;
 240
 241         return True;
 242 }
 243
 244 /*******************************************************************
 245 creates a STRHDR2 structure.
 246 ********************************************************************/
 247 BOOL make_strhdr2(STRHDR2 *hdr, uint32 max_len, uint32 len, uint32 buffer)
 248 {
 249         hdr->str_max_len = max_len;
 250         hdr->str_str_len = len;
 251         hdr->buffer      = buffer;
 252
 253         return True;
 254 }
 255
 256 /*******************************************************************
 257 reads or writes a STRHDR2 structure.
 258 ********************************************************************/
 259 BOOL smb_io_strhdr2(char *desc, STRHDR2 *hdr, prs_struct *ps, int depth)
 260 {
 261         if (hdr == NULL) return False;
 262
 263         prs_debug(ps, depth, desc, "smb_io_strhdr");
 264         depth++;
 265
 266         prs_align(ps);
 267
 268         prs_uint32("str_str_len", ps, depth, &(hdr->str_str_len));
 269         prs_uint32("str_max_len", ps, depth, &(hdr->str_max_len));
 270         prs_uint32("buffer     ", ps, depth, &(hdr->buffer     ));
 271
 272         /* oops! XXXX maybe issue a warning that this is happening... */
 273         if (hdr->str_max_len > MAX_STRINGLEN) hdr->str_max_len = MAX_STRINGLEN;
 274         if (hdr->str_str_len > MAX_STRINGLEN) hdr->str_str_len = MAX_STRINGLEN;
 275
 276         return True;
 277 }
 278
 279 /*******************************************************************
 280 creates a UNIHDR structure.
 281 ********************************************************************/
 282 BOOL make_uni_hdr(UNIHDR *hdr, int len)
 283 {
 284         if (hdr == NULL)
 285         {
 286                 return False;
 287         }
 288         hdr->uni_str_len = 2 * len;
 289         hdr->uni_max_len = 2 * len;
 290         hdr->buffer      = len != 0 ? 1 : 0;
 291
 292         return True;
 293 }
 294
 295 /*******************************************************************
 296 creates a UNIHDR structure from a UNISTR2.
 297 ********************************************************************/
 298 BOOL make_unihdr_from_unistr2(UNIHDR *hdr, const UNISTR2 *str)
 299 {
 300         int len;
 301
 302         len = (str ? str->uni_str_len : 0);
 303
 304         return make_uni_hdr(hdr, len);
 305 }
 306
 307 /*******************************************************************
 308 reads or writes a UNIHDR structure.
 309 ********************************************************************/
 310 BOOL smb_io_unihdr(char *desc,  UNIHDR *hdr, prs_struct *ps, int depth)
 311 {
 312         if (hdr == NULL) return False;
 313
 314         prs_debug(ps, depth, desc, "smb_io_unihdr");
 315         depth++;
 316
 317         prs_align(ps);
 318
 319         prs_uint16("uni_str_len", ps, depth, &(hdr->uni_str_len));
 320         prs_uint16("uni_max_len", ps, depth, &(hdr->uni_max_len));
 321         prs_uint32("buffer     ", ps, depth, &(hdr->buffer     ));
 322
 323         /* oops! XXXX maybe issue a warning that this is happening... */
 324         if (hdr->uni_max_len > MAX_UNISTRLEN) hdr->uni_max_len = MAX_UNISTRLEN;
 325         if (hdr->uni_str_len > MAX_UNISTRLEN) hdr->uni_str_len = MAX_UNISTRLEN;
 326
 327         return True;
 328 }
 329
 330 /*******************************************************************
 331 creates a BUFHDR structure.
 332 ********************************************************************/
 333 BOOL make_buf_hdr(BUFHDR *hdr, int max_len, int len)
 334 {
 335         hdr->buf_max_len = max_len;
 336         hdr->buf_len     = len;
 337
 338         return True;
 339 }
 340
 341 /*******************************************************************
 342  prs_uint16 wrapper.  call this and it sets up a pointer to where the
 343  uint16 should be stored, or gets the size if reading
 344  ********************************************************************/
 345 BOOL smb_io_hdrbuf_pre(char *desc,  BUFHDR *hdr, prs_struct *ps, int depth, uint32 *offset)
 346 {
 347         (*offset) = ps->offset;
 348         if (ps->io)
 349         {
 350                 /* reading. */
 351                 smb_io_hdrbuf(desc, hdr, ps, depth);
 352         }
 353         else
 354         {
 355                 ps->offset += sizeof(uint32) * 2;
 356         }
 357
 358         return True;
 359 }
 360
 361 /*******************************************************************
 362  smb_io_hdrbuf wrapper.  call this and it retrospectively stores the size.
 363  does nothing on reading, as that is already handled by ...._pre()
 364  ********************************************************************/
 365 BOOL smb_io_hdrbuf_post(char *desc,  BUFHDR *hdr, prs_struct *ps, int depth,
 366                                 uint32 ptr_hdrbuf, uint32 max_len, uint32 len)
 367 {
 368         if (!ps->io)
 369         {
 370                 /* storing: go back and do a retrospective job.  i hate this */
 371                 uint32 old_offset = ps->offset;
 372
 373                 make_buf_hdr(hdr, max_len, len);
 374                 ps->offset = ptr_hdrbuf;
 375                 smb_io_hdrbuf(desc, hdr, ps, depth);
 376                 ps->offset = old_offset;
 377         }
 378
 379         return True;
 380 }
 381
 382 /*******************************************************************
 383 reads or writes a BUFHDR structure.
 384 ********************************************************************/
 385 BOOL smb_io_hdrbuf(char *desc,  BUFHDR *hdr, prs_struct *ps, int depth)
 386 {
 387         if (hdr == NULL) return False;
 388
 389         prs_debug(ps, depth, desc, "smb_io_hdrbuf");
 390         depth++;
 391
 392         prs_align(ps);
 393
 394         prs_uint32("buf_max_len", ps, depth, &(hdr->buf_max_len));
 395         prs_uint32("buf_len    ", ps, depth, &(hdr->buf_len    ));
 396
 397         /* oops! XXXX maybe issue a warning that this is happening... */
 398         if (hdr->buf_max_len > MAX_BUFFERLEN) hdr->buf_max_len = MAX_BUFFERLEN;
 399         if (hdr->buf_len     > MAX_BUFFERLEN) hdr->buf_len     = MAX_BUFFERLEN;
 400
 401         return True;
 402 }
 403
 404 /*******************************************************************
 405 creates a BUFHDR2 structure.
 406 ********************************************************************/
 407 BOOL make_bufhdr2(BUFHDR2 *hdr, uint32 info_level, uint32 length, uint32 buffer)
 408 {
 409         hdr->info_level = info_level;
 410         hdr->length     = length;
 411         hdr->buffer     = buffer;
 412
 413         return True;
 414 }
 415
 416 /*******************************************************************
 417 reads or writes a BUFHDR2 structure.
 418 ********************************************************************/
 419 BOOL smb_io_bufhdr2(char *desc, BUFHDR2 *hdr, prs_struct *ps, int depth)
 420 {
 421         if (hdr == NULL) return False;
 422
 423         prs_debug(ps, depth, desc, "smb_io_bufhdr2");
 424         depth++;
 425
 426         prs_align(ps);
 427         prs_uint32("info_level", ps, depth, &(hdr->info_level));
 428         prs_uint32("length    ", ps, depth, &(hdr->length    ));
 429         prs_uint32("buffer    ", ps, depth, &(hdr->buffer    ));
 430
 431         return True;
 432 }
 433
 434 /*******************************************************************
 435 creates a UNIHDR2 structure.
 436 ********************************************************************/
 437 BOOL make_uni_hdr2(UNIHDR2 *hdr, int len)
 438 {
 439         if (hdr == NULL)
 440         {
 441                 return False;
 442         }
 443         make_uni_hdr(&(hdr->unihdr), len);
 444         hdr->buffer = len > 0 ? 1 : 0;
 445
 446         return True;
 447 }
 448
 449 /*******************************************************************
 450 creates a UNIHDR2 structure from a UNISTR2.
 451 ********************************************************************/
 452 BOOL make_unihdr2_from_unistr2(UNIHDR2 *hdr, const UNISTR2 *str)
 453 {
 454         int len;
 455
 456         len = (str ? str->uni_str_len : 0);
 457
 458         return make_uni_hdr2(hdr, len);
 459 }
 460
 461 /*******************************************************************
 462 reads or writes a UNIHDR2 structure.
 463 ********************************************************************/
 464 BOOL smb_io_unihdr2(char *desc,  UNIHDR2 *hdr2, prs_struct *ps, int depth)
 465 {
 466         if (hdr2 == NULL) return False;
 467
 468         prs_debug(ps, depth, desc, "smb_io_unihdr2");
 469         depth++;
 470
 471         prs_align(ps);
 472
 473         smb_io_unihdr("hdr", &(hdr2->unihdr), ps, depth);
 474         prs_uint32("buffer", ps, depth, &(hdr2->buffer));
 475
 476         return True;
 477 }
 478
 479 /*******************************************************************
 480 creates a UNISTR structure.
 481 ********************************************************************/
 482 BOOL make_unistr(UNISTR *str, char *buf)
 483 {
 484         ascii_to_unistr(str->buffer, buf, sizeof(str->buffer)-1);
 485
 486         return True;
 487 }
 488
 489 /*******************************************************************
 490 reads or writes a UNISTR structure.
 491 XXXX NOTE: UNISTR structures NEED to be null-terminated.
 492 ********************************************************************/
 493 BOOL smb_io_unistr(char *desc,  UNISTR *uni, prs_struct *ps, int depth)
 494 {
 495         if (uni == NULL) return False;
 496
 497         prs_debug(ps, depth, desc, "smb_io_unistr");
 498         depth++;
 499
 500         prs_unistr("unistr", ps, depth, uni);
 501
 502         return True;
 503 }
 504
 505 /*******************************************************************
 506 creates a BUFFER3 structure from a uint32
 507 ********************************************************************/
 508 BOOL make_buffer3_uint32(BUFFER3 *str, uint32 val)
 509 {
 510         ZERO_STRUCTP(str);
 511
 512         /* set up string lengths. */
 513         str->buf_max_len = sizeof(uint32);
 514         str->buf_len     = sizeof(uint32);
 515
 516         SIVAL(str->buffer, 0, val);
 517
 518         return True;
 519 }
 520
 521 /*******************************************************************
 522 creates a BUFFER3 structure.
 523 ********************************************************************/
 524 BOOL make_buffer3_str(BUFFER3 *str, const char *buf, int len)
 525 {
 526         ZERO_STRUCTP(str);
 527
 528         /* set up string lengths. */
 529         str->buf_max_len = len * 2;
 530         str->buf_len     = len * 2;
 531
 532         /* store the string (little endian buffer) */
 533         ascii_to_unibuf((char*)str->buffer, buf, str->buf_len);
 534
 535         return True;
 536 }
 537
 538 /*******************************************************************
 539 creates a BUFFER3 structure from a hex string.
 540 ********************************************************************/
 541 BOOL make_buffer3_hex(BUFFER3 *str, char *buf)
 542 {
 543         ZERO_STRUCTP(str);
 544         str->buf_max_len = str->buf_len = strhex_to_str((char *)str->buffer, sizeof(str->buffer), buf);
 545
 546         return True;
 547 }
 548
 549 /*******************************************************************
 550 creates a BUFFER3 structure.
 551 ********************************************************************/
 552 BOOL make_buffer3_bytes(BUFFER3 *str, uint8 *buf, int len)
 553 {
 554         ZERO_STRUCTP(str);
 555
 556         /* max buffer size (allocated size) */
 557         str->buf_max_len = len;
 558         if (buf != NULL)
 559         {
 560                 memcpy(str->buffer, buf, MIN(str->buf_len, sizeof(str->buffer)));
 561         }
 562         str->buf_len = buf != NULL ? len : 0;
 563
 564         return True;
 565 }
 566
 567 /*******************************************************************
 568 reads or writes a BUFFER3 structure.
 569      the uni_max_len member tells you how large the buffer is.
 570      the uni_str_len member tells you how much of the buffer is really used.
 571 ********************************************************************/
 572 BOOL smb_io_buffer3(char *desc,  BUFFER3 *buf3, prs_struct *ps, int depth)
 573 {
 574         if (buf3 == NULL) return False;
 575
 576         prs_debug(ps, depth, desc, "smb_io_buffer3");
 577         depth++;
 578
 579         prs_align(ps);
 580
 581         prs_uint32("uni_max_len", ps, depth, &(buf3->buf_max_len));
 582         if (buf3->buf_max_len > MAX_UNISTRLEN) buf3->buf_max_len = MAX_UNISTRLEN;
 583
 584         prs_uint8s(True, "buffer     ", ps, depth, buf3->buffer, buf3->buf_max_len);
 585
 586         prs_uint32("buf_len    ", ps, depth, &(buf3->buf_len));
 587         if (buf3->buf_len     > MAX_UNISTRLEN) buf3->buf_len     = MAX_UNISTRLEN;
 588
 589         return True;
 590 }
 591
 592 /*******************************************************************
 593 creates a BUFFER4 structure.
 594 ********************************************************************/
 595 BOOL make_buffer4_str(BUFFER4 *str, const char *buf, int len)
 596 {
 597         ZERO_STRUCTP(str);
 598
 599         /* set up string lengths. */
 600         str->buf_len     = len * 2;
 601
 602         /* store the string (little endian buffer) */
 603         ascii_to_unibuf((char*)str->buffer, buf, str->buf_len);
 604
 605         return True;
 606 }
 607
 608 /*******************************************************************
 609 reads or writes a BUFFER4 structure.
 610 ********************************************************************/
 611 BOOL smb_io_buffer4(char *desc, BUFFER4 *buf4, uint32 buffer, prs_struct *ps, int depth)
 612 {
 613         if ((buf4 == NULL) || (buffer == 0)) return False;
 614
 615         prs_debug(ps, depth, desc, "smb_io_buffer4");
 616         depth++;
 617
 618         prs_align(ps);
 619         prs_uint32("buf_len", ps, depth, &(buf4->buf_len));
 620
 621         if (buf4->buf_len > MAX_BUFFERLEN)
 622         {
 623                 buf4->buf_len = MAX_BUFFERLEN;
 624         }
 625
 626         prs_uint8s(True, "buffer", ps, depth, buf4->buffer, buf4->buf_len);
 627
 628         return True;
 629 }
 630
 631 /*******************************************************************
 632 initialise a BUFFER5 structure.
 633 ********************************************************************/
 634 BOOL init_buffer5(BUFFER5 **str)
 635 {
 636         BUFFER5 *buf5;
 637
 638         buf5=(BUFFER5 *)malloc( sizeof(BUFFER5) );
 639
 640         buf5->buf_len=0;
 641         buf5->buffer=NULL;
 642         *str=buf5;
 643
 644         return True;
 645 }
 646
 647 /*******************************************************************
 648 clear a BUFFER5 structure.
 649 ********************************************************************/
 650 BOOL clear_buffer5(BUFFER5 **str)
 651 {
 652         BUFFER5 *buf5;
 653
 654         buf5=*str;
 655         if (buf5->buffer != NULL )
 656         {
 657                 free(buf5->buffer);
 658         }
 659         free(buf5);
 660         *str=NULL;
 661
 662         return True;
 663 }
 664
 665 /*******************************************************************
 666 creates a BUFFER5 structure.
 667 ********************************************************************/
 668 BOOL make_buffer5(BUFFER5 *str, char *buf, int len)
 669 {
 670
 671         /* max buffer size (allocated size) */
 672         str->buf_len = len;
 673         str->buffer = (uint16 *)malloc( sizeof(uint16) * len );
 674         ascii_to_unistr(str->buffer, buf, len);
 675
 676         return True;
 677 }
 678
 679 /*******************************************************************
 680 reads or writes a BUFFER5 structure.
 681 the buf_len member tells you how large the buffer is.
 682 ********************************************************************/
 683 BOOL smb_io_buffer5(char *desc, BUFFER5 *buf5, prs_struct *ps, int depth)
 684 {
 685         prs_debug(ps, depth, desc, "smb_io_buffer4");
 686         depth++;
 687
 688         if (buf5 == NULL) return False;
 689
 690         prs_align(ps);
 691         prs_uint32("buf_len", ps, depth, &(buf5->buf_len));
 692
 693         /* reading: alloc the buffer first */
 694         if ( ps->io )
 695         {
 696                 buf5->buffer=(uint16 *)malloc( sizeof(uint16)*buf5->buf_len );
 697         }
 698
 699         prs_uint16s(True, "buffer     ", ps, depth, buf5->buffer, buf5->buf_len);
 700
 701         return True;
 702 }
 703
 704 /*******************************************************************
 705 creates a BUFFER2 structure.
 706 ********************************************************************/
 707 BOOL make_buffer2_multi(BUFFER2 *str, char *const* const buf, uint32 num)
 708 {
 709         int i;
 710         char *dest = (char*)str->buffer;
 711         size_t max_len = sizeof(str->buffer)-1;
 712
 713         ZERO_STRUCTP(str);
 714
 715         str->buf_max_len = 0;
 716         str->undoc       = 0;
 717
 718         for (i = 0; i < num && max_len > 0; i++)
 719         {
 720                 size_t len = buf[i] != NULL ? strlen(buf[i]) : 0;
 721
 722                 str->buf_max_len += len * 2;
 723                 str->buf_len     += len * 2;
 724
 725                 ascii_to_unibuf(dest, buf[i], max_len);
 726
 727                 dest += len * 2 + 2;
 728                 max_len -= len * 2 + 2;
 729         }
 730
 731         return True;
 732 }
 733
 734 /*******************************************************************
 735 creates a BUFFER2 structure.
 736 ********************************************************************/
 737 BOOL make_buffer2(BUFFER2 *str, const char *buf, int len)
 738 {
 739         ZERO_STRUCTP(str);
 740
 741         /* set up string lengths. */
 742         str->buf_max_len = str->buf_len = len * 2;
 743         str->undoc       = 0;
 744
 745         /* store the string */
 746         ascii_to_unibuf((char*)str->buffer, buf,
 747                          MIN(str->buf_len, sizeof(str->buffer)-1));
 748
 749         return True;
 750 }
 751
 752 /*******************************************************************
 753 reads or writes a BUFFER2 structure.
 754      the uni_max_len member tells you how large the buffer is.
 755      the uni_str_len member tells you how much of the buffer is really used.
 756 ********************************************************************/
 757 BOOL smb_io_buffer2(char *desc,  BUFFER2 *buf2, uint32 buffer, prs_struct *ps, int depth)
 758 {
 759         if (buf2 == NULL) return False;
 760
 761         if (buffer)
 762         {
 763                 prs_debug(ps, depth, desc, "smb_io_buffer2");
 764                 depth++;
 765
 766                 prs_align(ps);
 767
 768                 prs_uint32("buf_max_len", ps, depth, &(buf2->buf_max_len));
 769                 prs_uint32("undoc      ", ps, depth, &(buf2->undoc      ));
 770                 prs_uint32("buf_len    ", ps, depth, &(buf2->buf_len));
 771
 772                 /* oops! XXXX maybe issue a warning that this is happening... */
 773                 if (buf2->buf_max_len > MAX_UNISTRLEN) buf2->buf_max_len = MAX_UNISTRLEN;
 774                 if (buf2->buf_len     > MAX_UNISTRLEN) buf2->buf_len     = MAX_UNISTRLEN;
 775
 776                 /* buffer advanced by indicated length of string
 777                    NOT by searching for null-termination */
 778                 prs_buffer2(True, "buffer     ", ps, depth, buf2);
 779         }
 780         else
 781         {
 782                 prs_debug(ps, depth, desc, "smb_io_buffer2 - NULL");
 783                 depth++;
 784                 bzero(buf2, sizeof(*buf2));
 785         }
 786
 787         return True;
 788 }
 789
 790 /*******************************************************************
 791 creates a UNISTR2 structure: sets up the buffer, too
 792 ********************************************************************/
 793 BOOL make_buf_unistr2(UNISTR2 *str, uint32 *ptr, const char *buf)
 794 {
 795         if (buf != NULL)
 796         {
 797                 *ptr = 1;
 798                 make_unistr2(str, buf, strlen(buf)+1);
 799         }
 800         else
 801         {
 802                 *ptr = 0;
 803                 make_unistr2(str, "", 0);
 804         }
 805
 806         return True;
 807 }
 808
 809 /*******************************************************************
 810 creates a STRING2 structure.
 811 ********************************************************************/
 812 BOOL make_string2(STRING2 *str, const char *buf, int len)
 813 {
 814         ZERO_STRUCTP(str);
 815
 816         /* set up string lengths. */
 817         str->str_max_len = len;
 818         str->undoc       = 0;
 819         str->str_str_len = len;
 820
 821         /* store the string */
 822         if(len != 0)
 823         {
 824                 memcpy(str->buffer, buf, len);
 825         }
 826
 827         return True;
 828 }
 829
 830 /*******************************************************************
 831 creates a STRING2 structure: sets up the buffer, too
 832 ********************************************************************/
 833 BOOL make_buf_string2(STRING2 *str, uint32 *ptr, const char *buf)
 834 {
 835         if (buf != NULL)
 836         {
 837                 *ptr = 1;
 838                 make_string2(str, buf, strlen(buf)+1);
 839         }
 840         else
 841         {
 842                 *ptr = 0;
 843                 make_string2(str, "", 0);
 844         }
 845
 846         return True;
 847 }
 848
 849 /*******************************************************************
 850 reads or writes a STRING2 structure.
 851 XXXX NOTE: STRING2 structures need NOT be null-terminated.
 852      the str_str_len member tells you how long the string is;
 853      the str_max_len member tells you how large the buffer is.
 854 ********************************************************************/
 855 BOOL smb_io_string2(char *desc,  STRING2 *str2, uint32 buffer, prs_struct *ps, int depth)
 856 {
 857         if (str2 == NULL) return False;
 858
 859         if (buffer)
 860         {
 861                 prs_debug(ps, depth, desc, "smb_io_string2");
 862                 depth++;
 863
 864                 prs_align(ps);
 865
 866                 prs_uint32("str_max_len", ps, depth, &(str2->str_max_len));
 867                 prs_uint32("undoc      ", ps, depth, &(str2->undoc      ));
 868                 prs_uint32("str_str_len", ps, depth, &(str2->str_str_len));
 869
 870                 /* oops! XXXX maybe issue a warning that this is happening... */
 871                 if (str2->str_max_len > MAX_STRINGLEN) str2->str_max_len = MAX_STRINGLEN;
 872                 if (str2->str_str_len > MAX_STRINGLEN) str2->str_str_len = MAX_STRINGLEN;
 873
 874                 /* buffer advanced by indicated length of string
 875                    NOT by searching for null-termination */
 876                 prs_string2(True, "buffer     ", ps, depth, str2);
 877         }
 878         else
 879         {
 880                 prs_debug(ps, depth, desc, "smb_io_string2 - NULL");
 881                 depth++;
 882                 bzero(str2, sizeof(*str2));
 883         }
 884
 885         return True;
 886 }
 887
 888 /*******************************************************************
 889 creates a UNISTR2 structure.
 890 ********************************************************************/
 891 BOOL make_unistr2(UNISTR2 *str, const char *buf, int len)
 892 {
 893         unistr2_assign_ascii(str, buf, len);
 894
 895         return True;
 896 }
 897
 898 /*******************************************************************
 899 reads or writes a UNISTR2 structure.
 900 XXXX NOTE: UNISTR2 structures need NOT be null-terminated.
 901      the uni_str_len member tells you how long the string is;
 902      the uni_max_len member tells you how large the buffer is.
 903 ********************************************************************/
 904 BOOL smb_io_unistr2(char *desc,  UNISTR2 *uni2, uint32 buffer, prs_struct *ps, int depth)
 905 {
 906         if (uni2 == NULL) return False;
 907
 908         if (buffer)
 909         {
 910                 prs_debug(ps, depth, desc, "smb_io_unistr2");
 911                 depth++;
 912
 913                 prs_align(ps);
 914
 915                 prs_uint32("uni_max_len", ps, depth, &(uni2->uni_max_len));
 916                 prs_uint32("undoc      ", ps, depth, &(uni2->undoc      ));
 917                 prs_uint32("uni_str_len", ps, depth, &(uni2->uni_str_len));
 918
 919                 /* oops! XXXX maybe issue a warning that this is happening... */
 920                 if (uni2->uni_max_len > MAX_UNISTRLEN) uni2->uni_max_len = MAX_UNISTRLEN;
 921                 if (uni2->uni_str_len > MAX_UNISTRLEN) uni2->uni_str_len = MAX_UNISTRLEN;
 922
 923                 /* buffer advanced by indicated length of string
 924                    NOT by searching for null-termination */
 925                 prs_unistr2(True, "buffer     ", ps, depth, uni2);
 926         }
 927         else
 928         {
 929                 prs_debug(ps, depth, desc, "smb_io_unistr2 - NULL");
 930                 depth++;
 931                 bzero(uni2, sizeof(*uni2));
 932         }
 933
 934         return True;
 935 }
 936
 937 /*******************************************************************
 938 creates a DOM_RID2 structure.
 939 ********************************************************************/
 940 BOOL make_dom_rid2(DOM_RID2 *rid2, uint32 rid, uint8 type, uint32 idx)
 941 {
 942         rid2->type    = type;
 943         rid2->rid     = rid;
 944         rid2->rid_idx = idx;
 945
 946         return True;
 947 }
 948
 949 /*******************************************************************
 950 reads or writes a DOM_RID2 structure.
 951 ********************************************************************/
 952 BOOL smb_io_dom_rid2(char *desc,  DOM_RID2 *rid2, prs_struct *ps, int depth)
 953 {
 954         if (rid2 == NULL) return False;
 955
 956         prs_debug(ps, depth, desc, "smb_io_dom_rid2");
 957         depth++;
 958
 959         prs_align(ps);
 960
 961         prs_uint8("type   ", ps, depth, &(rid2->type));
 962         prs_align(ps);
 963         prs_uint32("rid    ", ps, depth, &(rid2->rid     ));
 964         prs_uint32("rid_idx", ps, depth, &(rid2->rid_idx ));
 965
 966         return True;
 967 }
 968
 969 /*******************************************************************
 970 creates a DOM_RID3 structure.
 971 ********************************************************************/
 972 BOOL make_dom_rid3(DOM_RID3 *rid3, uint32 rid, uint8 type)
 973 {
 974         rid3->rid      = rid;
 975         rid3->type1    = type;
 976         rid3->ptr_type = 0x1; /* non-zero, basically. */
 977         rid3->type2    = 0x1;
 978         rid3->unk      = type;
 979
 980         return True;
 981 }
 982
 983 /*******************************************************************
 984 reads or writes a DOM_RID3 structure.
 985 ********************************************************************/
 986 BOOL smb_io_dom_rid3(char *desc,  DOM_RID3 *rid3, prs_struct *ps, int depth)
 987 {
 988         if (rid3 == NULL) return False;
 989
 990         prs_debug(ps, depth, desc, "smb_io_dom_rid3");
 991         depth++;
 992
 993         prs_align(ps);
 994
 995         prs_uint32("rid     ", ps, depth, &(rid3->rid     ));
 996         prs_uint32("type1   ", ps, depth, &(rid3->type1   ));
 997         prs_uint32("ptr_type", ps, depth, &(rid3->ptr_type));
 998         prs_uint32("type2   ", ps, depth, &(rid3->type2   ));
 999         prs_uint32("unk     ", ps, depth, &(rid3->unk     ));
1000
1001         return True;
1002 }
1003
1004 /*******************************************************************
1005 makes a DOM_CLNT_SRV structure.
1006 ********************************************************************/
1007 static BOOL make_clnt_srv(DOM_CLNT_SRV *log,
1008                                 const char *logon_srv,
1009                                 const char *comp_name)
1010 {
1011         if (log == NULL) return False;
1012
1013         DEBUG(5,("make_clnt_srv: %d\n", __LINE__));
1014
1015         if (logon_srv != NULL)
1016         {
1017                 log->undoc_buffer = 1;
1018                 make_unistr2(&(log->uni_logon_srv), logon_srv, strlen(logon_srv)+1);
1019         }
1020         else
1021         {
1022                 log->undoc_buffer = 0;
1023         }
1024
1025         if (comp_name != NULL)
1026         {
1027                 log->undoc_buffer2 = 1;
1028                 make_unistr2(&(log->uni_comp_name), comp_name, strlen(comp_name)+1);
1029         }
1030         else
1031         {
1032                 log->undoc_buffer2 = 0;
1033         }
1034
1035         return True;
1036 }
1037
1038 /*******************************************************************
1039 reads or writes a DOM_CLNT_SRV structure.
1040 ********************************************************************/
1041 static BOOL smb_io_clnt_srv(char *desc,  DOM_CLNT_SRV *log, prs_struct *ps, int depth)
1042 {
1043         if (log == NULL) return False;
1044
1045         prs_debug(ps, depth, desc, "smb_io_clnt_srv");
1046         depth++;
1047
1048         prs_align(ps);
1049
1050         prs_uint32("undoc_buffer ", ps, depth, &(log->undoc_buffer ));
1051         if (log->undoc_buffer != 0)
1052         {
1053                 smb_io_unistr2("unistr2", &(log->uni_logon_srv), log->undoc_buffer, ps, depth);
1054         }
1055
1056         prs_align(ps);
1057
1058         prs_uint32("undoc_buffer2", ps, depth, &(log->undoc_buffer2));
1059         if (log->undoc_buffer2 != 0)
1060         {
1061                 smb_io_unistr2("unistr2", &(log->uni_comp_name), log->undoc_buffer2, ps, depth);
1062         }
1063
1064         return True;
1065 }
1066
1067 /*******************************************************************
1068 makes a DOM_LOG_INFO structure.
1069 ********************************************************************/
1070 BOOL make_log_info(DOM_LOG_INFO *log,
1071                 const char *logon_srv, const char *acct_name,
1072                 uint16 sec_chan, const char *comp_name)
1073 {
1074         if (log == NULL) return False;
1075
1076         DEBUG(5,("make_log_info %d\n", __LINE__));
1077
1078         log->undoc_buffer = 1;
1079
1080         make_unistr2(&(log->uni_logon_srv), logon_srv, strlen(logon_srv)+1);
1081         make_unistr2(&(log->uni_acct_name), acct_name, strlen(acct_name)+1);
1082
1083         log->sec_chan = sec_chan;
1084
1085         make_unistr2(&(log->uni_comp_name), comp_name, strlen(comp_name)+1);
1086
1087         return True;
1088 }
1089
1090 /*******************************************************************
1091 reads or writes a DOM_LOG_INFO structure.
1092 ********************************************************************/
1093 BOOL smb_io_log_info(char *desc,  DOM_LOG_INFO *log, prs_struct *ps, int depth)
1094 {
1095         if (log == NULL) return False;
1096
1097         prs_debug(ps, depth, desc, "smb_io_log_info");
1098         depth++;
1099
1100         prs_align(ps);
1101
1102         prs_uint32("undoc_buffer", ps, depth, &(log->undoc_buffer));
1103
1104         smb_io_unistr2("unistr2", &(log->uni_logon_srv), True, ps, depth);
1105         smb_io_unistr2("unistr2", &(log->uni_acct_name), True, ps, depth);
1106
1107         prs_uint16("sec_chan", ps, depth, &(log->sec_chan));
1108
1109         smb_io_unistr2("unistr2", &(log->uni_comp_name), True, ps, depth);
1110
1111         return True;
1112 }
1113
1114 /*******************************************************************
1115 reads or writes a DOM_CHAL structure.
1116 ********************************************************************/
1117 BOOL smb_io_chal(char *desc,  DOM_CHAL *chal, prs_struct *ps, int depth)
1118 {
1119         if (chal == NULL) return False;
1120
1121         prs_debug(ps, depth, desc, "smb_io_chal");
1122         depth++;
1123
1124         prs_align(ps);
1125
1126         prs_uint8s (False, "data", ps, depth, chal->data, 8);
1127
1128         return True;
1129 }
1130
1131 /*******************************************************************
1132 reads or writes a DOM_CRED structure.
1133 ********************************************************************/
1134 BOOL smb_io_cred(char *desc,  DOM_CRED *cred, prs_struct *ps, int depth)
1135 {
1136         if (cred == NULL) return False;
1137
1138         prs_debug(ps, depth, desc, "smb_io_cred");
1139         depth++;
1140
1141         prs_align(ps);
1142
1143         smb_io_chal ("", &(cred->challenge), ps, depth);
1144         smb_io_utime("", &(cred->timestamp), ps, depth);
1145
1146         return True;
1147 }
1148
1149 /*******************************************************************
1150 makes a DOM_CLNT_INFO2 structure.
1151 ********************************************************************/
1152 BOOL make_clnt_info2(DOM_CLNT_INFO2 *clnt,
1153                                 const char *logon_srv, const char *comp_name,
1154                                 DOM_CRED *clnt_cred)
1155 {
1156         if (clnt == NULL) return False;
1157
1158         DEBUG(5,("make_clnt_info: %d\n", __LINE__));
1159
1160         make_clnt_srv(&(clnt->login), logon_srv, comp_name);
1161
1162         if (clnt_cred != NULL)
1163         {
1164                 clnt->ptr_cred = 1;
1165                 memcpy(&(clnt->cred), clnt_cred, sizeof(clnt->cred));
1166         }
1167         else
1168         {
1169                 clnt->ptr_cred = 0;
1170         }
1171
1172         return True;
1173 }
1174
1175 /*******************************************************************
1176 reads or writes a DOM_CLNT_INFO2 structure.
1177 ********************************************************************/
1178 BOOL smb_io_clnt_info2(char *desc,  DOM_CLNT_INFO2 *clnt, prs_struct *ps, int depth)
1179 {
1180         if (clnt == NULL) return False;
1181
1182         prs_debug(ps, depth, desc, "smb_io_clnt_info2");
1183         depth++;
1184
1185         prs_align(ps);
1186
1187         smb_io_clnt_srv("", &(clnt->login), ps, depth);
1188
1189         prs_align(ps);
1190
1191         prs_uint32("ptr_cred", ps, depth, &(clnt->ptr_cred));
1192         smb_io_cred    ("", &(clnt->cred ), ps, depth);
1193
1194         return True;
1195 }
1196
1197 /*******************************************************************
1198 makes a DOM_CLNT_INFO structure.
1199 ********************************************************************/
1200 BOOL make_clnt_info(DOM_CLNT_INFO *clnt,
1201                 const char *logon_srv, const char *acct_name,
1202                 uint16 sec_chan, const char *comp_name,
1203                                 DOM_CRED *cred)
1204 {
1205         if (clnt == NULL || cred == NULL) return False;
1206
1207         DEBUG(5,("make_clnt_info\n"));
1208
1209         make_log_info(&(clnt->login), logon_srv, acct_name, sec_chan, comp_name);
1210         memcpy(&(clnt->cred), cred, sizeof(clnt->cred));
1211
1212         return True;
1213 }
1214
1215 /*******************************************************************
1216 reads or writes a DOM_CLNT_INFO structure.
1217 ********************************************************************/
1218 BOOL smb_io_clnt_info(char *desc,  DOM_CLNT_INFO *clnt, prs_struct *ps, int depth)
1219 {
1220         if (clnt == NULL) return False;
1221
1222         prs_debug(ps, depth, desc, "smb_io_clnt_info");
1223         depth++;
1224
1225         prs_align(ps);
1226
1227         smb_io_log_info("", &(clnt->login), ps, depth);
1228         smb_io_cred    ("", &(clnt->cred ), ps, depth);
1229
1230         return True;
1231 }
1232
1233 /*******************************************************************
1234 makes an OWF_INFO structure.
1235 ********************************************************************/
1236 BOOL make_owf_info(OWF_INFO *hash, const uint8 data[16])
1237 {
1238         if (hash == NULL) return False;
1239
1240         DEBUG(5,("make_owf_info: %d\n", __LINE__));
1241
1242         if (data != NULL)
1243         {
1244                 memcpy(hash->data, data, sizeof(hash->data));
1245         }
1246         else
1247         {
1248                 bzero(hash->data, sizeof(hash->data));
1249         }
1250
1251         return True;
1252 }
1253
1254 /*******************************************************************
1255 reads or writes an OWF_INFO structure.
1256 ********************************************************************/
1257 BOOL smb_io_owf_info(char *desc, OWF_INFO *hash, prs_struct *ps, int depth)
1258 {
1259         if (hash == NULL) return False;
1260
1261         prs_debug(ps, depth, desc, "smb_io_owf_info");
1262         depth++;
1263
1264         prs_align(ps);
1265
1266         prs_uint8s (False, "data", ps, depth, hash->data, 16);
1267
1268         return True;
1269 }
1270
1271 /*******************************************************************
1272 reads or writes a DOM_GID structure.
1273 ********************************************************************/
1274 BOOL smb_io_gid(char *desc,  DOM_GID *gid, prs_struct *ps, int depth)
1275 {
1276         if (gid == NULL) return False;
1277
1278         prs_debug(ps, depth, desc, "smb_io_gid");
1279         depth++;
1280
1281         prs_align(ps);
1282
1283         prs_uint32("g_rid", ps, depth, &(gid->g_rid));
1284         prs_uint32("attr ", ps, depth, &(gid->attr ));
1285
1286         return True;
1287 }
1288
1289 /*******************************************************************
1290 reads or writes an POLICY_HND structure.
1291 ********************************************************************/
1292 BOOL smb_io_pol_hnd(char *desc,  POLICY_HND *pol, prs_struct *ps, int depth)
1293 {
1294         if (pol == NULL) return False;
1295
1296         prs_debug(ps, depth, desc, "smb_io_pol_hnd");
1297         depth++;
1298
1299         prs_align(ps);
1300
1301         prs_uint8s (False, "data", ps, depth, pol->data, POL_HND_SIZE);
1302
1303         return True;
1304 }
1305
1306 /*******************************************************************
1307 reads or writes a dom query structure.
1308 ********************************************************************/
1309 static BOOL smb_io_dom_query(char *desc,  DOM_QUERY *d_q, prs_struct *ps, int depth)
1310 {
1311         if (d_q == NULL) return False;
1312
1313         prs_debug(ps, depth, desc, "smb_io_dom_query");
1314         depth++;
1315
1316         prs_align(ps);
1317
1318         prs_uint16("uni_dom_max_len", ps, depth, &(d_q->uni_dom_max_len)); /* domain name string length * 2 */
1319         prs_uint16("uni_dom_str_len", ps, depth, &(d_q->uni_dom_str_len)); /* domain name string length * 2 */
1320
1321         prs_uint32("buffer_dom_name", ps, depth, &(d_q->buffer_dom_name)); /* undocumented domain name string buffer pointer */
1322         prs_uint32("buffer_dom_sid ", ps, depth, &(d_q->buffer_dom_sid )); /* undocumented domain SID string buffer pointer */
1323
1324         smb_io_unistr2("unistr2", &(d_q->uni_domain_name), d_q->buffer_dom_name, ps, depth); /* domain name (unicode string) */
1325
1326         prs_align(ps);
1327
1328         if (d_q->buffer_dom_sid != 0)
1329         {
1330                 smb_io_dom_sid2("", &(d_q->dom_sid), ps, depth); /* domain SID */
1331         }
1332         else
1333         {
1334                 bzero(&(d_q->dom_sid), sizeof(d_q->dom_sid));
1335         }
1336
1337         return True;
1338 }
1339
1340 /*******************************************************************
1341 reads or writes a dom query structure.
1342 ********************************************************************/
1343 BOOL smb_io_dom_query_3(char *desc,  DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
1344 {
1345         smb_io_dom_query("", d_q, ps, depth);
1346
1347         return True;
1348 }
1349
1350 /*******************************************************************
1351 reads or writes a dom query structure.
1352 ********************************************************************/
1353 BOOL smb_io_dom_query_5(char *desc,  DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
1354 {
1355         smb_io_dom_query("", d_q, ps, depth);
1356
1357         return True;
1358 }
1359
1360
1361 /*******************************************************************
1362 reads or writes a UNISTR3 structure.
1363 ********************************************************************/
1364 BOOL smb_io_unistr3(char *desc,  UNISTR3 *name, prs_struct *ps, int depth)
1365 {
1366         if (name == NULL) return False;
1367
1368         prs_debug(ps, depth, desc, "smb_io_unistr3");
1369         depth++;
1370
1371         prs_align(ps);
1372
1373         prs_uint32("uni_str_len", ps, depth, &(name->uni_str_len));
1374
1375         /* don't know if len is specified by uni_str_len member... */
1376         /* assume unicode string is unicode-null-terminated, instead */
1377
1378         prs_unistr3(True, "unistr", name, ps, depth);
1379
1380         return True;
1381 }
1382