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