source/rpc_parse/parse_misc.c

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