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