source/rpc_parse/parse_prs.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Samba memory buffer functions
   5    Copyright (C) Andrew Tridgell              1992-1997
   6    Copyright (C) Luke Kenneth Casson Leighton 1996-1997
   7    Copyright (C) Jeremy Allison 1999.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 extern int DEBUGLEVEL;
  25
  26 #include "includes.h"
  27
  28
  29 /*******************************************************************
  30 dump a prs to a file
  31  ********************************************************************/
  32 void prs_dump(char *name, int v, prs_struct *ps)
  33 {
  34         int fd, i;
  35         pstring fname;
  36         if (DEBUGLEVEL < 50) return;
  37         for (i=1;i<100;i++) {
  38                 if (v != -1) {
  39                         slprintf(fname,sizeof(fname), "/tmp/%s_%d.%d.prs", name, v, i);
  40                 } else {
  41                         slprintf(fname,sizeof(fname), "/tmp/%s.%d.prs", name, i);
  42                 }
  43                 fd = open(fname, O_WRONLY|O_CREAT|O_EXCL, 0644);
  44                 if (fd != -1 || errno != EEXIST) break;
  45         }
  46         if (fd != -1) {
  47                 write(fd, ps->data_p + ps->data_offset, ps->buffer_size - ps->data_offset);
  48                 close(fd);
  49                 DEBUG(0,("created %s\n", fname));
  50         }
  51 }
  52
  53
  54
  55 /*******************************************************************
  56  debug output for parsing info.
  57
  58  XXXX side-effect of this function is to increase the debug depth XXXX
  59
  60  ********************************************************************/
  61 void prs_debug(prs_struct *ps, int depth, char *desc, char *fn_name)
  62 {
  63         DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(depth), ps->data_offset, fn_name, desc));
  64 }
  65
  66
  67 /*******************************************************************
  68  Initialise a parse structure - malloc the data if requested.
  69  ********************************************************************/
  70 BOOL prs_init(prs_struct *ps, uint32 size, uint8 align, TALLOC_CTX *ctx, BOOL io)
  71 {
  72         ZERO_STRUCTP(ps);
  73         ps->io = io;
  74         ps->bigendian_data = False;
  75         ps->align = align;
  76         ps->is_dynamic = False;
  77         ps->data_offset = 0;
  78         ps->buffer_size = 0;
  79         ps->data_p = NULL;
  80         ps->mem_ctx = ctx;
  81
  82         if (size != 0) {
  83                 ps->buffer_size = size;
  84                 if((ps->data_p = (char *)malloc((size_t)size)) == NULL) {
  85                         DEBUG(0,("prs_init: malloc fail for %u bytes.\n", (unsigned int)size));
  86                         return False;
  87                 }
  88                 ps->is_dynamic = True; /* We own this memory. */
  89         }
  90
  91         return True;
  92 }
  93
  94 /*******************************************************************
  95  read from a socket into memory.
  96  ********************************************************************/
  97 BOOL prs_read(prs_struct *ps, int fd, size_t len, int timeout)
  98 {
  99         BOOL ok;
 100         size_t prev_size = ps->buffer_size;
 101         if (!prs_grow(ps, len))
 102                 return False;
 103
 104         if (timeout > 0) {
 105                 ok = (read_with_timeout(fd, &ps->data_p[prev_size],
 106                                             len, len,timeout) == len);
 107         } else {
 108                 ok = (read_data(fd, &ps->data_p[prev_size], len) == len);
 109         }
 110         return ok;
 111 }
 112
 113 /*******************************************************************
 114  Delete the memory in a parse structure - if we own it.
 115  ********************************************************************/
 116
 117 void prs_mem_free(prs_struct *ps)
 118 {
 119         if(ps->is_dynamic && (ps->data_p != NULL))
 120                 free(ps->data_p);
 121         ps->is_dynamic = False;
 122         ps->data_p = NULL;
 123         ps->buffer_size = 0;
 124         ps->data_offset = 0;
 125 }
 126
 127 /*******************************************************************
 128  Allocate memory when unmarshalling... Always zero clears.
 129  ********************************************************************/
 130
 131 char *prs_alloc_mem(prs_struct *ps, size_t size)
 132 {
 133         char *ret = talloc(ps->mem_ctx, size);
 134
 135         if (ret)
 136                 memset(ret, '\0', size);
 137
 138         return ret;
 139 }
 140
 141 /*******************************************************************
 142  Return the current talloc context we're using.
 143  ********************************************************************/
 144
 145 TALLOC_CTX *prs_get_mem_context(prs_struct *ps)
 146 {
 147         return ps->mem_ctx;
 148 }
 149
 150 /*******************************************************************
 151  Hand some already allocated memory to a prs_struct.
 152  ********************************************************************/
 153
 154 void prs_give_memory(prs_struct *ps, char *buf, uint32 size, BOOL is_dynamic)
 155 {
 156         ps->is_dynamic = is_dynamic;
 157         ps->data_p = buf;
 158         ps->buffer_size = size;
 159 }
 160
 161 /*******************************************************************
 162  Take some memory back from a prs_struct.
 163  ********************************************************************/
 164
 165 char *prs_take_memory(prs_struct *ps, uint32 *psize)
 166 {
 167         char *ret = ps->data_p;
 168         if(psize)
 169                 *psize = ps->buffer_size;
 170         ps->is_dynamic = False;
 171         prs_mem_free(ps);
 172         return ret;
 173 }
 174
 175 /*******************************************************************
 176  Set a prs_struct to exactly a given size. Will grow or tuncate if neccessary.
 177  ********************************************************************/
 178
 179 BOOL prs_set_buffer_size(prs_struct *ps, uint32 newsize)
 180 {
 181         if (newsize > ps->buffer_size)
 182                 return prs_force_grow(ps, newsize - ps->buffer_size);
 183
 184         if (newsize < ps->buffer_size) {
 185                 char *new_data_p = Realloc(ps->data_p, newsize);
 186                 /* if newsize is zero, Realloc acts like free() & returns NULL*/
 187                 if (new_data_p == NULL && newsize != 0) {
 188                         DEBUG(0,("prs_set_buffer_size: Realloc failure for size %u.\n",
 189                                 (unsigned int)newsize));
 190                         DEBUG(0,("prs_set_buffer_size: Reason %s\n",strerror(errno)));
 191                         return False;
 192                 }
 193                 ps->data_p = new_data_p;
 194                 ps->buffer_size = newsize;
 195         }
 196
 197         return True;
 198 }
 199
 200 /*******************************************************************
 201  Attempt, if needed, to grow a data buffer.
 202  Also depends on the data stream mode (io).
 203  ********************************************************************/
 204
 205 BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 206 {
 207         uint32 new_size;
 208         char *new_data;
 209
 210         ps->grow_size = MAX(ps->grow_size, ps->data_offset + extra_space);
 211
 212         if(ps->data_offset + extra_space <= ps->buffer_size)
 213                 return True;
 214
 215         /*
 216          * We cannot grow the buffer if we're not reading
 217          * into the prs_struct, or if we don't own the memory.
 218          */
 219
 220         if(UNMARSHALLING(ps) || !ps->is_dynamic) {
 221                 DEBUG(0,("prs_grow: Buffer overflow - unable to expand buffer by %u bytes.\n",
 222                                 (unsigned int)extra_space));
 223                 return False;
 224         }
 225
 226         /*
 227          * Decide how much extra space we really need.
 228          */
 229
 230         extra_space -= (ps->buffer_size - ps->data_offset);
 231         if(ps->buffer_size == 0) {
 232                 /*
 233                  * Ensure we have at least a PDU's length, or extra_space, whichever
 234                  * is greater.
 235                  */
 236
 237                 new_size = MAX(MAX_PDU_FRAG_LEN,extra_space);
 238
 239                 if((new_data = malloc(new_size)) == NULL) {
 240                         DEBUG(0,("prs_grow: Malloc failure for size %u.\n", (unsigned int)new_size));
 241                         return False;
 242                 }
 243                 memset(new_data, '\0', new_size );
 244         } else {
 245                 /*
 246                  * If the current buffer size is bigger than the space needed, just
 247                  * double it, else add extra_space.
 248                  */
 249                 new_size = MAX(ps->buffer_size*2, ps->buffer_size + extra_space);
 250
 251                 if ((new_data = Realloc(ps->data_p, new_size)) == NULL) {
 252                         DEBUG(0,("prs_grow: Realloc failure for size %u.\n",
 253                                 (unsigned int)new_size));
 254                         return False;
 255                 }
 256
 257                 memset(&new_data[ps->buffer_size], '\0', new_size - ps->buffer_size);
 258         }
 259         ps->buffer_size = new_size;
 260         ps->data_p = new_data;
 261
 262         return True;
 263 }
 264
 265 /*******************************************************************
 266  Attempt to force a data buffer to grow by len bytes.
 267  This is only used when appending more data onto a prs_struct
 268  when reading an rpc reply, before unmarshalling it.
 269  ********************************************************************/
 270
 271 BOOL prs_force_grow(prs_struct *ps, uint32 extra_space)
 272 {
 273         uint32 new_size = ps->buffer_size + extra_space;
 274         char *new_data;
 275
 276         if(!UNMARSHALLING(ps) || !ps->is_dynamic) {
 277                 DEBUG(0,("prs_force_grow: Buffer overflow - unable to expand buffer by %u bytes.\n",
 278                                 (unsigned int)extra_space));
 279                 return False;
 280         }
 281
 282         if((new_data = Realloc(ps->data_p, new_size)) == NULL) {
 283                 DEBUG(0,("prs_force_grow: Realloc failure for size %u.\n",
 284                         (unsigned int)new_size));
 285                 return False;
 286         }
 287
 288         memset(&new_data[ps->buffer_size], '\0', new_size - ps->buffer_size);
 289
 290         ps->buffer_size = new_size;
 291         ps->data_p = new_data;
 292
 293         return True;
 294 }
 295
 296 /*******************************************************************
 297  Get the data pointer (external interface).
 298  ********************************************************************/
 299
 300 char *prs_data_p(prs_struct *ps)
 301 {
 302         return ps->data_p;
 303 }
 304
 305 /*******************************************************************
 306  Get the current data size (external interface).
 307  ********************************************************************/
 308
 309 uint32 prs_data_size(prs_struct *ps)
 310 {
 311         return ps->buffer_size;
 312 }
 313
 314 /*******************************************************************
 315  Fetch the current offset (external interface).
 316  ********************************************************************/
 317
 318 uint32 prs_offset(prs_struct *ps)
 319 {
 320         return ps->data_offset;
 321 }
 322
 323 /*******************************************************************
 324  Set the current offset (external interface).
 325  ********************************************************************/
 326
 327 BOOL prs_set_offset(prs_struct *ps, uint32 offset)
 328 {
 329         if(offset <= ps->data_offset) {
 330                 ps->data_offset = offset;
 331                 return True;
 332         }
 333
 334         if(!prs_grow(ps, offset - ps->data_offset))
 335                 return False;
 336
 337         ps->data_offset = offset;
 338         return True;
 339 }
 340
 341 /*******************************************************************
 342  Append the data from one parse_struct into another.
 343  ********************************************************************/
 344
 345 BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
 346 {
 347         if(!prs_grow(dst, prs_offset(src)))
 348                 return False;
 349
 350         memcpy(&dst->data_p[dst->data_offset], prs_data_p(src), (size_t)prs_offset(src));
 351         dst->data_offset += prs_offset(src);
 352
 353         return True;
 354 }
 355
 356 /*******************************************************************
 357  Append some data from one parse_struct into another.
 358  ********************************************************************/
 359
 360 BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uint32 len)
 361 {
 362         if (len == 0)
 363                 return True;
 364
 365         if(!prs_grow(dst, len))
 366                 return False;
 367
 368         memcpy(&dst->data_p[dst->data_offset], prs_data_p(src)+start, (size_t)len);
 369         dst->data_offset += len;
 370
 371         return True;
 372 }
 373
 374 /*******************************************************************
 375  Append the data from a buffer into a parse_struct.
 376  ********************************************************************/
 377
 378 BOOL prs_append_data(prs_struct *dst, char *src, uint32 len)
 379 {
 380         if(!prs_grow(dst, len))
 381                 return False;
 382
 383         memcpy(&dst->data_p[dst->data_offset], src, (size_t)len);
 384         dst->data_offset += len;
 385
 386         return True;
 387 }
 388
 389 /*******************************************************************
 390  Set the data as big-endian (external interface).
 391  ********************************************************************/
 392
 393 void prs_set_bigendian_data(prs_struct *ps)
 394 {
 395         ps->bigendian_data = True;
 396 }
 397
 398 /*******************************************************************
 399  Align a the data_len to a multiple of align bytes - filling with
 400  zeros.
 401  ********************************************************************/
 402
 403 BOOL prs_align(prs_struct *ps)
 404 {
 405         uint32 mod = ps->data_offset & (ps->align-1);
 406
 407         if (ps->align != 0 && mod != 0) {
 408                 uint32 extra_space = (ps->align - mod);
 409                 if(!prs_grow(ps, extra_space))
 410                         return False;
 411                 memset(&ps->data_p[ps->data_offset], '\0', (size_t)extra_space);
 412                 ps->data_offset += extra_space;
 413         }
 414
 415         return True;
 416 }
 417
 418 /*******************************************************************
 419  Align only if required (for the unistr2 string mainly)
 420  ********************************************************************/
 421
 422 BOOL prs_align_needed(prs_struct *ps, uint32 needed)
 423 {
 424         if (needed==0)
 425                 return True;
 426         else
 427                 return prs_align(ps);
 428 }
 429
 430 /*******************************************************************
 431  Ensure we can read/write to a given offset.
 432  ********************************************************************/
 433
 434 char *prs_mem_get(prs_struct *ps, uint32 extra_size)
 435 {
 436         if(UNMARSHALLING(ps)) {
 437                 /*
 438                  * If reading, ensure that we can read the requested size item.
 439                  */
 440                 if (ps->data_offset + extra_size > ps->buffer_size) {
 441                         DEBUG(0,("prs_mem_get: reading data of size %u would overrun buffer.\n",
 442                                         (unsigned int)extra_size ));
 443                         return NULL;
 444                 }
 445         } else {
 446                 /*
 447                  * Writing - grow the buffer if needed.
 448                  */
 449                 if(!prs_grow(ps, extra_size))
 450                         return NULL;
 451         }
 452         return &ps->data_p[ps->data_offset];
 453 }
 454
 455 /*******************************************************************
 456  Change the struct type.
 457  ********************************************************************/
 458
 459 void prs_switch_type(prs_struct *ps, BOOL io)
 460 {
 461         if ((ps->io ^ io) == True)
 462                 ps->io=io;
 463 }
 464
 465 /*******************************************************************
 466  Force a prs_struct to be dynamic even when it's size is 0.
 467  ********************************************************************/
 468
 469 void prs_force_dynamic(prs_struct *ps)
 470 {
 471         ps->is_dynamic=True;
 472 }
 473
 474 /*******************************************************************
 475  Stream a uint8.
 476  ********************************************************************/
 477
 478 BOOL prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
 479 {
 480         char *q = prs_mem_get(ps, sizeof(uint8));
 481         if (q == NULL)
 482                 return False;
 483
 484         DBG_RW_CVAL(name, depth, ps->data_offset, ps->io, q, *data8)
 485         ps->data_offset += sizeof(uint8);
 486
 487         return True;
 488 }
 489
 490 /*******************************************************************
 491  Stream a uint16.
 492  ********************************************************************/
 493
 494 BOOL prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
 495 {
 496         char *q = prs_mem_get(ps, sizeof(uint16));
 497         if (q == NULL)
 498                 return False;
 499
 500         DBG_RW_SVAL(name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, *data16)
 501         ps->data_offset += sizeof(uint16);
 502
 503         return True;
 504 }
 505
 506 /*******************************************************************
 507  Stream a uint32.
 508  ********************************************************************/
 509
 510 BOOL prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
 511 {
 512         char *q = prs_mem_get(ps, sizeof(uint32));
 513         if (q == NULL)
 514                 return False;
 515
 516         DBG_RW_IVAL(name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, *data32)
 517         ps->data_offset += sizeof(uint32);
 518
 519         return True;
 520 }
 521
 522 /******************************************************************
 523  Stream an array of uint8s. Length is number of uint8s.
 524  ********************************************************************/
 525
 526 BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
 527 {
 528         char *q = prs_mem_get(ps, len * sizeof(uint8));
 529         if (q == NULL)
 530                 return False;
 531
 532         DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, data8s, len)
 533         ps->data_offset += (len * sizeof(uint8));
 534
 535         return True;
 536 }
 537
 538 /******************************************************************
 539  Stream an array of uint16s. Length is number of uint16s.
 540  ********************************************************************/
 541
 542 BOOL prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
 543 {
 544         char *q = prs_mem_get(ps, len * sizeof(uint16));
 545         if (q == NULL)
 546                 return False;
 547
 548         DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, data16s, len)
 549         ps->data_offset += (len * sizeof(uint16));
 550
 551         return True;
 552 }
 553
 554 /******************************************************************
 555  Stream an array of uint32s. Length is number of uint32s.
 556  ********************************************************************/
 557
 558 BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
 559 {
 560         char *q = prs_mem_get(ps, len * sizeof(uint32));
 561         if (q == NULL)
 562                 return False;
 563
 564         DBG_RW_PIVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, data32s, len)
 565         ps->data_offset += (len * sizeof(uint32));
 566
 567         return True;
 568 }
 569
 570 /******************************************************************
 571  Stream an array of unicode string, length/buffer specified separately,
 572  in uint16 chars. We use DBG_RW_PCVAL, not DBG_RW_PSVAL here
 573  as the unicode string is already in little-endian format.
 574  ********************************************************************/
 575
 576 BOOL prs_buffer5(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER5 *str)
 577 {
 578         char *p;
 579         char *q = prs_mem_get(ps, str->buf_len * sizeof(uint16));
 580         if (q == NULL)
 581                 return False;
 582
 583         if (UNMARSHALLING(ps)) {
 584                 str->buffer = (uint16 *)prs_alloc_mem(ps,str->buf_len * sizeof(uint16));
 585                 if (str->buffer == NULL)
 586                         return False;
 587                 memset(str->buffer, '\0', str->buf_len * sizeof(uint16));
 588         }
 589
 590         /* If the string is empty, we don't have anything to stream */
 591         if (str->buf_len==0)
 592                 return True;
 593
 594         p = (char *)str->buffer;
 595
 596         /* If we're using big-endian, reverse to get little-endian. */
 597         if(ps->bigendian_data) {
 598                 DBG_RW_PSVAL(charmode, name, depth, ps->data_offset,
 599                              ps->io, ps->bigendian_data, q, p,
 600                              str->buf_len)
 601         } else {
 602                 DBG_RW_PCVAL(charmode, name, depth, ps->data_offset,
 603                              ps->io, q, p, str->buf_len * sizeof(uint16))
 604         }
 605
 606         ps->data_offset += (str->buf_len * sizeof(uint16));
 607
 608         return True;
 609 }
 610
 611 /******************************************************************
 612  Stream a "not" unicode string, length/buffer specified separately,
 613  in byte chars. String is in little-endian format.
 614  ********************************************************************/
 615
 616 BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str)
 617 {
 618         char *p;
 619         char *q = prs_mem_get(ps, str->buf_len);
 620         if (q == NULL)
 621                 return False;
 622
 623         if (UNMARSHALLING(ps)) {
 624                 str->buffer = (uint16 *)prs_alloc_mem(ps,str->buf_len);
 625                 if (str->buffer == NULL)
 626                         return False;
 627         }
 628
 629         p = (char *)str->buffer;
 630
 631         /* If we're using big-endian, reverse to get little-endian. */
 632         if(ps->bigendian_data)
 633                 DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, p, str->buf_len/2)
 634         else
 635                 DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, p, str->buf_len)
 636         ps->data_offset += str->buf_len;
 637
 638         return True;
 639 }
 640
 641 /******************************************************************
 642  Stream a string, length/buffer specified separately,
 643  in uint8 chars.
 644  ********************************************************************/
 645
 646 BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
 647 {
 648         char *q = prs_mem_get(ps, str->str_str_len * sizeof(uint8));
 649         if (q == NULL)
 650                 return False;
 651
 652         if (UNMARSHALLING(ps)) {
 653                 str->buffer = (unsigned char *)prs_alloc_mem(ps,str->str_str_len);
 654                 if (str->buffer == NULL)
 655                         return False;
 656         }
 657
 658         DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, str->buffer, str->str_max_len)
 659         ps->data_offset += (str->str_str_len * sizeof(uint8));
 660
 661         return True;
 662 }
 663
 664 /******************************************************************
 665  Stream a unicode string, length/buffer specified separately,
 666  in uint16 chars. We use DBG_RW_PCVAL, not DBG_RW_PSVAL here
 667  as the unicode string is already in little-endian format.
 668  ********************************************************************/
 669
 670 BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
 671 {
 672         char *p;
 673         char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
 674         if (q == NULL)
 675                 return False;
 676
 677         if (UNMARSHALLING(ps)) {
 678                 str->buffer = (uint16 *)prs_alloc_mem(ps,str->uni_max_len * sizeof(uint16));
 679                 if (str->buffer == NULL)
 680                         return False;
 681                 memset(str->buffer, '\0', str->uni_max_len * sizeof(uint16));
 682         }
 683
 684         /* If the string is empty, we don't have anything to stream */
 685         if (str->uni_str_len==0)
 686                 return True;
 687
 688         p = (char *)str->buffer;
 689
 690         /* If we're using big-endian, reverse to get little-endian. */
 691         if(ps->bigendian_data) {
 692                 DBG_RW_PSVAL(charmode, name, depth, ps->data_offset,
 693                              ps->io, ps->bigendian_data, q, p,
 694                              str->uni_str_len)
 695         } else {
 696                 DBG_RW_PCVAL(charmode, name, depth, ps->data_offset,
 697                              ps->io, q, p, str->uni_str_len * sizeof(uint16))
 698         }
 699
 700         ps->data_offset += (str->uni_str_len * sizeof(uint16));
 701
 702         return True;
 703 }
 704
 705
 706
 707 /******************************************************************
 708  Stream a unicode string, length/buffer specified separately,
 709  in uint16 chars. We use DBG_RW_PCVAL, not DBG_RW_PSVAL here
 710  as the unicode string is already in little-endian format.
 711  ********************************************************************/
 712
 713 BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
 714 {
 715         char *p;
 716         char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
 717         if (q == NULL)
 718                 return False;
 719
 720         if (UNMARSHALLING(ps)) {
 721                 str->str.buffer = (uint16 *)prs_alloc_mem(ps,str->uni_str_len * sizeof(uint16));
 722                 if (str->str.buffer == NULL)
 723                         return False;
 724         }
 725
 726         p = (char *)str->str.buffer;
 727
 728         /* If we're using big-endian, reverse to get little-endian. */
 729         if(ps->bigendian_data)
 730                 DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, p, str->uni_str_len)
 731         else
 732                 DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, p, str->uni_str_len * sizeof(uint16))
 733         ps->data_offset += (str->uni_str_len * sizeof(uint16));
 734
 735         return True;
 736 }
 737
 738 /*******************************************************************
 739  Stream a unicode  null-terminated string. As the string is already
 740  in little-endian format then do it as a stream of bytes.
 741  ********************************************************************/
 742
 743 BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 744 {
 745         int len = 0;
 746         unsigned char *p = (unsigned char *)str->buffer;
 747         uint8 *start;
 748         char *q;
 749         char zero=0;
 750         uint32 max_len;
 751         uint16* ptr;
 752
 753         if (MARSHALLING(ps)) {
 754
 755                 for(len = 0; str->buffer[len] != 0; len++)
 756                         ;
 757
 758                 q = prs_mem_get(ps, (len+1)*2);
 759                 if (q == NULL)
 760                         return False;
 761
 762                 start = (uint8*)q;
 763
 764                 for(len = 0; str->buffer[len] != 0; len++)
 765                 {
 766                         if(ps->bigendian_data)
 767                         {
 768                                 RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0);
 769                                 p += 2;
 770                                 q += 2;
 771                         }
 772                         else
 773                         {
 774                                 RW_CVAL(ps->io, q, *p, 0);
 775                                 p++;
 776                                 q++;
 777                                 RW_CVAL(ps->io, q, *p, 0);
 778                                 p++;
 779                                 q++;
 780                         }
 781                 }
 782
 783                 /*
 784                  * even if the string is 'empty' (only an \0 char)
 785                  * at this point the leading \0 hasn't been parsed.
 786                  * so parse it now
 787                  */
 788
 789                 RW_CVAL(ps->io, q, zero, 0);
 790                 q++;
 791                 RW_CVAL(ps->io, q, zero, 0);
 792                 q++;
 793
 794                 len++;
 795
 796                 dump_data(5+depth, (char *)start, len * 2);
 797         }
 798         else { /* unmarshalling */
 799
 800                 uint32 alloc_len = 0;
 801                 q = prs_data_p(ps) + prs_offset(ps);
 802
 803                 /*
 804                  * Work out how much space we need and talloc it.
 805                  */
 806                 max_len = (ps->buffer_size - ps->data_offset)/sizeof(uint16);
 807
 808                 /* the test of the value of *ptr helps to catch the circumstance
 809                    where we have an emtpty (non-existent) string in the buffer */
 810                 for ( ptr = (uint16 *)q; *ptr && (alloc_len <= max_len); alloc_len++)
 811                         /* do nothing */
 812                         ;
 813
 814                 /* should we allocate anything at all? */
 815                 str->buffer = (uint16 *)prs_alloc_mem(ps,alloc_len * sizeof(uint16));
 816                 if ((str->buffer == NULL) && (alloc_len > 0))
 817                         return False;
 818
 819                 p = (unsigned char *)str->buffer;
 820
 821                 len = 0;
 822                 /* the (len < alloc_len) test is to prevent us from overwriting
 823                    memory that is not ours...if we get that far, we have a non-null
 824                    terminated string in the buffer and have messed up somewhere */
 825                 while ((len < alloc_len) && (*q != '\0'))
 826                 {
 827                         if(ps->bigendian_data)
 828                         {
 829                                 RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0);
 830                                 p += 2;
 831                                 q += 2;
 832                         } else {
 833 #if WORDS_BIGENDIAN
 834                                 RW_CVAL(ps->io, q+1, *p, 0);
 835                                 p++;
 836                                 RW_CVAL(ps->io, q, *p, 0);
 837                                 p++;
 838                                 q+=2;
 839 #else
 840                                 RW_CVAL(ps->io, q, *p, 0);
 841                                 p++;
 842                                 q++;
 843                                 RW_CVAL(ps->io, q, *p, 0);
 844                                 p++;
 845                                 q++;
 846 #endif  /* WORDS_BIGENDIAN */
 847
 848                         }
 849
 850                         len++;
 851                 }
 852                 if (len < alloc_len)
 853                 {
 854                         /* NULL terminate the UNISTR */
 855                         str->buffer[len++] = '\0';
 856                 }
 857         }
 858
 859         /* set the offset in the prs_struct; 'len' points to the
 860            terminiating NULL in the UNISTR so we need to go one more
 861            uint16 */
 862         ps->data_offset += (len)*2;
 863
 864         return True;
 865 }
 866
 867
 868 /*******************************************************************
 869  Stream a null-terminated string.  len is strlen, and therefore does
 870  not include the null-termination character.
 871  ********************************************************************/
 872
 873 BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, int len, int max_buf_size)
 874 {
 875         char *q;
 876         uint8 *start;
 877         int i;
 878
 879         len = MIN(len, (max_buf_size-1));
 880
 881         q = prs_mem_get(ps, len+1);
 882         if (q == NULL)
 883                 return False;
 884
 885         start = (uint8*)q;
 886
 887         for(i = 0; i < len; i++) {
 888                 RW_CVAL(ps->io, q, str[i],0);
 889                 q++;
 890         }
 891
 892         /* The terminating null. */
 893         str[i] = '\0';
 894
 895         if (MARSHALLING(ps)) {
 896                 RW_CVAL(ps->io, q, str[i], 0);
 897         }
 898
 899         ps->data_offset += len+1;
 900
 901         dump_data(5+depth, (char *)start, len);
 902
 903         return True;
 904 }
 905
 906 /*******************************************************************
 907  prs_uint16 wrapper. Call this and it sets up a pointer to where the
 908  uint16 should be stored, or gets the size if reading.
 909  ********************************************************************/
 910
 911 BOOL prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
 912 {
 913         *offset = ps->data_offset;
 914         if (UNMARSHALLING(ps)) {
 915                 /* reading. */
 916                 return prs_uint16(name, ps, depth, data16);
 917         } else {
 918                 char *q = prs_mem_get(ps, sizeof(uint16));
 919                 if(q ==NULL)
 920                         return False;
 921                 ps->data_offset += sizeof(uint16);
 922         }
 923         return True;
 924 }
 925
 926 /*******************************************************************
 927  prs_uint16 wrapper.  call this and it retrospectively stores the size.
 928  does nothing on reading, as that is already handled by ...._pre()
 929  ********************************************************************/
 930
 931 BOOL prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
 932                                 uint32 ptr_uint16, uint32 start_offset)
 933 {
 934         if (MARSHALLING(ps)) {
 935                 /*
 936                  * Writing - temporarily move the offset pointer.
 937                  */
 938                 uint16 data_size = ps->data_offset - start_offset;
 939                 uint32 old_offset = ps->data_offset;
 940
 941                 ps->data_offset = ptr_uint16;
 942                 if(!prs_uint16(name, ps, depth, &data_size)) {
 943                         ps->data_offset = old_offset;
 944                         return False;
 945                 }
 946                 ps->data_offset = old_offset;
 947         } else {
 948                 ps->data_offset = start_offset + (uint32)(*data16);
 949         }
 950         return True;
 951 }
 952
 953 /*******************************************************************
 954  prs_uint32 wrapper. Call this and it sets up a pointer to where the
 955  uint32 should be stored, or gets the size if reading.
 956  ********************************************************************/
 957
 958 BOOL prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
 959 {
 960         *offset = ps->data_offset;
 961         if (UNMARSHALLING(ps) && (data32 != NULL)) {
 962                 /* reading. */
 963                 return prs_uint32(name, ps, depth, data32);
 964         } else {
 965                 ps->data_offset += sizeof(uint32);
 966         }
 967         return True;
 968 }
 969
 970 /*******************************************************************
 971  prs_uint32 wrapper.  call this and it retrospectively stores the size.
 972  does nothing on reading, as that is already handled by ...._pre()
 973  ********************************************************************/
 974
 975 BOOL prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
 976                                 uint32 ptr_uint32, uint32 data_size)
 977 {
 978         if (MARSHALLING(ps)) {
 979                 /*
 980                  * Writing - temporarily move the offset pointer.
 981                  */
 982                 uint32 old_offset = ps->data_offset;
 983                 ps->data_offset = ptr_uint32;
 984                 if(!prs_uint32(name, ps, depth, &data_size)) {
 985                         ps->data_offset = old_offset;
 986                         return False;
 987                 }
 988                 ps->data_offset = old_offset;
 989         }
 990         return True;
 991 }
 992
 993 /* useful function to store a structure in rpc wire format */
 994 int tdb_prs_store(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
 995 {
 996     TDB_DATA kbuf, dbuf;
 997     kbuf.dptr = keystr;
 998     kbuf.dsize = strlen(keystr)+1;
 999     dbuf.dptr = prs_data_p(ps);
1000     dbuf.dsize = prs_offset(ps);
1001     return tdb_store(tdb, kbuf, dbuf, TDB_REPLACE);
1002 }
1003
1004 /* useful function to fetch a structure into rpc wire format */
1005 int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *mem_ctx)
1006 {
1007     TDB_DATA kbuf, dbuf;
1008     kbuf.dptr = keystr;
1009     kbuf.dsize = strlen(keystr)+1;
1010
1011     dbuf = tdb_fetch(tdb, kbuf);
1012     if (!dbuf.dptr) return -1;
1013
1014     ZERO_STRUCTP(ps);
1015     prs_init(ps, 0, 4, mem_ctx, UNMARSHALL);
1016     prs_give_memory(ps, dbuf.dptr, dbuf.dsize, True);
1017
1018     return 0;
1019 }