source/rpc_parse/parse_prs.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba memory buffer functions
   4    Copyright (C) Andrew Tridgell              1992-1997
   5    Copyright (C) Luke Kenneth Casson Leighton 1996-1997
   6    Copyright (C) Jeremy Allison 1999.
   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  * Dump a prs to a file: from the current location through to the end.
  30  **/
  31 void prs_dump(char *name, int v, prs_struct *ps)
  32 {
  33         prs_dump_region(name, v, ps, ps->data_offset, ps->buffer_size);
  34 }
  35
  36
  37 /**
  38  * Dump from the start of the prs to the current location.
  39  **/
  40 void prs_dump_before(char *name, int v, prs_struct *ps)
  41 {
  42         prs_dump_region(name, v, ps, 0, ps->data_offset);
  43 }
  44
  45
  46 /**
  47  * Dump everything from the start of the prs up to the current location.
  48  **/
  49 void prs_dump_region(char *name, int v, prs_struct *ps,
  50                      int from_off, int to_off)
  51 {
  52         int fd, i;
  53         pstring fname;
  54         if (DEBUGLEVEL < 50) return;
  55         for (i=1;i<100;i++) {
  56                 if (v != -1) {
  57                         slprintf(fname,sizeof(fname)-1, "/tmp/%s_%d.%d.prs", name, v, i);
  58                 } else {
  59                         slprintf(fname,sizeof(fname)-1, "/tmp/%s.%d.prs", name, i);
  60                 }
  61                 fd = open(fname, O_WRONLY|O_CREAT|O_EXCL, 0644);
  62                 if (fd != -1 || errno != EEXIST) break;
  63         }
  64         if (fd != -1) {
  65                 write(fd, ps->data_p + from_off, to_off - from_off);
  66                 close(fd);
  67                 DEBUG(0,("created %s\n", fname));
  68         }
  69 }
  70
  71
  72
  73 /*******************************************************************
  74  debug output for parsing info.
  75
  76  XXXX side-effect of this function is to increase the debug depth XXXX
  77
  78  ********************************************************************/
  79 void prs_debug(prs_struct *ps, int depth, const char *desc, char *fn_name)
  80 {
  81         DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(depth), ps->data_offset, fn_name, desc));
  82 }
  83
  84
  85 /**
  86  * Initialise an expandable parse structure.
  87  *
  88  * @param size Initial buffer size.  If >0, a new buffer will be
  89  * created with malloc().
  90  *
  91  * @return False if allocation fails, otherwise True.
  92  **/
  93 BOOL prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, BOOL io)
  94 {
  95         ZERO_STRUCTP(ps);
  96         ps->io = io;
  97         ps->bigendian_data = RPC_LITTLE_ENDIAN;
  98         ps->align = RPC_PARSE_ALIGN;
  99         ps->is_dynamic = False;
 100         ps->data_offset = 0;
 101         ps->buffer_size = 0;
 102         ps->data_p = NULL;
 103         ps->mem_ctx = ctx;
 104
 105         if (size != 0) {
 106                 ps->buffer_size = size;
 107                 if((ps->data_p = (char *)malloc((size_t)size)) == NULL) {
 108                         DEBUG(0,("prs_init: malloc fail for %u bytes.\n", (unsigned int)size));
 109                         return False;
 110                 }
 111                 memset(ps->data_p, '\0', (size_t)size);
 112                 ps->is_dynamic = True; /* We own this memory. */
 113         }
 114
 115         return True;
 116 }
 117
 118 /*******************************************************************
 119  read from a socket into memory.
 120  ********************************************************************/
 121 BOOL prs_read(prs_struct *ps, int fd, size_t len, int timeout)
 122 {
 123         BOOL ok;
 124         size_t prev_size = ps->buffer_size;
 125         if (!prs_grow(ps, len))
 126                 return False;
 127
 128         if (timeout > 0) {
 129                 ok = (read_with_timeout(fd, &ps->data_p[prev_size],
 130                                             len, len,timeout) == len);
 131         } else {
 132                 ok = (read_data(fd, &ps->data_p[prev_size], len) == len);
 133         }
 134         return ok;
 135 }
 136
 137 /*******************************************************************
 138  Delete the memory in a parse structure - if we own it.
 139  ********************************************************************/
 140
 141 void prs_mem_free(prs_struct *ps)
 142 {
 143         if(ps->is_dynamic)
 144                 SAFE_FREE(ps->data_p);
 145         ps->is_dynamic = False;
 146         ps->buffer_size = 0;
 147         ps->data_offset = 0;
 148 }
 149
 150 /*******************************************************************
 151  Clear the memory in a parse structure.
 152  ********************************************************************/
 153
 154 void prs_mem_clear(prs_struct *ps)
 155 {
 156         memset(ps->data_p, '\0', (size_t)ps->buffer_size);
 157 }
 158
 159 /*******************************************************************
 160  Allocate memory when unmarshalling... Always zero clears.
 161  ********************************************************************/
 162
 163 char *prs_alloc_mem(prs_struct *ps, size_t size)
 164 {
 165         char *ret = talloc(ps->mem_ctx, size);
 166
 167         if (ret)
 168                 memset(ret, '\0', size);
 169
 170         return ret;
 171 }
 172
 173 /*******************************************************************
 174  Return the current talloc context we're using.
 175  ********************************************************************/
 176
 177 TALLOC_CTX *prs_get_mem_context(prs_struct *ps)
 178 {
 179         return ps->mem_ctx;
 180 }
 181
 182 /*******************************************************************
 183  Hand some already allocated memory to a prs_struct.
 184  ********************************************************************/
 185
 186 void prs_give_memory(prs_struct *ps, char *buf, uint32 size, BOOL is_dynamic)
 187 {
 188         ps->is_dynamic = is_dynamic;
 189         ps->data_p = buf;
 190         ps->buffer_size = size;
 191 }
 192
 193 /*******************************************************************
 194  Take some memory back from a prs_struct.
 195  ********************************************************************/
 196
 197 char *prs_take_memory(prs_struct *ps, uint32 *psize)
 198 {
 199         char *ret = ps->data_p;
 200         if(psize)
 201                 *psize = ps->buffer_size;
 202         ps->is_dynamic = False;
 203         prs_mem_free(ps);
 204         return ret;
 205 }
 206
 207 /*******************************************************************
 208  Set a prs_struct to exactly a given size. Will grow or tuncate if neccessary.
 209  ********************************************************************/
 210
 211 BOOL prs_set_buffer_size(prs_struct *ps, uint32 newsize)
 212 {
 213         if (newsize > ps->buffer_size)
 214                 return prs_force_grow(ps, newsize - ps->buffer_size);
 215
 216         if (newsize < ps->buffer_size) {
 217                 char *new_data_p = Realloc(ps->data_p, newsize);
 218                 /* if newsize is zero, Realloc acts like free() & returns NULL*/
 219                 if (new_data_p == NULL && newsize != 0) {
 220                         DEBUG(0,("prs_set_buffer_size: Realloc failure for size %u.\n",
 221                                 (unsigned int)newsize));
 222                         DEBUG(0,("prs_set_buffer_size: Reason %s\n",strerror(errno)));
 223                         return False;
 224                 }
 225                 ps->data_p = new_data_p;
 226                 ps->buffer_size = newsize;
 227         }
 228
 229         return True;
 230 }
 231
 232 /*******************************************************************
 233  Attempt, if needed, to grow a data buffer.
 234  Also depends on the data stream mode (io).
 235  ********************************************************************/
 236
 237 BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 238 {
 239         uint32 new_size;
 240         char *new_data;
 241
 242         ps->grow_size = MAX(ps->grow_size, ps->data_offset + extra_space);
 243
 244         if(ps->data_offset + extra_space <= ps->buffer_size)
 245                 return True;
 246
 247         /*
 248          * We cannot grow the buffer if we're not reading
 249          * into the prs_struct, or if we don't own the memory.
 250          */
 251
 252         if(UNMARSHALLING(ps) || !ps->is_dynamic) {
 253                 DEBUG(0,("prs_grow: Buffer overflow - unable to expand buffer by %u bytes.\n",
 254                                 (unsigned int)extra_space));
 255                 return False;
 256         }
 257
 258         /*
 259          * Decide how much extra space we really need.
 260          */
 261
 262         extra_space -= (ps->buffer_size - ps->data_offset);
 263         if(ps->buffer_size == 0) {
 264                 /*
 265                  * Ensure we have at least a PDU's length, or extra_space, whichever
 266                  * is greater.
 267                  */
 268
 269                 new_size = MAX(MAX_PDU_FRAG_LEN,extra_space);
 270
 271                 if((new_data = malloc(new_size)) == NULL) {
 272                         DEBUG(0,("prs_grow: Malloc failure for size %u.\n", (unsigned int)new_size));
 273                         return False;
 274                 }
 275                 memset(new_data, '\0', (size_t)new_size );
 276         } else {
 277                 /*
 278                  * If the current buffer size is bigger than the space needed, just
 279                  * double it, else add extra_space.
 280                  */
 281                 new_size = MAX(ps->buffer_size*2, ps->buffer_size + extra_space);
 282
 283                 if ((new_data = Realloc(ps->data_p, new_size)) == NULL) {
 284                         DEBUG(0,("prs_grow: Realloc failure for size %u.\n",
 285                                 (unsigned int)new_size));
 286                         return False;
 287                 }
 288
 289                 memset(&new_data[ps->buffer_size], '\0', (size_t)(new_size - ps->buffer_size));
 290         }
 291         ps->buffer_size = new_size;
 292         ps->data_p = new_data;
 293
 294         return True;
 295 }
 296
 297 /*******************************************************************
 298  Attempt to force a data buffer to grow by len bytes.
 299  This is only used when appending more data onto a prs_struct
 300  when reading an rpc reply, before unmarshalling it.
 301  ********************************************************************/
 302
 303 BOOL prs_force_grow(prs_struct *ps, uint32 extra_space)
 304 {
 305         uint32 new_size = ps->buffer_size + extra_space;
 306         char *new_data;
 307
 308         if(!UNMARSHALLING(ps) || !ps->is_dynamic) {
 309                 DEBUG(0,("prs_force_grow: Buffer overflow - unable to expand buffer by %u bytes.\n",
 310                                 (unsigned int)extra_space));
 311                 return False;
 312         }
 313
 314         if((new_data = Realloc(ps->data_p, new_size)) == NULL) {
 315                 DEBUG(0,("prs_force_grow: Realloc failure for size %u.\n",
 316                         (unsigned int)new_size));
 317                 return False;
 318         }
 319
 320         memset(&new_data[ps->buffer_size], '\0', (size_t)(new_size - ps->buffer_size));
 321
 322         ps->buffer_size = new_size;
 323         ps->data_p = new_data;
 324
 325         return True;
 326 }
 327
 328 /*******************************************************************
 329  Get the data pointer (external interface).
 330  ********************************************************************/
 331
 332 char *prs_data_p(prs_struct *ps)
 333 {
 334         return ps->data_p;
 335 }
 336
 337 /*******************************************************************
 338  Get the current data size (external interface).
 339  ********************************************************************/
 340
 341 uint32 prs_data_size(prs_struct *ps)
 342 {
 343         return ps->buffer_size;
 344 }
 345
 346 /*******************************************************************
 347  Fetch the current offset (external interface).
 348  ********************************************************************/
 349
 350 uint32 prs_offset(prs_struct *ps)
 351 {
 352         return ps->data_offset;
 353 }
 354
 355 /*******************************************************************
 356  Set the current offset (external interface).
 357  ********************************************************************/
 358
 359 BOOL prs_set_offset(prs_struct *ps, uint32 offset)
 360 {
 361         if(offset <= ps->data_offset) {
 362                 ps->data_offset = offset;
 363                 return True;
 364         }
 365
 366         if(!prs_grow(ps, offset - ps->data_offset))
 367                 return False;
 368
 369         ps->data_offset = offset;
 370         return True;
 371 }
 372
 373 /*******************************************************************
 374  Append the data from one parse_struct into another.
 375  ********************************************************************/
 376
 377 BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
 378 {
 379         if(!prs_grow(dst, prs_offset(src)))
 380                 return False;
 381
 382         memcpy(&dst->data_p[dst->data_offset], prs_data_p(src), (size_t)prs_offset(src));
 383         dst->data_offset += prs_offset(src);
 384
 385         return True;
 386 }
 387
 388 /*******************************************************************
 389  Append some data from one parse_struct into another.
 390  ********************************************************************/
 391
 392 BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uint32 len)
 393 {
 394         if (len == 0)
 395                 return True;
 396
 397         if(!prs_grow(dst, len))
 398                 return False;
 399
 400         memcpy(&dst->data_p[dst->data_offset], prs_data_p(src)+start, (size_t)len);
 401         dst->data_offset += len;
 402
 403         return True;
 404 }
 405
 406 /*******************************************************************
 407  Append the data from a buffer into a parse_struct.
 408  ********************************************************************/
 409
 410 BOOL prs_append_data(prs_struct *dst, char *src, uint32 len)
 411 {
 412         if(!prs_grow(dst, len))
 413                 return False;
 414
 415         memcpy(&dst->data_p[dst->data_offset], src, (size_t)len);
 416         dst->data_offset += len;
 417
 418         return True;
 419 }
 420
 421 /*******************************************************************
 422  Set the data as X-endian (external interface).
 423  ********************************************************************/
 424
 425 void prs_set_endian_data(prs_struct *ps, BOOL endian)
 426 {
 427         ps->bigendian_data = endian;
 428 }
 429
 430 /*******************************************************************
 431  Align a the data_len to a multiple of align bytes - filling with
 432  zeros.
 433  ********************************************************************/
 434
 435 BOOL prs_align(prs_struct *ps)
 436 {
 437         uint32 mod = ps->data_offset & (ps->align-1);
 438
 439         if (ps->align != 0 && mod != 0) {
 440                 uint32 extra_space = (ps->align - mod);
 441                 if(!prs_grow(ps, extra_space))
 442                         return False;
 443                 memset(&ps->data_p[ps->data_offset], '\0', (size_t)extra_space);
 444                 ps->data_offset += extra_space;
 445         }
 446
 447         return True;
 448 }
 449
 450 /******************************************************************
 451  Align on a 2 byte boundary
 452  *****************************************************************/
 453
 454 BOOL prs_align_uint16(prs_struct *ps)
 455 {
 456         BOOL ret;
 457         uint8 old_align = ps->align;
 458
 459         ps->align = 2;
 460         ret = prs_align(ps);
 461         ps->align = old_align;
 462
 463         return ret;
 464 }
 465
 466 /******************************************************************
 467  Align on a 8 byte boundary
 468  *****************************************************************/
 469
 470 BOOL prs_align_uint64(prs_struct *ps)
 471 {
 472         BOOL ret;
 473         uint8 old_align = ps->align;
 474
 475         ps->align = 8;
 476         ret = prs_align(ps);
 477         ps->align = old_align;
 478
 479         return ret;
 480 }
 481
 482 /*******************************************************************
 483  Align only if required (for the unistr2 string mainly)
 484  ********************************************************************/
 485
 486 BOOL prs_align_needed(prs_struct *ps, uint32 needed)
 487 {
 488         if (needed==0)
 489                 return True;
 490         else
 491                 return prs_align(ps);
 492 }
 493
 494 /*******************************************************************
 495  Ensure we can read/write to a given offset.
 496  ********************************************************************/
 497
 498 char *prs_mem_get(prs_struct *ps, uint32 extra_size)
 499 {
 500         if(UNMARSHALLING(ps)) {
 501                 /*
 502                  * If reading, ensure that we can read the requested size item.
 503                  */
 504                 if (ps->data_offset + extra_size > ps->buffer_size) {
 505                         DEBUG(0,("prs_mem_get: reading data of size %u would overrun buffer.\n",
 506                                         (unsigned int)extra_size ));
 507                         return NULL;
 508                 }
 509         } else {
 510                 /*
 511                  * Writing - grow the buffer if needed.
 512                  */
 513                 if(!prs_grow(ps, extra_size))
 514                         return NULL;
 515         }
 516         return &ps->data_p[ps->data_offset];
 517 }
 518
 519 /*******************************************************************
 520  Change the struct type.
 521  ********************************************************************/
 522
 523 void prs_switch_type(prs_struct *ps, BOOL io)
 524 {
 525         if ((ps->io ^ io) == True)
 526                 ps->io=io;
 527 }
 528
 529 /*******************************************************************
 530  Force a prs_struct to be dynamic even when it's size is 0.
 531  ********************************************************************/
 532
 533 void prs_force_dynamic(prs_struct *ps)
 534 {
 535         ps->is_dynamic=True;
 536 }
 537
 538 /*******************************************************************
 539  Stream a uint8.
 540  ********************************************************************/
 541
 542 BOOL prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
 543 {
 544         char *q = prs_mem_get(ps, 1);
 545         if (q == NULL)
 546                 return False;
 547
 548     if (UNMARSHALLING(ps))
 549                 *data8 = CVAL(q,0);
 550         else
 551                 SCVAL(q,0,*data8);
 552
 553     DEBUG(5,("%s%04x %s: %02x\n", tab_depth(depth), ps->data_offset, name, *data8));
 554
 555         ps->data_offset += 1;
 556
 557         return True;
 558 }
 559
 560 /*******************************************************************
 561  Stream a uint16.
 562  ********************************************************************/
 563
 564 BOOL prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
 565 {
 566         char *q = prs_mem_get(ps, sizeof(uint16));
 567         if (q == NULL)
 568                 return False;
 569
 570     if (UNMARSHALLING(ps)) {
 571                 if (ps->bigendian_data)
 572                         *data16 = RSVAL(q,0);
 573                 else
 574                         *data16 = SVAL(q,0);
 575     } else {
 576                 if (ps->bigendian_data)
 577                         RSSVAL(q,0,*data16);
 578                 else
 579                         SSVAL(q,0,*data16);
 580         }
 581
 582         DEBUG(5,("%s%04x %s: %04x\n", tab_depth(depth), ps->data_offset, name, *data16));
 583
 584         ps->data_offset += sizeof(uint16);
 585
 586         return True;
 587 }
 588
 589 /*******************************************************************
 590  Stream a uint32.
 591  ********************************************************************/
 592
 593 BOOL prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
 594 {
 595         char *q = prs_mem_get(ps, sizeof(uint32));
 596         if (q == NULL)
 597                 return False;
 598
 599         if (UNMARSHALLING(ps)) {
 600                 if (ps->bigendian_data)
 601                         *data32 = RIVAL(q,0);
 602                 else
 603                         *data32 = IVAL(q,0);
 604         } else {
 605                 if (ps->bigendian_data)
 606                         RSIVAL(q,0,*data32);
 607                 else
 608                         SIVAL(q,0,*data32);
 609         }
 610
 611         DEBUG(5,("%s%04x %s: %08x\n", tab_depth(depth), ps->data_offset, name, *data32));
 612
 613         ps->data_offset += sizeof(uint32);
 614
 615         return True;
 616 }
 617
 618 /*******************************************************************
 619  Stream a NTSTATUS
 620  ********************************************************************/
 621
 622 BOOL prs_ntstatus(char *name, prs_struct *ps, int depth, NTSTATUS *status)
 623 {
 624         char *q = prs_mem_get(ps, sizeof(uint32));
 625         if (q == NULL)
 626                 return False;
 627
 628         if (UNMARSHALLING(ps)) {
 629                 if (ps->bigendian_data)
 630                         *status = NT_STATUS(RIVAL(q,0));
 631                 else
 632                         *status = NT_STATUS(IVAL(q,0));
 633         } else {
 634                 if (ps->bigendian_data)
 635                         RSIVAL(q,0,NT_STATUS_V(*status));
 636                 else
 637                         SIVAL(q,0,NT_STATUS_V(*status));
 638         }
 639
 640         DEBUG(5,("%s%04x %s: %s\n", tab_depth(depth), ps->data_offset, name,
 641                  nt_errstr(*status)));
 642
 643         ps->data_offset += sizeof(uint32);
 644
 645         return True;
 646 }
 647
 648 /*******************************************************************
 649  Stream a WERROR
 650  ********************************************************************/
 651
 652 BOOL prs_werror(char *name, prs_struct *ps, int depth, WERROR *status)
 653 {
 654         char *q = prs_mem_get(ps, sizeof(uint32));
 655         if (q == NULL)
 656                 return False;
 657
 658         if (UNMARSHALLING(ps)) {
 659                 if (ps->bigendian_data)
 660                         *status = W_ERROR(RIVAL(q,0));
 661                 else
 662                         *status = W_ERROR(IVAL(q,0));
 663         } else {
 664                 if (ps->bigendian_data)
 665                         RSIVAL(q,0,W_ERROR_V(*status));
 666                 else
 667                         SIVAL(q,0,W_ERROR_V(*status));
 668         }
 669
 670         DEBUG(5,("%s%04x %s: %s\n", tab_depth(depth), ps->data_offset, name,
 671                  dos_errstr(*status)));
 672
 673         ps->data_offset += sizeof(uint32);
 674
 675         return True;
 676 }
 677
 678
 679 /******************************************************************
 680  Stream an array of uint8s. Length is number of uint8s.
 681  ********************************************************************/
 682
 683 BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
 684 {
 685         int i;
 686         char *q = prs_mem_get(ps, len);
 687         if (q == NULL)
 688                 return False;
 689
 690         if (UNMARSHALLING(ps)) {
 691                 for (i = 0; i < len; i++)
 692                         data8s[i] = CVAL(q,i);
 693         } else {
 694                 for (i = 0; i < len; i++)
 695                         SCVAL(q, i, data8s[i]);
 696         }
 697
 698     DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset ,name));
 699     if (charmode)
 700                 print_asc(5, (unsigned char*)data8s, len);
 701         else {
 702         for (i = 0; i < len; i++)
 703                         DEBUG(5,("%02x ", data8s[i]));
 704         }
 705     DEBUG(5,("\n"));
 706
 707         ps->data_offset += len;
 708
 709         return True;
 710 }
 711
 712 /******************************************************************
 713  Stream an array of uint16s. Length is number of uint16s.
 714  ********************************************************************/
 715
 716 BOOL prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
 717 {
 718         int i;
 719         char *q = prs_mem_get(ps, len * sizeof(uint16));
 720         if (q == NULL)
 721                 return False;
 722
 723         if (UNMARSHALLING(ps)) {
 724                 if (ps->bigendian_data) {
 725                         for (i = 0; i < len; i++)
 726                                 data16s[i] = RSVAL(q, 2*i);
 727                 } else {
 728                         for (i = 0; i < len; i++)
 729                                 data16s[i] = SVAL(q, 2*i);
 730                 }
 731         } else {
 732                 if (ps->bigendian_data) {
 733                         for (i = 0; i < len; i++)
 734                                 RSSVAL(q, 2*i, data16s[i]);
 735                 } else {
 736                         for (i = 0; i < len; i++)
 737                                 SSVAL(q, 2*i, data16s[i]);
 738                 }
 739         }
 740
 741         DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
 742         if (charmode)
 743                 print_asc(5, (unsigned char*)data16s, 2*len);
 744         else {
 745                 for (i = 0; i < len; i++)
 746                         DEBUG(5,("%04x ", data16s[i]));
 747         }
 748     DEBUG(5,("\n"));
 749
 750         ps->data_offset += (len * sizeof(uint16));
 751
 752         return True;
 753 }
 754
 755 /******************************************************************
 756  Start using a function for streaming unicode chars. If unmarshalling,
 757  output must be little-endian, if marshalling, input must be little-endian.
 758  ********************************************************************/
 759
 760 static void dbg_rw_punival(BOOL charmode, char *name, int depth, prs_struct *ps,
 761                                                         char *in_buf, char *out_buf, int len)
 762 {
 763         int i;
 764
 765         if (UNMARSHALLING(ps)) {
 766                 if (ps->bigendian_data) {
 767                         for (i = 0; i < len; i++)
 768                                 SSVAL(out_buf,2*i,RSVAL(in_buf, 2*i));
 769                 } else {
 770                         for (i = 0; i < len; i++)
 771                                 SSVAL(out_buf, 2*i, SVAL(in_buf, 2*i));
 772                 }
 773         } else {
 774                 if (ps->bigendian_data) {
 775                         for (i = 0; i < len; i++)
 776                                 RSSVAL(in_buf, 2*i, SVAL(out_buf,2*i));
 777                 } else {
 778                         for (i = 0; i < len; i++)
 779                                 SSVAL(in_buf, 2*i, SVAL(out_buf,2*i));
 780                 }
 781         }
 782
 783         DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
 784         if (charmode)
 785                 print_asc(5, (unsigned char*)out_buf, 2*len);
 786         else {
 787                 for (i = 0; i < len; i++)
 788                         DEBUG(5,("%04x ", out_buf[i]));
 789         }
 790     DEBUG(5,("\n"));
 791 }
 792
 793 /******************************************************************
 794  Stream a unistr. Always little endian.
 795  ********************************************************************/
 796
 797 BOOL prs_uint16uni(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
 798 {
 799         char *q = prs_mem_get(ps, len * sizeof(uint16));
 800         if (q == NULL)
 801                 return False;
 802
 803         dbg_rw_punival(charmode, name, depth, ps, q, (char *)data16s, len);
 804         ps->data_offset += (len * sizeof(uint16));
 805
 806         return True;
 807 }
 808
 809 /******************************************************************
 810  Stream an array of uint32s. Length is number of uint32s.
 811  ********************************************************************/
 812
 813 BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
 814 {
 815         int i;
 816         char *q = prs_mem_get(ps, len * sizeof(uint32));
 817         if (q == NULL)
 818                 return False;
 819
 820         if (UNMARSHALLING(ps)) {
 821                 if (ps->bigendian_data) {
 822                         for (i = 0; i < len; i++)
 823                                 data32s[i] = RIVAL(q, 4*i);
 824                 } else {
 825                         for (i = 0; i < len; i++)
 826                                 data32s[i] = IVAL(q, 4*i);
 827                 }
 828         } else {
 829                 if (ps->bigendian_data) {
 830                         for (i = 0; i < len; i++)
 831                                 RSIVAL(q, 4*i, data32s[i]);
 832                 } else {
 833                         for (i = 0; i < len; i++)
 834                                 SIVAL(q, 4*i, data32s[i]);
 835                 }
 836         }
 837
 838         DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
 839         if (charmode)
 840                 print_asc(5, (unsigned char*)data32s, 4*len);
 841         else {
 842                 for (i = 0; i < len; i++)
 843                         DEBUG(5,("%08x ", data32s[i]));
 844         }
 845     DEBUG(5,("\n"));
 846
 847         ps->data_offset += (len * sizeof(uint32));
 848
 849         return True;
 850 }
 851
 852 /******************************************************************
 853  Stream an array of unicode string, length/buffer specified separately,
 854  in uint16 chars. The unicode string is already in little-endian format.
 855  ********************************************************************/
 856
 857 BOOL prs_buffer5(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER5 *str)
 858 {
 859         char *p;
 860         char *q = prs_mem_get(ps, str->buf_len * sizeof(uint16));
 861         if (q == NULL)
 862                 return False;
 863
 864         if (UNMARSHALLING(ps)) {
 865                 str->buffer = (uint16 *)prs_alloc_mem(ps,str->buf_len * sizeof(uint16));
 866                 if (str->buffer == NULL)
 867                         return False;
 868         }
 869
 870         /* If the string is empty, we don't have anything to stream */
 871         if (str->buf_len==0)
 872                 return True;
 873
 874         p = (char *)str->buffer;
 875
 876         dbg_rw_punival(charmode, name, depth, ps, q, p, str->buf_len);
 877
 878         ps->data_offset += (str->buf_len * sizeof(uint16));
 879
 880         return True;
 881 }
 882
 883 /******************************************************************
 884  Stream a "not" unicode string, length/buffer specified separately,
 885  in byte chars. String is in little-endian format.
 886  ********************************************************************/
 887
 888 BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str)
 889 {
 890         char *p;
 891         char *q = prs_mem_get(ps, str->buf_len);
 892         if (q == NULL)
 893                 return False;
 894
 895         if (UNMARSHALLING(ps)) {
 896                 if ( str->buf_len ) {
 897                         str->buffer = (uint16 *)prs_alloc_mem(ps,str->buf_len);
 898                         if ( str->buffer == NULL )
 899                                 return False;
 900                 }
 901         }
 902
 903         p = (char *)str->buffer;
 904
 905         dbg_rw_punival(charmode, name, depth, ps, q, p, str->buf_len/2);
 906         ps->data_offset += str->buf_len;
 907
 908         return True;
 909 }
 910
 911 /******************************************************************
 912  Stream a string, length/buffer specified separately,
 913  in uint8 chars.
 914  ********************************************************************/
 915
 916 BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
 917 {
 918         int i;
 919         char *q = prs_mem_get(ps, str->str_max_len);
 920         if (q == NULL)
 921                 return False;
 922
 923         if (UNMARSHALLING(ps)) {
 924                 str->buffer = (unsigned char *)prs_alloc_mem(ps,str->str_max_len);
 925                 if (str->buffer == NULL)
 926                         return False;
 927         }
 928
 929         if (UNMARSHALLING(ps)) {
 930                 for (i = 0; i < str->str_str_len; i++)
 931                         str->buffer[i] = CVAL(q,i);
 932         } else {
 933                 for (i = 0; i < str->str_str_len; i++)
 934                         SCVAL(q, i, str->buffer[i]);
 935         }
 936
 937     DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
 938     if (charmode)
 939                 print_asc(5, (unsigned char*)str->buffer, str->str_str_len);
 940         else {
 941         for (i = 0; i < str->str_str_len; i++)
 942                         DEBUG(5,("%02x ", str->buffer[i]));
 943         }
 944     DEBUG(5,("\n"));
 945
 946         ps->data_offset += str->str_str_len;
 947
 948         return True;
 949 }
 950
 951 /******************************************************************
 952  Stream a unicode string, length/buffer specified separately,
 953  in uint16 chars. The unicode string is already in little-endian format.
 954  ********************************************************************/
 955
 956 BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
 957 {
 958         char *p;
 959         char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
 960         if (q == NULL)
 961                 return False;
 962
 963         /* If the string is empty, we don't have anything to stream */
 964         if (str->uni_str_len==0)
 965                 return True;
 966
 967         if (UNMARSHALLING(ps)) {
 968                 str->buffer = (uint16 *)prs_alloc_mem(ps,str->uni_max_len * sizeof(uint16));
 969                 if (str->buffer == NULL)
 970                         return False;
 971         }
 972
 973         p = (char *)str->buffer;
 974
 975         dbg_rw_punival(charmode, name, depth, ps, q, p, str->uni_str_len);
 976
 977         ps->data_offset += (str->uni_str_len * sizeof(uint16));
 978
 979         return True;
 980 }
 981
 982 /******************************************************************
 983  Stream a unicode string, length/buffer specified separately,
 984  in uint16 chars. The unicode string is already in little-endian format.
 985  ********************************************************************/
 986
 987 BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
 988 {
 989         char *p;
 990         char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
 991         if (q == NULL)
 992                 return False;
 993
 994         if (UNMARSHALLING(ps)) {
 995                 str->str.buffer = (uint16 *)prs_alloc_mem(ps,str->uni_str_len * sizeof(uint16));
 996                 if (str->str.buffer == NULL)
 997                         return False;
 998         }
 999
1000         p = (char *)str->str.buffer;
1001
1002         dbg_rw_punival(charmode, name, depth, ps, q, p, str->uni_str_len);
1003         ps->data_offset += (str->uni_str_len * sizeof(uint16));
1004
1005         return True;
1006 }
1007
1008 /*******************************************************************
1009  Stream a unicode  null-terminated string. As the string is already
1010  in little-endian format then do it as a stream of bytes.
1011  ********************************************************************/
1012
1013 BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
1014 {
1015         int len = 0;
1016         unsigned char *p = (unsigned char *)str->buffer;
1017         uint8 *start;
1018         char *q;
1019         uint32 max_len;
1020         uint16* ptr;
1021
1022         if (MARSHALLING(ps)) {
1023
1024                 for(len = 0; str->buffer[len] != 0; len++)
1025                         ;
1026
1027                 q = prs_mem_get(ps, (len+1)*2);
1028                 if (q == NULL)
1029                         return False;
1030
1031                 start = (uint8*)q;
1032
1033                 for(len = 0; str->buffer[len] != 0; len++)
1034                 {
1035                         if(ps->bigendian_data)
1036                         {
1037                                 /* swap bytes - p is little endian, q is big endian. */
1038                                 q[0] = (char)p[1];
1039                                 q[1] = (char)p[0];
1040                                 p += 2;
1041                                 q += 2;
1042                         }
1043                         else
1044                         {
1045                                 q[0] = (char)p[0];
1046                                 q[1] = (char)p[1];
1047                                 p += 2;
1048                                 q += 2;
1049                         }
1050                 }
1051
1052                 /*
1053                  * even if the string is 'empty' (only an \0 char)
1054                  * at this point the leading \0 hasn't been parsed.
1055                  * so parse it now
1056                  */
1057
1058                 q[0] = 0;
1059                 q[1] = 0;
1060                 q += 2;
1061
1062                 len++;
1063
1064                 dump_data(5+depth, (char *)start, len * 2);
1065         }
1066         else { /* unmarshalling */
1067
1068                 uint32 alloc_len = 0;
1069                 q = prs_data_p(ps) + prs_offset(ps);
1070
1071                 /*
1072                  * Work out how much space we need and talloc it.
1073                  */
1074                 max_len = (ps->buffer_size - ps->data_offset)/sizeof(uint16);
1075
1076                 /* the test of the value of *ptr helps to catch the circumstance
1077                    where we have an emtpty (non-existent) string in the buffer */
1078                 for ( ptr = (uint16 *)q; *ptr && (alloc_len <= max_len); alloc_len++)
1079                         /* do nothing */
1080                         ;
1081
1082                 /* should we allocate anything at all? */
1083                 str->buffer = (uint16 *)prs_alloc_mem(ps,alloc_len * sizeof(uint16));
1084                 if ((str->buffer == NULL) && (alloc_len > 0))
1085                         return False;
1086
1087                 p = (unsigned char *)str->buffer;
1088
1089                 len = 0;
1090                 /* the (len < alloc_len) test is to prevent us from overwriting
1091                    memory that is not ours...if we get that far, we have a non-null
1092                    terminated string in the buffer and have messed up somewhere */
1093                 while ((len < alloc_len) && (*(uint16 *)q != 0))
1094                 {
1095                         if(ps->bigendian_data)
1096                         {
1097                                 /* swap bytes - q is big endian, p is little endian. */
1098                                 p[0] = (unsigned char)q[1];
1099                                 p[1] = (unsigned char)q[0];
1100                                 p += 2;
1101                                 q += 2;
1102                         } else {
1103
1104                                 p[0] = (unsigned char)q[0];
1105                                 p[1] = (unsigned char)q[1];
1106                                 p += 2;
1107                                 q += 2;
1108                         }
1109
1110                         len++;
1111                 }
1112                 if (len < alloc_len)
1113                 {
1114                         /* NULL terminate the UNISTR */
1115                         str->buffer[len++] = '\0';
1116                 }
1117         }
1118
1119         /* set the offset in the prs_struct; 'len' points to the
1120            terminiating NULL in the UNISTR so we need to go one more
1121            uint16 */
1122         ps->data_offset += (len)*2;
1123
1124         return True;
1125 }
1126
1127
1128 /*******************************************************************
1129  Stream a null-terminated string.  len is strlen, and therefore does
1130  not include the null-termination character.
1131  ********************************************************************/
1132
1133 BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, int len, int max_buf_size)
1134 {
1135         char *q;
1136         int i;
1137
1138         len = MIN(len, (max_buf_size-1));
1139
1140         q = prs_mem_get(ps, len+1);
1141         if (q == NULL)
1142                 return False;
1143
1144         for(i = 0; i < len; i++) {
1145                 if (UNMARSHALLING(ps))
1146                         str[i] = q[i];
1147                 else
1148                         q[i] = str[i];
1149         }
1150
1151         /* The terminating null. */
1152         str[i] = '\0';
1153
1154         if (MARSHALLING(ps)) {
1155                 q[i] = '\0';
1156         }
1157
1158         ps->data_offset += len+1;
1159
1160         dump_data(5+depth, q, len);
1161
1162         return True;
1163 }
1164
1165 /*******************************************************************
1166  prs_uint16 wrapper. Call this and it sets up a pointer to where the
1167  uint16 should be stored, or gets the size if reading.
1168  ********************************************************************/
1169
1170 BOOL prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
1171 {
1172         *offset = ps->data_offset;
1173         if (UNMARSHALLING(ps)) {
1174                 /* reading. */
1175                 return prs_uint16(name, ps, depth, data16);
1176         } else {
1177                 char *q = prs_mem_get(ps, sizeof(uint16));
1178                 if(q ==NULL)
1179                         return False;
1180                 ps->data_offset += sizeof(uint16);
1181         }
1182         return True;
1183 }
1184
1185 /*******************************************************************
1186  prs_uint16 wrapper.  call this and it retrospectively stores the size.
1187  does nothing on reading, as that is already handled by ...._pre()
1188  ********************************************************************/
1189
1190 BOOL prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
1191                                 uint32 ptr_uint16, uint32 start_offset)
1192 {
1193         if (MARSHALLING(ps)) {
1194                 /*
1195                  * Writing - temporarily move the offset pointer.
1196                  */
1197                 uint16 data_size = ps->data_offset - start_offset;
1198                 uint32 old_offset = ps->data_offset;
1199
1200                 ps->data_offset = ptr_uint16;
1201                 if(!prs_uint16(name, ps, depth, &data_size)) {
1202                         ps->data_offset = old_offset;
1203                         return False;
1204                 }
1205                 ps->data_offset = old_offset;
1206         } else {
1207                 ps->data_offset = start_offset + (uint32)(*data16);
1208         }
1209         return True;
1210 }
1211
1212 /*******************************************************************
1213  prs_uint32 wrapper. Call this and it sets up a pointer to where the
1214  uint32 should be stored, or gets the size if reading.
1215  ********************************************************************/
1216
1217 BOOL prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
1218 {
1219         *offset = ps->data_offset;
1220         if (UNMARSHALLING(ps) && (data32 != NULL)) {
1221                 /* reading. */
1222                 return prs_uint32(name, ps, depth, data32);
1223         } else {
1224                 ps->data_offset += sizeof(uint32);
1225         }
1226         return True;
1227 }
1228
1229 /*******************************************************************
1230  prs_uint32 wrapper.  call this and it retrospectively stores the size.
1231  does nothing on reading, as that is already handled by ...._pre()
1232  ********************************************************************/
1233
1234 BOOL prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
1235                                 uint32 ptr_uint32, uint32 data_size)
1236 {
1237         if (MARSHALLING(ps)) {
1238                 /*
1239                  * Writing - temporarily move the offset pointer.
1240                  */
1241                 uint32 old_offset = ps->data_offset;
1242                 ps->data_offset = ptr_uint32;
1243                 if(!prs_uint32(name, ps, depth, &data_size)) {
1244                         ps->data_offset = old_offset;
1245                         return False;
1246                 }
1247                 ps->data_offset = old_offset;
1248         }
1249         return True;
1250 }
1251
1252 /* useful function to store a structure in rpc wire format */
1253 int tdb_prs_store(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
1254 {
1255     TDB_DATA kbuf, dbuf;
1256     kbuf.dptr = keystr;
1257     kbuf.dsize = strlen(keystr)+1;
1258     dbuf.dptr = prs_data_p(ps);
1259     dbuf.dsize = prs_offset(ps);
1260     return tdb_store(tdb, kbuf, dbuf, TDB_REPLACE);
1261 }
1262
1263 /* useful function to fetch a structure into rpc wire format */
1264 int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *mem_ctx)
1265 {
1266     TDB_DATA kbuf, dbuf;
1267     kbuf.dptr = keystr;
1268     kbuf.dsize = strlen(keystr)+1;
1269
1270     dbuf = tdb_fetch(tdb, kbuf);
1271     if (!dbuf.dptr) return -1;
1272
1273     ZERO_STRUCTP(ps);
1274     prs_init(ps, 0, mem_ctx, UNMARSHALL);
1275     prs_give_memory(ps, dbuf.dptr, dbuf.dsize, True);
1276
1277     return 0;
1278 }
1279
1280 /*******************************************************************
1281  hash a stream.
1282  ********************************************************************/
1283 BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
1284 {
1285         char *q;
1286
1287         q = prs_data_p(ps);
1288         q = &q[offset];
1289
1290 #ifdef DEBUG_PASSWORD
1291         DEBUG(100, ("prs_hash1\n"));
1292         dump_data(100, sess_key, 16);
1293         dump_data(100, q, 68);
1294 #endif
1295         SamOEMhash((uchar *) q, sess_key, 68);
1296
1297 #ifdef DEBUG_PASSWORD
1298         dump_data(100, q, 68);
1299 #endif
1300
1301         return True;
1302 }