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         }
 588
 589         /* If the string is empty, we don't have anything to stream */
 590         if (str->buf_len==0)
 591                 return True;
 592
 593         p = (char *)str->buffer;
 594
 595         /* If we're using big-endian, reverse to get little-endian. */
 596         if(ps->bigendian_data) {
 597                 DBG_RW_PSVAL(charmode, name, depth, ps->data_offset,
 598                              ps->io, ps->bigendian_data, q, p,
 599                              str->buf_len)
 600         } else {
 601                 DBG_RW_PCVAL(charmode, name, depth, ps->data_offset,
 602                              ps->io, q, p, str->buf_len * sizeof(uint16))
 603         }
 604
 605         ps->data_offset += (str->buf_len * sizeof(uint16));
 606
 607         return True;
 608 }
 609
 610 /******************************************************************
 611  Stream a "not" unicode string, length/buffer specified separately,
 612  in byte chars. String is in little-endian format.
 613  ********************************************************************/
 614
 615 BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str)
 616 {
 617         char *p;
 618         char *q = prs_mem_get(ps, str->buf_len);
 619         if (q == NULL)
 620                 return False;
 621
 622         if (UNMARSHALLING(ps)) {
 623                 str->buffer = (uint16 *)prs_alloc_mem(ps,str->buf_len);
 624                 if (str->buffer == NULL)
 625                         return False;
 626         }
 627
 628         p = (char *)str->buffer;
 629
 630         /* If we're using big-endian, reverse to get little-endian. */
 631         if(ps->bigendian_data)
 632                 DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, p, str->buf_len/2)
 633         else
 634                 DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, p, str->buf_len)
 635         ps->data_offset += str->buf_len;
 636
 637         return True;
 638 }
 639
 640 /******************************************************************
 641  Stream a string, length/buffer specified separately,
 642  in uint8 chars.
 643  ********************************************************************/
 644
 645 BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
 646 {
 647         char *q = prs_mem_get(ps, str->str_str_len * sizeof(uint8));
 648         if (q == NULL)
 649                 return False;
 650
 651         if (UNMARSHALLING(ps)) {
 652                 str->buffer = (unsigned char *)prs_alloc_mem(ps,str->str_str_len);
 653                 if (str->buffer == NULL)
 654                         return False;
 655         }
 656
 657         DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, str->buffer, str->str_max_len)
 658         ps->data_offset += (str->str_str_len * sizeof(uint8));
 659
 660         return True;
 661 }
 662
 663 /******************************************************************
 664  Stream a unicode string, length/buffer specified separately,
 665  in uint16 chars. We use DBG_RW_PCVAL, not DBG_RW_PSVAL here
 666  as the unicode string is already in little-endian format.
 667  ********************************************************************/
 668
 669 BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
 670 {
 671         char *p;
 672         char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
 673         if (q == NULL)
 674                 return False;
 675
 676         /* If the string is empty, we don't have anything to stream */
 677         if (str->uni_str_len==0)
 678                 return True;
 679
 680         if (UNMARSHALLING(ps)) {
 681                 str->buffer = (uint16 *)prs_alloc_mem(ps,str->uni_max_len * sizeof(uint16));
 682                 if (str->buffer == NULL)
 683                         return False;
 684         }
 685
 686         p = (char *)str->buffer;
 687
 688         /* If we're using big-endian, reverse to get little-endian. */
 689         if(ps->bigendian_data) {
 690                 DBG_RW_PSVAL(charmode, name, depth, ps->data_offset,
 691                              ps->io, ps->bigendian_data, q, p,
 692                              str->uni_str_len)
 693         } else {
 694                 DBG_RW_PCVAL(charmode, name, depth, ps->data_offset,
 695                              ps->io, q, p, str->uni_str_len * sizeof(uint16))
 696         }
 697
 698         ps->data_offset += (str->uni_str_len * sizeof(uint16));
 699
 700         return True;
 701 }
 702
 703
 704
 705 /******************************************************************
 706  Stream a unicode string, length/buffer specified separately,
 707  in uint16 chars. We use DBG_RW_PCVAL, not DBG_RW_PSVAL here
 708  as the unicode string is already in little-endian format.
 709  ********************************************************************/
 710
 711 BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
 712 {
 713         char *p;
 714         char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
 715         if (q == NULL)
 716                 return False;
 717
 718         if (UNMARSHALLING(ps)) {
 719                 str->str.buffer = (uint16 *)prs_alloc_mem(ps,str->uni_str_len * sizeof(uint16));
 720                 if (str->str.buffer == NULL)
 721                         return False;
 722         }
 723
 724         p = (char *)str->str.buffer;
 725
 726         /* If we're using big-endian, reverse to get little-endian. */
 727         if(ps->bigendian_data)
 728                 DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, p, str->uni_str_len)
 729         else
 730                 DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, p, str->uni_str_len * sizeof(uint16))
 731         ps->data_offset += (str->uni_str_len * sizeof(uint16));
 732
 733         return True;
 734 }
 735
 736 /*******************************************************************
 737  Stream a unicode  null-terminated string. As the string is already
 738  in little-endian format then do it as a stream of bytes.
 739  ********************************************************************/
 740
 741 BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 742 {
 743         int len = 0;
 744         unsigned char *p = (unsigned char *)str->buffer;
 745         uint8 *start;
 746         char *q;
 747         char zero=0;
 748         uint32 max_len;
 749         uint16* ptr;
 750
 751         if (MARSHALLING(ps)) {
 752
 753                 for(len = 0; str->buffer[len] != 0; len++)
 754                         ;
 755
 756                 q = prs_mem_get(ps, (len+1)*2);
 757                 if (q == NULL)
 758                         return False;
 759
 760                 start = (uint8*)q;
 761
 762                 for(len = 0; str->buffer[len] != 0; len++)
 763                 {
 764                         if(ps->bigendian_data)
 765                         {
 766                                 RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0);
 767                                 p += 2;
 768                                 q += 2;
 769                         }
 770                         else
 771                         {
 772                                 RW_CVAL(ps->io, q, *p, 0);
 773                                 p++;
 774                                 q++;
 775                                 RW_CVAL(ps->io, q, *p, 0);
 776                                 p++;
 777                                 q++;
 778                         }
 779                 }
 780
 781                 /*
 782                  * even if the string is 'empty' (only an \0 char)
 783                  * at this point the leading \0 hasn't been parsed.
 784                  * so parse it now
 785                  */
 786
 787                 RW_CVAL(ps->io, q, zero, 0);
 788                 q++;
 789                 RW_CVAL(ps->io, q, zero, 0);
 790                 q++;
 791
 792                 len++;
 793
 794                 dump_data(5+depth, (char *)start, len * 2);
 795         }
 796         else { /* unmarshalling */
 797
 798                 uint32 alloc_len = 0;
 799                 q = prs_data_p(ps) + prs_offset(ps);
 800
 801                 /*
 802                  * Work out how much space we need and talloc it.
 803                  */
 804                 max_len = (ps->buffer_size - ps->data_offset)/sizeof(uint16);
 805
 806                 /* the test of the value of *ptr helps to catch the circumstance
 807                    where we have an emtpty (non-existent) string in the buffer */
 808                 for ( ptr = (uint16 *)q; *ptr && (alloc_len <= max_len); alloc_len++)
 809                         /* do nothing */
 810                         ;
 811
 812                 /* should we allocate anything at all? */
 813                 str->buffer = (uint16 *)prs_alloc_mem(ps,alloc_len * sizeof(uint16));
 814                 if ((str->buffer == NULL) && (alloc_len > 0))
 815                         return False;
 816
 817                 p = (unsigned char *)str->buffer;
 818
 819                 len = 0;
 820                 /* the (len < alloc_len) test is to prevent us from overwriting
 821                    memory that is not ours...if we get that far, we have a non-null
 822                    terminated string in the buffer and have messed up somewhere */
 823                 while ((len < alloc_len) && (*q != '\0'))
 824                 {
 825                         if(ps->bigendian_data)
 826                         {
 827                                 RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0);
 828                                 p += 2;
 829                                 q += 2;
 830                         } else {
 831 #if WORDS_BIGENDIAN
 832                                 RW_CVAL(ps->io, q+1, *p, 0);
 833                                 p++;
 834                                 RW_CVAL(ps->io, q, *p, 0);
 835                                 p++;
 836                                 q+=2;
 837 #else
 838                                 RW_CVAL(ps->io, q, *p, 0);
 839                                 p++;
 840                                 q++;
 841                                 RW_CVAL(ps->io, q, *p, 0);
 842                                 p++;
 843                                 q++;
 844 #endif  /* WORDS_BIGENDIAN */
 845
 846                         }
 847
 848                         len++;
 849                 }
 850                 if (len < alloc_len)
 851                 {
 852                         /* NULL terminate the UNISTR */
 853                         str->buffer[len++] = '\0';
 854                 }
 855         }
 856
 857         /* set the offset in the prs_struct; 'len' points to the
 858            terminiating NULL in the UNISTR so we need to go one more
 859            uint16 */
 860         ps->data_offset += (len)*2;
 861
 862         return True;
 863 }
 864
 865
 866 /*******************************************************************
 867  Stream a null-terminated string.  len is strlen, and therefore does
 868  not include the null-termination character.
 869  ********************************************************************/
 870
 871 BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, int len, int max_buf_size)
 872 {
 873         char *q;
 874         uint8 *start;
 875         int i;
 876
 877         len = MIN(len, (max_buf_size-1));
 878
 879         q = prs_mem_get(ps, len+1);
 880         if (q == NULL)
 881                 return False;
 882
 883         start = (uint8*)q;
 884
 885         for(i = 0; i < len; i++) {
 886                 RW_CVAL(ps->io, q, str[i],0);
 887                 q++;
 888         }
 889
 890         /* The terminating null. */
 891         str[i] = '\0';
 892
 893         if (MARSHALLING(ps)) {
 894                 RW_CVAL(ps->io, q, str[i], 0);
 895         }
 896
 897         ps->data_offset += len+1;
 898
 899         dump_data(5+depth, (char *)start, len);
 900
 901         return True;
 902 }
 903
 904 /*******************************************************************
 905  prs_uint16 wrapper. Call this and it sets up a pointer to where the
 906  uint16 should be stored, or gets the size if reading.
 907  ********************************************************************/
 908
 909 BOOL prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
 910 {
 911         *offset = ps->data_offset;
 912         if (UNMARSHALLING(ps)) {
 913                 /* reading. */
 914                 return prs_uint16(name, ps, depth, data16);
 915         } else {
 916                 char *q = prs_mem_get(ps, sizeof(uint16));
 917                 if(q ==NULL)
 918                         return False;
 919                 ps->data_offset += sizeof(uint16);
 920         }
 921         return True;
 922 }
 923
 924 /*******************************************************************
 925  prs_uint16 wrapper.  call this and it retrospectively stores the size.
 926  does nothing on reading, as that is already handled by ...._pre()
 927  ********************************************************************/
 928
 929 BOOL prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
 930                                 uint32 ptr_uint16, uint32 start_offset)
 931 {
 932         if (MARSHALLING(ps)) {
 933                 /*
 934                  * Writing - temporarily move the offset pointer.
 935                  */
 936                 uint16 data_size = ps->data_offset - start_offset;
 937                 uint32 old_offset = ps->data_offset;
 938
 939                 ps->data_offset = ptr_uint16;
 940                 if(!prs_uint16(name, ps, depth, &data_size)) {
 941                         ps->data_offset = old_offset;
 942                         return False;
 943                 }
 944                 ps->data_offset = old_offset;
 945         } else {
 946                 ps->data_offset = start_offset + (uint32)(*data16);
 947         }
 948         return True;
 949 }
 950
 951 /*******************************************************************
 952  prs_uint32 wrapper. Call this and it sets up a pointer to where the
 953  uint32 should be stored, or gets the size if reading.
 954  ********************************************************************/
 955
 956 BOOL prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
 957 {
 958         *offset = ps->data_offset;
 959         if (UNMARSHALLING(ps) && (data32 != NULL)) {
 960                 /* reading. */
 961                 return prs_uint32(name, ps, depth, data32);
 962         } else {
 963                 ps->data_offset += sizeof(uint32);
 964         }
 965         return True;
 966 }
 967
 968 /*******************************************************************
 969  prs_uint32 wrapper.  call this and it retrospectively stores the size.
 970  does nothing on reading, as that is already handled by ...._pre()
 971  ********************************************************************/
 972
 973 BOOL prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
 974                                 uint32 ptr_uint32, uint32 data_size)
 975 {
 976         if (MARSHALLING(ps)) {
 977                 /*
 978                  * Writing - temporarily move the offset pointer.
 979                  */
 980                 uint32 old_offset = ps->data_offset;
 981                 ps->data_offset = ptr_uint32;
 982                 if(!prs_uint32(name, ps, depth, &data_size)) {
 983                         ps->data_offset = old_offset;
 984                         return False;
 985                 }
 986                 ps->data_offset = old_offset;
 987         }
 988         return True;
 989 }
 990
 991 /* useful function to store a structure in rpc wire format */
 992 int tdb_prs_store(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
 993 {
 994     TDB_DATA kbuf, dbuf;
 995     kbuf.dptr = keystr;
 996     kbuf.dsize = strlen(keystr)+1;
 997     dbuf.dptr = prs_data_p(ps);
 998     dbuf.dsize = prs_offset(ps);
 999     return tdb_store(tdb, kbuf, dbuf, TDB_REPLACE);
1000 }
1001
1002 /* useful function to fetch a structure into rpc wire format */
1003 int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *mem_ctx)
1004 {
1005     TDB_DATA kbuf, dbuf;
1006     kbuf.dptr = keystr;
1007     kbuf.dsize = strlen(keystr)+1;
1008
1009     dbuf = tdb_fetch(tdb, kbuf);
1010     if (!dbuf.dptr) return -1;
1011
1012     ZERO_STRUCTP(ps);
1013     prs_init(ps, 0, 4, mem_ctx, UNMARSHALL);
1014     prs_give_memory(ps, dbuf.dptr, dbuf.dsize, True);
1015
1016     return 0;
1017 }