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 only if required (for the unistr2 string mainly)
 452  ********************************************************************/
 453
 454 BOOL prs_align_needed(prs_struct *ps, uint32 needed)
 455 {
 456         if (needed==0)
 457                 return True;
 458         else
 459                 return prs_align(ps);
 460 }
 461
 462 /*******************************************************************
 463  Ensure we can read/write to a given offset.
 464  ********************************************************************/
 465
 466 char *prs_mem_get(prs_struct *ps, uint32 extra_size)
 467 {
 468         if(UNMARSHALLING(ps)) {
 469                 /*
 470                  * If reading, ensure that we can read the requested size item.
 471                  */
 472                 if (ps->data_offset + extra_size > ps->buffer_size) {
 473                         DEBUG(0,("prs_mem_get: reading data of size %u would overrun buffer.\n",
 474                                         (unsigned int)extra_size ));
 475                         return NULL;
 476                 }
 477         } else {
 478                 /*
 479                  * Writing - grow the buffer if needed.
 480                  */
 481                 if(!prs_grow(ps, extra_size))
 482                         return NULL;
 483         }
 484         return &ps->data_p[ps->data_offset];
 485 }
 486
 487 /*******************************************************************
 488  Change the struct type.
 489  ********************************************************************/
 490
 491 void prs_switch_type(prs_struct *ps, BOOL io)
 492 {
 493         if ((ps->io ^ io) == True)
 494                 ps->io=io;
 495 }
 496
 497 /*******************************************************************
 498  Force a prs_struct to be dynamic even when it's size is 0.
 499  ********************************************************************/
 500
 501 void prs_force_dynamic(prs_struct *ps)
 502 {
 503         ps->is_dynamic=True;
 504 }
 505
 506 /*******************************************************************
 507  Stream a uint8.
 508  ********************************************************************/
 509
 510 BOOL prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
 511 {
 512         char *q = prs_mem_get(ps, 1);
 513         if (q == NULL)
 514                 return False;
 515
 516     if (UNMARSHALLING(ps))
 517                 *data8 = CVAL(q,0);
 518         else
 519                 SCVAL(q,0,*data8);
 520
 521     DEBUG(5,("%s%04x %s: %02x\n", tab_depth(depth), ps->data_offset, name, *data8));
 522
 523         ps->data_offset += 1;
 524
 525         return True;
 526 }
 527
 528 /*******************************************************************
 529  Stream a uint16.
 530  ********************************************************************/
 531
 532 BOOL prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
 533 {
 534         char *q = prs_mem_get(ps, sizeof(uint16));
 535         if (q == NULL)
 536                 return False;
 537
 538     if (UNMARSHALLING(ps)) {
 539                 if (ps->bigendian_data)
 540                         *data16 = RSVAL(q,0);
 541                 else
 542                         *data16 = SVAL(q,0);
 543     } else {
 544                 if (ps->bigendian_data)
 545                         RSSVAL(q,0,*data16);
 546                 else
 547                         SSVAL(q,0,*data16);
 548         }
 549
 550         DEBUG(5,("%s%04x %s: %04x\n", tab_depth(depth), ps->data_offset, name, *data16));
 551
 552         ps->data_offset += sizeof(uint16);
 553
 554         return True;
 555 }
 556
 557 /*******************************************************************
 558  Stream a uint32.
 559  ********************************************************************/
 560
 561 BOOL prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
 562 {
 563         char *q = prs_mem_get(ps, sizeof(uint32));
 564         if (q == NULL)
 565                 return False;
 566
 567         if (UNMARSHALLING(ps)) {
 568                 if (ps->bigendian_data)
 569                         *data32 = RIVAL(q,0);
 570                 else
 571                         *data32 = IVAL(q,0);
 572         } else {
 573                 if (ps->bigendian_data)
 574                         RSIVAL(q,0,*data32);
 575                 else
 576                         SIVAL(q,0,*data32);
 577         }
 578
 579         DEBUG(5,("%s%04x %s: %08x\n", tab_depth(depth), ps->data_offset, name, *data32));
 580
 581         ps->data_offset += sizeof(uint32);
 582
 583         return True;
 584 }
 585
 586 /*******************************************************************
 587  Stream a NTSTATUS
 588  ********************************************************************/
 589
 590 BOOL prs_ntstatus(char *name, prs_struct *ps, int depth, NTSTATUS *status)
 591 {
 592         char *q = prs_mem_get(ps, sizeof(uint32));
 593         if (q == NULL)
 594                 return False;
 595
 596         if (UNMARSHALLING(ps)) {
 597                 if (ps->bigendian_data)
 598                         *status = NT_STATUS(RIVAL(q,0));
 599                 else
 600                         *status = NT_STATUS(IVAL(q,0));
 601         } else {
 602                 if (ps->bigendian_data)
 603                         RSIVAL(q,0,NT_STATUS_V(*status));
 604                 else
 605                         SIVAL(q,0,NT_STATUS_V(*status));
 606         }
 607
 608         DEBUG(5,("%s%04x %s: %s\n", tab_depth(depth), ps->data_offset, name,
 609                  nt_errstr(*status)));
 610
 611         ps->data_offset += sizeof(uint32);
 612
 613         return True;
 614 }
 615
 616 /*******************************************************************
 617  Stream a WERROR
 618  ********************************************************************/
 619
 620 BOOL prs_werror(char *name, prs_struct *ps, int depth, WERROR *status)
 621 {
 622         char *q = prs_mem_get(ps, sizeof(uint32));
 623         if (q == NULL)
 624                 return False;
 625
 626         if (UNMARSHALLING(ps)) {
 627                 if (ps->bigendian_data)
 628                         *status = W_ERROR(RIVAL(q,0));
 629                 else
 630                         *status = W_ERROR(IVAL(q,0));
 631         } else {
 632                 if (ps->bigendian_data)
 633                         RSIVAL(q,0,W_ERROR_V(*status));
 634                 else
 635                         SIVAL(q,0,W_ERROR_V(*status));
 636         }
 637
 638         DEBUG(5,("%s%04x %s: %s\n", tab_depth(depth), ps->data_offset, name,
 639                  dos_errstr(*status)));
 640
 641         ps->data_offset += sizeof(uint32);
 642
 643         return True;
 644 }
 645
 646
 647 /******************************************************************
 648  Stream an array of uint8s. Length is number of uint8s.
 649  ********************************************************************/
 650
 651 BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
 652 {
 653         int i;
 654         char *q = prs_mem_get(ps, len);
 655         if (q == NULL)
 656                 return False;
 657
 658         if (UNMARSHALLING(ps)) {
 659                 for (i = 0; i < len; i++)
 660                         data8s[i] = CVAL(q,i);
 661         } else {
 662                 for (i = 0; i < len; i++)
 663                         SCVAL(q, i, data8s[i]);
 664         }
 665
 666     DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset ,name));
 667     if (charmode)
 668                 print_asc(5, (unsigned char*)data8s, len);
 669         else {
 670         for (i = 0; i < len; i++)
 671                         DEBUG(5,("%02x ", data8s[i]));
 672         }
 673     DEBUG(5,("\n"));
 674
 675         ps->data_offset += len;
 676
 677         return True;
 678 }
 679
 680 /******************************************************************
 681  Stream an array of uint16s. Length is number of uint16s.
 682  ********************************************************************/
 683
 684 BOOL prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
 685 {
 686         int i;
 687         char *q = prs_mem_get(ps, len * sizeof(uint16));
 688         if (q == NULL)
 689                 return False;
 690
 691         if (UNMARSHALLING(ps)) {
 692                 if (ps->bigendian_data) {
 693                         for (i = 0; i < len; i++)
 694                                 data16s[i] = RSVAL(q, 2*i);
 695                 } else {
 696                         for (i = 0; i < len; i++)
 697                                 data16s[i] = SVAL(q, 2*i);
 698                 }
 699         } else {
 700                 if (ps->bigendian_data) {
 701                         for (i = 0; i < len; i++)
 702                                 RSSVAL(q, 2*i, data16s[i]);
 703                 } else {
 704                         for (i = 0; i < len; i++)
 705                                 SSVAL(q, 2*i, data16s[i]);
 706                 }
 707         }
 708
 709         DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
 710         if (charmode)
 711                 print_asc(5, (unsigned char*)data16s, 2*len);
 712         else {
 713                 for (i = 0; i < len; i++)
 714                         DEBUG(5,("%04x ", data16s[i]));
 715         }
 716     DEBUG(5,("\n"));
 717
 718         ps->data_offset += (len * sizeof(uint16));
 719
 720         return True;
 721 }
 722
 723 /******************************************************************
 724  Start using a function for streaming unicode chars. If unmarshalling,
 725  output must be little-endian, if marshalling, input must be little-endian.
 726  ********************************************************************/
 727
 728 static void dbg_rw_punival(BOOL charmode, char *name, int depth, prs_struct *ps,
 729                                                         char *in_buf, char *out_buf, int len)
 730 {
 731         int i;
 732
 733         if (UNMARSHALLING(ps)) {
 734                 if (ps->bigendian_data) {
 735                         for (i = 0; i < len; i++)
 736                                 SSVAL(out_buf,2*i,RSVAL(in_buf, 2*i));
 737                 } else {
 738                         for (i = 0; i < len; i++)
 739                                 SSVAL(out_buf, 2*i, SVAL(in_buf, 2*i));
 740                 }
 741         } else {
 742                 if (ps->bigendian_data) {
 743                         for (i = 0; i < len; i++)
 744                                 RSSVAL(in_buf, 2*i, SVAL(out_buf,2*i));
 745                 } else {
 746                         for (i = 0; i < len; i++)
 747                                 SSVAL(in_buf, 2*i, SVAL(out_buf,2*i));
 748                 }
 749         }
 750
 751         DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
 752         if (charmode)
 753                 print_asc(5, (unsigned char*)out_buf, 2*len);
 754         else {
 755                 for (i = 0; i < len; i++)
 756                         DEBUG(5,("%04x ", out_buf[i]));
 757         }
 758     DEBUG(5,("\n"));
 759 }
 760
 761 /******************************************************************
 762  Stream a unistr. Always little endian.
 763  ********************************************************************/
 764
 765 BOOL prs_uint16uni(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
 766 {
 767         char *q = prs_mem_get(ps, len * sizeof(uint16));
 768         if (q == NULL)
 769                 return False;
 770
 771         dbg_rw_punival(charmode, name, depth, ps, q, (char *)data16s, len);
 772         ps->data_offset += (len * sizeof(uint16));
 773
 774         return True;
 775 }
 776
 777 /******************************************************************
 778  Stream an array of uint32s. Length is number of uint32s.
 779  ********************************************************************/
 780
 781 BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
 782 {
 783         int i;
 784         char *q = prs_mem_get(ps, len * sizeof(uint32));
 785         if (q == NULL)
 786                 return False;
 787
 788         if (UNMARSHALLING(ps)) {
 789                 if (ps->bigendian_data) {
 790                         for (i = 0; i < len; i++)
 791                                 data32s[i] = RIVAL(q, 4*i);
 792                 } else {
 793                         for (i = 0; i < len; i++)
 794                                 data32s[i] = IVAL(q, 4*i);
 795                 }
 796         } else {
 797                 if (ps->bigendian_data) {
 798                         for (i = 0; i < len; i++)
 799                                 RSIVAL(q, 4*i, data32s[i]);
 800                 } else {
 801                         for (i = 0; i < len; i++)
 802                                 SIVAL(q, 4*i, data32s[i]);
 803                 }
 804         }
 805
 806         DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
 807         if (charmode)
 808                 print_asc(5, (unsigned char*)data32s, 4*len);
 809         else {
 810                 for (i = 0; i < len; i++)
 811                         DEBUG(5,("%08x ", data32s[i]));
 812         }
 813     DEBUG(5,("\n"));
 814
 815         ps->data_offset += (len * sizeof(uint32));
 816
 817         return True;
 818 }
 819
 820 /******************************************************************
 821  Stream an array of unicode string, length/buffer specified separately,
 822  in uint16 chars. The unicode string is already in little-endian format.
 823  ********************************************************************/
 824
 825 BOOL prs_buffer5(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER5 *str)
 826 {
 827         char *p;
 828         char *q = prs_mem_get(ps, str->buf_len * sizeof(uint16));
 829         if (q == NULL)
 830                 return False;
 831
 832         if (UNMARSHALLING(ps)) {
 833                 str->buffer = (uint16 *)prs_alloc_mem(ps,str->buf_len * sizeof(uint16));
 834                 if (str->buffer == NULL)
 835                         return False;
 836         }
 837
 838         /* If the string is empty, we don't have anything to stream */
 839         if (str->buf_len==0)
 840                 return True;
 841
 842         p = (char *)str->buffer;
 843
 844         dbg_rw_punival(charmode, name, depth, ps, q, p, str->buf_len);
 845
 846         ps->data_offset += (str->buf_len * sizeof(uint16));
 847
 848         return True;
 849 }
 850
 851 /******************************************************************
 852  Stream a "not" unicode string, length/buffer specified separately,
 853  in byte chars. String is in little-endian format.
 854  ********************************************************************/
 855
 856 BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str)
 857 {
 858         char *p;
 859         char *q = prs_mem_get(ps, str->buf_len);
 860         if (q == NULL)
 861                 return False;
 862
 863         if (UNMARSHALLING(ps)) {
 864                 str->buffer = (uint16 *)prs_alloc_mem(ps,str->buf_len);
 865                 if (str->buffer == NULL)
 866                         return False;
 867         }
 868
 869         p = (char *)str->buffer;
 870
 871         dbg_rw_punival(charmode, name, depth, ps, q, p, str->buf_len/2);
 872         ps->data_offset += str->buf_len;
 873
 874         return True;
 875 }
 876
 877 /******************************************************************
 878  Stream a string, length/buffer specified separately,
 879  in uint8 chars.
 880  ********************************************************************/
 881
 882 BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
 883 {
 884         int i;
 885         char *q = prs_mem_get(ps, str->str_max_len);
 886         if (q == NULL)
 887                 return False;
 888
 889         if (UNMARSHALLING(ps)) {
 890                 str->buffer = (unsigned char *)prs_alloc_mem(ps,str->str_max_len);
 891                 if (str->buffer == NULL)
 892                         return False;
 893         }
 894
 895         if (UNMARSHALLING(ps)) {
 896                 for (i = 0; i < str->str_str_len; i++)
 897                         str->buffer[i] = CVAL(q,i);
 898         } else {
 899                 for (i = 0; i < str->str_str_len; i++)
 900                         SCVAL(q, i, str->buffer[i]);
 901         }
 902
 903     DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
 904     if (charmode)
 905                 print_asc(5, (unsigned char*)str->buffer, str->str_str_len);
 906         else {
 907         for (i = 0; i < str->str_str_len; i++)
 908                         DEBUG(5,("%02x ", str->buffer[i]));
 909         }
 910     DEBUG(5,("\n"));
 911
 912         ps->data_offset += str->str_str_len;
 913
 914         return True;
 915 }
 916
 917 /******************************************************************
 918  Stream a unicode string, length/buffer specified separately,
 919  in uint16 chars. The unicode string is already in little-endian format.
 920  ********************************************************************/
 921
 922 BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
 923 {
 924         char *p;
 925         char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
 926         if (q == NULL)
 927                 return False;
 928
 929         /* If the string is empty, we don't have anything to stream */
 930         if (str->uni_str_len==0)
 931                 return True;
 932
 933         if (UNMARSHALLING(ps)) {
 934                 str->buffer = (uint16 *)prs_alloc_mem(ps,str->uni_max_len * sizeof(uint16));
 935                 if (str->buffer == NULL)
 936                         return False;
 937         }
 938
 939         p = (char *)str->buffer;
 940
 941         dbg_rw_punival(charmode, name, depth, ps, q, p, str->uni_str_len);
 942
 943         ps->data_offset += (str->uni_str_len * sizeof(uint16));
 944
 945         return True;
 946 }
 947
 948 /******************************************************************
 949  Stream a unicode string, length/buffer specified separately,
 950  in uint16 chars. The unicode string is already in little-endian format.
 951  ********************************************************************/
 952
 953 BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
 954 {
 955         char *p;
 956         char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
 957         if (q == NULL)
 958                 return False;
 959
 960         if (UNMARSHALLING(ps)) {
 961                 str->str.buffer = (uint16 *)prs_alloc_mem(ps,str->uni_str_len * sizeof(uint16));
 962                 if (str->str.buffer == NULL)
 963                         return False;
 964         }
 965
 966         p = (char *)str->str.buffer;
 967
 968         dbg_rw_punival(charmode, name, depth, ps, q, p, str->uni_str_len);
 969         ps->data_offset += (str->uni_str_len * sizeof(uint16));
 970
 971         return True;
 972 }
 973
 974 /*******************************************************************
 975  Stream a unicode  null-terminated string. As the string is already
 976  in little-endian format then do it as a stream of bytes.
 977  ********************************************************************/
 978
 979 BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 980 {
 981         int len = 0;
 982         unsigned char *p = (unsigned char *)str->buffer;
 983         uint8 *start;
 984         char *q;
 985         uint32 max_len;
 986         uint16* ptr;
 987
 988         if (MARSHALLING(ps)) {
 989
 990                 for(len = 0; str->buffer[len] != 0; len++)
 991                         ;
 992
 993                 q = prs_mem_get(ps, (len+1)*2);
 994                 if (q == NULL)
 995                         return False;
 996
 997                 start = (uint8*)q;
 998
 999                 for(len = 0; str->buffer[len] != 0; len++)
1000                 {
1001                         if(ps->bigendian_data)
1002                         {
1003                                 /* swap bytes - p is little endian, q is big endian. */
1004                                 q[0] = (char)p[1];
1005                                 q[1] = (char)p[0];
1006                                 p += 2;
1007                                 q += 2;
1008                         }
1009                         else
1010                         {
1011                                 q[0] = (char)p[0];
1012                                 q[1] = (char)p[1];
1013                                 p += 2;
1014                                 q += 2;
1015                         }
1016                 }
1017
1018                 /*
1019                  * even if the string is 'empty' (only an \0 char)
1020                  * at this point the leading \0 hasn't been parsed.
1021                  * so parse it now
1022                  */
1023
1024                 q[0] = 0;
1025                 q[1] = 0;
1026                 q += 2;
1027
1028                 len++;
1029
1030                 dump_data(5+depth, (char *)start, len * 2);
1031         }
1032         else { /* unmarshalling */
1033
1034                 uint32 alloc_len = 0;
1035                 q = prs_data_p(ps) + prs_offset(ps);
1036
1037                 /*
1038                  * Work out how much space we need and talloc it.
1039                  */
1040                 max_len = (ps->buffer_size - ps->data_offset)/sizeof(uint16);
1041
1042                 /* the test of the value of *ptr helps to catch the circumstance
1043                    where we have an emtpty (non-existent) string in the buffer */
1044                 for ( ptr = (uint16 *)q; *ptr && (alloc_len <= max_len); alloc_len++)
1045                         /* do nothing */
1046                         ;
1047
1048                 /* should we allocate anything at all? */
1049                 str->buffer = (uint16 *)prs_alloc_mem(ps,alloc_len * sizeof(uint16));
1050                 if ((str->buffer == NULL) && (alloc_len > 0))
1051                         return False;
1052
1053                 p = (unsigned char *)str->buffer;
1054
1055                 len = 0;
1056                 /* the (len < alloc_len) test is to prevent us from overwriting
1057                    memory that is not ours...if we get that far, we have a non-null
1058                    terminated string in the buffer and have messed up somewhere */
1059                 while ((len < alloc_len) && (*(uint16 *)q != 0))
1060                 {
1061                         if(ps->bigendian_data)
1062                         {
1063                                 /* swap bytes - q is big endian, p is little endian. */
1064                                 p[0] = (unsigned char)q[1];
1065                                 p[1] = (unsigned char)q[0];
1066                                 p += 2;
1067                                 q += 2;
1068                         } else {
1069
1070                                 p[0] = (unsigned char)q[0];
1071                                 p[1] = (unsigned char)q[1];
1072                                 p += 2;
1073                                 q += 2;
1074                         }
1075
1076                         len++;
1077                 }
1078                 if (len < alloc_len)
1079                 {
1080                         /* NULL terminate the UNISTR */
1081                         str->buffer[len++] = '\0';
1082                 }
1083         }
1084
1085         /* set the offset in the prs_struct; 'len' points to the
1086            terminiating NULL in the UNISTR so we need to go one more
1087            uint16 */
1088         ps->data_offset += (len)*2;
1089
1090         return True;
1091 }
1092
1093
1094 /*******************************************************************
1095  Stream a null-terminated string.  len is strlen, and therefore does
1096  not include the null-termination character.
1097  ********************************************************************/
1098
1099 BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, int len, int max_buf_size)
1100 {
1101         char *q;
1102         int i;
1103
1104         len = MIN(len, (max_buf_size-1));
1105
1106         q = prs_mem_get(ps, len+1);
1107         if (q == NULL)
1108                 return False;
1109
1110         for(i = 0; i < len; i++) {
1111                 if (UNMARSHALLING(ps))
1112                         str[i] = q[i];
1113                 else
1114                         q[i] = str[i];
1115         }
1116
1117         /* The terminating null. */
1118         str[i] = '\0';
1119
1120         if (MARSHALLING(ps)) {
1121                 q[i] = '\0';
1122         }
1123
1124         ps->data_offset += len+1;
1125
1126         dump_data(5+depth, q, len);
1127
1128         return True;
1129 }
1130
1131 /*******************************************************************
1132  prs_uint16 wrapper. Call this and it sets up a pointer to where the
1133  uint16 should be stored, or gets the size if reading.
1134  ********************************************************************/
1135
1136 BOOL prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
1137 {
1138         *offset = ps->data_offset;
1139         if (UNMARSHALLING(ps)) {
1140                 /* reading. */
1141                 return prs_uint16(name, ps, depth, data16);
1142         } else {
1143                 char *q = prs_mem_get(ps, sizeof(uint16));
1144                 if(q ==NULL)
1145                         return False;
1146                 ps->data_offset += sizeof(uint16);
1147         }
1148         return True;
1149 }
1150
1151 /*******************************************************************
1152  prs_uint16 wrapper.  call this and it retrospectively stores the size.
1153  does nothing on reading, as that is already handled by ...._pre()
1154  ********************************************************************/
1155
1156 BOOL prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
1157                                 uint32 ptr_uint16, uint32 start_offset)
1158 {
1159         if (MARSHALLING(ps)) {
1160                 /*
1161                  * Writing - temporarily move the offset pointer.
1162                  */
1163                 uint16 data_size = ps->data_offset - start_offset;
1164                 uint32 old_offset = ps->data_offset;
1165
1166                 ps->data_offset = ptr_uint16;
1167                 if(!prs_uint16(name, ps, depth, &data_size)) {
1168                         ps->data_offset = old_offset;
1169                         return False;
1170                 }
1171                 ps->data_offset = old_offset;
1172         } else {
1173                 ps->data_offset = start_offset + (uint32)(*data16);
1174         }
1175         return True;
1176 }
1177
1178 /*******************************************************************
1179  prs_uint32 wrapper. Call this and it sets up a pointer to where the
1180  uint32 should be stored, or gets the size if reading.
1181  ********************************************************************/
1182
1183 BOOL prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
1184 {
1185         *offset = ps->data_offset;
1186         if (UNMARSHALLING(ps) && (data32 != NULL)) {
1187                 /* reading. */
1188                 return prs_uint32(name, ps, depth, data32);
1189         } else {
1190                 ps->data_offset += sizeof(uint32);
1191         }
1192         return True;
1193 }
1194
1195 /*******************************************************************
1196  prs_uint32 wrapper.  call this and it retrospectively stores the size.
1197  does nothing on reading, as that is already handled by ...._pre()
1198  ********************************************************************/
1199
1200 BOOL prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
1201                                 uint32 ptr_uint32, uint32 data_size)
1202 {
1203         if (MARSHALLING(ps)) {
1204                 /*
1205                  * Writing - temporarily move the offset pointer.
1206                  */
1207                 uint32 old_offset = ps->data_offset;
1208                 ps->data_offset = ptr_uint32;
1209                 if(!prs_uint32(name, ps, depth, &data_size)) {
1210                         ps->data_offset = old_offset;
1211                         return False;
1212                 }
1213                 ps->data_offset = old_offset;
1214         }
1215         return True;
1216 }
1217
1218 /* useful function to store a structure in rpc wire format */
1219 int tdb_prs_store(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
1220 {
1221     TDB_DATA kbuf, dbuf;
1222     kbuf.dptr = keystr;
1223     kbuf.dsize = strlen(keystr)+1;
1224     dbuf.dptr = prs_data_p(ps);
1225     dbuf.dsize = prs_offset(ps);
1226     return tdb_store(tdb, kbuf, dbuf, TDB_REPLACE);
1227 }
1228
1229 /* useful function to fetch a structure into rpc wire format */
1230 int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *mem_ctx)
1231 {
1232     TDB_DATA kbuf, dbuf;
1233     kbuf.dptr = keystr;
1234     kbuf.dsize = strlen(keystr)+1;
1235
1236     dbuf = tdb_fetch(tdb, kbuf);
1237     if (!dbuf.dptr) return -1;
1238
1239     ZERO_STRUCTP(ps);
1240     prs_init(ps, 0, mem_ctx, UNMARSHALL);
1241     prs_give_memory(ps, dbuf.dptr, dbuf.dsize, True);
1242
1243     return 0;
1244 }
1245
1246 /*******************************************************************
1247  hash a stream.
1248  ********************************************************************/
1249 BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
1250 {
1251         char *q;
1252
1253         q = prs_data_p(ps);
1254         q = &q[offset];
1255
1256 #ifdef DEBUG_PASSWORD
1257         DEBUG(100, ("prs_hash1\n"));
1258         dump_data(100, sess_key, 16);
1259         dump_data(100, q, 68);
1260 #endif
1261         SamOEMhash((uchar *) q, sess_key, 68);
1262
1263 #ifdef DEBUG_PASSWORD
1264         dump_data(100, q, 68);
1265 #endif
1266
1267         return True;
1268 }