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-1999
   6    Copyright (C) Luke Kenneth Casson Leighton 1996-1999
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 extern int DEBUGLEVEL;
  24
  25 #include "includes.h"
  26
  27
  28 /*******************************************************************
  29  debug output for parsing info.
  30  ********************************************************************/
  31 void prs_debug(prs_struct *ps, int depth, const char *desc, const char *fn_name)
  32 {
  33         CHECK_STRUCT(ps);
  34         DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(depth), ps->offset, fn_name, desc));
  35 }
  36
  37 /*******************************************************************
  38  debug a parse structure
  39  ********************************************************************/
  40 void prs_debug_out(const prs_struct *ps, char *msg, int level)
  41 {
  42         CHECK_STRUCT(ps);
  43         DEBUG(level,("%s ps: io %s align %d offset %d err %d data %p\n",
  44                 msg, BOOLSTR(ps->io), ps->align, ps->offset, ps->error,
  45                 ps->data));
  46
  47         if (ps->data != NULL)
  48         {
  49                 dump_data(level, ps->data, prs_buf_len(ps));
  50         }
  51 }
  52
  53 /*******************************************************************
  54  initialise a parse structure
  55  ********************************************************************/
  56 void prs_init(prs_struct *ps, uint32 size, uint8 align,  BOOL io)
  57 {
  58         ps->struct_start = 0xfefefefe;
  59         ps->io = io;
  60         ps->align = align;
  61         ps->offset = 0;
  62         ps->error = False;
  63         ps->bigendian = False;
  64
  65         ps->data = NULL;
  66         ps->data_size = 0;
  67
  68         ps->start = 0;
  69         ps->end   = 0;
  70
  71         ps->next = NULL;
  72
  73         ps->struct_end = 0xdcdcdcdc;
  74
  75         if (size != 0)
  76         {
  77                 prs_realloc_data(ps, size);
  78                 ps->end   = 0xffffffff;
  79         }
  80
  81         CHECK_STRUCT(ps);
  82 }
  83
  84 /*******************************************************************
  85  set the packed data representation type in a parse structure
  86  ********************************************************************/
  87 void prs_set_packtype(prs_struct *ps, const uint8 *pack_type)
  88 {
  89         CHECK_STRUCT(ps);
  90         ps->bigendian = pack_type[0] == 0x0;
  91 }
  92
  93 /*******************************************************************
  94  create a parse structure
  95  ********************************************************************/
  96 void prs_create(prs_struct *ps, char *data, uint32 size, uint8 align, BOOL io)
  97 {
  98         DEBUG(200,("prs_create: data:%p size:%d align:%d io:%s\n",
  99                     data, size, align, BOOLSTR(io)));
 100
 101         prs_init(ps, 0, align, io);
 102         ps->data = data;
 103         ps->data_size = size;
 104         ps->end = size;
 105
 106         CHECK_STRUCT(ps);
 107 }
 108
 109 /*******************************************************************
 110  copy a parse structure
 111  ********************************************************************/
 112 BOOL prs_copy(prs_struct *ps, const prs_struct *from)
 113 {
 114         int len = prs_buf_len(from);
 115         CHECK_STRUCT(ps);
 116         CHECK_STRUCT(from);
 117         prs_init(ps, len, from->align, from->io);
 118         ps->bigendian = from->bigendian;
 119         if (len != 0)
 120         {
 121                 if (ps->data == NULL)
 122                 {
 123                         return False;
 124                 }
 125                 if (!prs_buf_copy(ps->data, from, 0, len))
 126                 {
 127                         return False;
 128                 }
 129         }
 130         ps->offset = len;
 131         prs_link(NULL, ps, NULL);
 132         return True;
 133 }
 134
 135 /*******************************************************************
 136  allocate a memory buffer.  assume it's empty
 137  ********************************************************************/
 138 BOOL prs_alloc_data(prs_struct *buf, int size)
 139 {
 140         CHECK_STRUCT(buf);
 141
 142         buf->data_size = size;
 143         buf->data = (char*)malloc(buf->data_size);
 144
 145         if (buf->data == NULL && size != 0)
 146         {
 147                 DEBUG(3,("prs_alloc: could not malloc size %d\n",
 148                                           buf->data_size));
 149                 buf->data_size = 0;
 150
 151                 return False;
 152         }
 153
 154         bzero(buf->data, buf->data_size);
 155         buf->end   = buf->start + size;
 156
 157         CHECK_STRUCT(buf);
 158         return True;
 159 }
 160
 161 /*******************************************************************
 162  search for a memory buffer that falls within the specified offset
 163  ********************************************************************/
 164 static const prs_struct *prs_find(const prs_struct *buf, uint32 offset)
 165 {
 166         const prs_struct *f;
 167         if (buf == NULL) return False;
 168
 169         f = buf;
 170
 171         CHECK_STRUCT(f);
 172         DEBUG(200,("prs_find: data[%d..%d] offset: %d\n",
 173               f->start, f->end, offset));
 174
 175         while (f != NULL && offset >= f->end)
 176         {
 177                 DEBUG(200,("prs_find: next[%d..%d]\n", f->start, f->end));
 178
 179                 f = f->next;
 180         }
 181
 182         if (f != NULL)
 183         {
 184                 DEBUG(200,("prs_find: found data[%d..%d]\n", f->start, f->end));
 185         }
 186
 187         return f;
 188 }
 189
 190 /*******************************************************************
 191  allocates a memory buffer structure
 192  ********************************************************************/
 193 BOOL prs_buf_copy(char *copy_into, const prs_struct *buf,
 194                                 uint32 offset, uint32 len)
 195 {
 196         uint32 end = offset + len;
 197         char *q = NULL;
 198         uint32 data_len = prs_buf_len(buf);
 199         uint32 start_offset = offset;
 200         const prs_struct *bcp = buf;
 201
 202         if (buf == NULL || copy_into == NULL) return False;
 203
 204         CHECK_STRUCT(buf);
 205         DEBUG(200,("prs_struct_copy: data[%d..%d] offset %d len %d\n",
 206                     buf->start, data_len, offset, len));
 207
 208         prs_debug_out(bcp, "prs_struct_copy", 200);
 209
 210         /* there's probably an off-by-one bug, here, and i haven't even tested the code :-) */
 211         while (offset < end && ((q = prs_data(bcp, offset)) != NULL))
 212         {
 213                 uint32 copy_len;
 214                 bcp = prs_find(bcp, offset);
 215                 copy_len = bcp->end - offset;
 216
 217                 DEBUG(200,("\tdata[%d..%d] - offset %d len %d\n",
 218                         bcp->start, bcp->end,
 219                         offset, copy_len));
 220
 221                 memcpy(copy_into, q, copy_len);
 222
 223                 offset    += copy_len;
 224                 copy_into += copy_len;
 225         }
 226
 227         if (bcp != NULL)
 228         {
 229                 DEBUG(200,("prs_struct_copy: copied %d bytes\n", offset - start_offset));
 230         }
 231         else
 232         {
 233                 DEBUG(200,("prs_struct_copy: failed\n"));
 234         }
 235
 236         return buf != NULL;
 237 }
 238
 239 /*******************************************************************
 240  frees up a memory buffer.
 241  ********************************************************************/
 242 void prs_struct_free(prs_struct **buf)
 243 {
 244         if (buf == NULL) return;
 245         if ((*buf) == NULL) return;
 246
 247         CHECK_STRUCT(*buf);
 248         prs_free_data(*buf);            /* delete memory data */
 249         free(*buf);                     /* delete item */
 250         (*buf) = NULL;
 251 }
 252
 253 /*******************************************************************
 254  frees a memory buffer chain.  assumes that all items are malloced.
 255  ********************************************************************/
 256 static void prs_free_chain(prs_struct **buf)
 257 {
 258         if (buf == NULL) return;
 259         if ((*buf) == NULL) return;
 260
 261         CHECK_STRUCT(*buf);
 262         if ((*buf)->next != NULL)
 263         {
 264                 prs_free_chain(&((*buf)->next)); /* delete all other items in chain */
 265         }
 266         prs_struct_free(buf);
 267 }
 268
 269 /*******************************************************************
 270  frees a memory buffer.
 271  ********************************************************************/
 272 void prs_free_data(prs_struct *buf)
 273 {
 274         if (buf == NULL) return;
 275
 276         if (buf->data != NULL)
 277         {
 278                 CHECK_STRUCT(buf);
 279                 free(buf->data);     /* delete data in this structure */
 280                 buf->data = NULL;
 281         }
 282         buf->data_size = 0;
 283 }
 284
 285 static void *prs_realloc(void *p, size_t size)
 286 {
 287         void *ret;
 288         if (size == 0)
 289         {
 290                 safe_free(p);
 291                 return NULL;
 292         }
 293         ret = (void *)malloc(size);
 294         if (!ret) return NULL;
 295         if (p) {
 296                 memcpy(ret, p, size);
 297                 memset(p, 0, 1);
 298         }
 299         safe_free(p);
 300         return ret;
 301 }
 302
 303 /*******************************************************************
 304  reallocate a memory buffer
 305 ********************************************************************/
 306 BOOL prs_realloc_data(prs_struct *buf, size_t new_size)
 307 {
 308         char *new_data;
 309
 310         CHECK_STRUCT(buf);
 311
 312         prs_debug_out(buf, "prs_realloc_data - before", 200);
 313
 314         if (new_size == 0)
 315         {
 316                 prs_free_data(buf);
 317                 return True;
 318         }
 319
 320         new_data = (char*)Realloc(buf->data, new_size);
 321
 322         if (new_data != NULL)
 323         {
 324                 if (new_size > buf->data_size)
 325                 {
 326                         memset(&new_data[buf->data_size], 0, new_size - buf->data_size);
 327                 }
 328                 buf->data = new_data;
 329                 buf->data_size = new_size;
 330         }
 331         else if (buf->data_size >= new_size)
 332         {
 333                 DEBUG(3,("prs_realloc_data: warning - could not realloc to %d\n",
 334                                   new_size));
 335         }
 336         else
 337         {
 338                 DEBUG(3,("prs_realloc_data: error - could not realloc to %d\n",
 339                                   new_size));
 340
 341                 prs_free_data(buf);
 342                 return False;
 343         }
 344
 345         buf->end   = buf->start + new_size;
 346
 347         prs_debug_out(buf, "prs_realloc_data - after", 200);
 348         return True;
 349 }
 350
 351 /*******************************************************************
 352  reallocate a memory buffer, retrospectively :-)
 353  ********************************************************************/
 354 BOOL prs_grow_data(prs_struct *buf, BOOL io, int new_size, BOOL force_grow)
 355 {
 356         if (buf == NULL)
 357         {
 358                 return False;
 359         }
 360
 361         CHECK_STRUCT(buf);
 362
 363         if (new_size >= buf->data_size)
 364         {
 365                 if (!io || force_grow)
 366                 {
 367                         /* writing or forge realloc */
 368                         return prs_realloc_data(buf, new_size);
 369                 }
 370                 else
 371                 {
 372                 }
 373         }
 374         return True;
 375 }
 376
 377
 378 /*******************************************************************
 379  add up the lengths of all sections.
 380  ********************************************************************/
 381 uint32 prs_buf_len(const prs_struct *buf)
 382 {
 383         int len = 0;
 384         CHECK_STRUCT(buf);
 385         while (buf != NULL)
 386         {
 387                 len += buf->end - buf->start;
 388                 buf = buf->next;
 389         }
 390         return len;
 391 }
 392
 393 /*******************************************************************
 394  return the memory location specified by   may return NULL.
 395  ********************************************************************/
 396 char *prs_data(const prs_struct *buf, uint32 offset)
 397 {
 398         CHECK_STRUCT(buf);
 399         buf = prs_find(buf, offset);
 400         if (buf != NULL)
 401         {
 402                 return &(buf->data[offset - buf->start]);
 403         }
 404         return NULL;
 405 }
 406
 407
 408 /*******************************************************************
 409  link one parsing structure to another
 410  ********************************************************************/
 411 void prs_link(prs_struct *prev, prs_struct *ps, prs_struct *next)
 412 {
 413         CHECK_STRUCT(ps);
 414         if (next != NULL)
 415         {
 416                 CHECK_STRUCT(next);
 417         }
 418         if (prev != NULL)
 419         {
 420                 CHECK_STRUCT(prev);
 421         }
 422         ps->start = prev != NULL ? prev->end : 0;
 423         ps->end   = ps->start + ps->offset;
 424
 425         ps->next = next;
 426
 427         DEBUG(150,("prs_link: start %d end %d\n", ps->start, ps->end));
 428 }
 429
 430 /*******************************************************************
 431  align a pointer to a multiple of align_offset bytes.  looks like it
 432  will work for offsets of 0, 2 and 4...
 433  ********************************************************************/
 434 void prs_align(prs_struct *ps)
 435 {
 436         int mod;
 437         CHECK_STRUCT(ps);
 438         if (ps->error) return;
 439         mod = ps->offset & (ps->align-1);
 440         if (ps->align != 0 && mod != 0)
 441         {
 442                 ps->offset += ps->align - mod;
 443                 prs_grow(ps, ps->offset);
 444         }
 445 }
 446
 447 /*******************************************************************
 448  attempt, if appropriate, to grow a data buffer.
 449
 450  depends on the data stream mode (io)
 451  ********************************************************************/
 452 BOOL prs_grow(prs_struct *ps, uint32 new_size)
 453 {
 454         CHECK_STRUCT(ps);
 455         if (ps->error) return False;
 456         return prs_grow_data(ps, ps->io, new_size, False);
 457 }
 458
 459 /*******************************************************************
 460  lengthens a buffer by len bytes and copies data into it.
 461  ********************************************************************/
 462 BOOL prs_append_data(prs_struct *ps, const char *data, int len)
 463 {
 464         int prev_size = ps->data_size;
 465         int new_size  = prev_size + len;
 466         char *to;
 467
 468         DEBUG(200,("prs_append_data: prev_size: %d new_size: %d\n",
 469                     prev_size, new_size));
 470
 471         CHECK_STRUCT(ps);
 472         prs_realloc_data(ps, new_size);
 473         to = prs_data(ps, prev_size);
 474
 475         if (to == NULL || ps->data_size != new_size)
 476         {
 477                 return False;
 478         }
 479         memcpy(to, data, len);
 480
 481         return True;
 482 }
 483
 484 BOOL prs_add_data(prs_struct *ps, const char *data, int len)
 485 {
 486         int prev_size;
 487         int new_size;
 488         char *to = NULL;
 489
 490         ps->offset = 0;
 491
 492         if (ps->data == NULL)
 493         {
 494                 DEBUG(10,("prs_add_data: new_size: %d\n", len));
 495                 prs_init(ps, len, 4, True);
 496                 prev_size = 0;
 497                 new_size  = len;
 498                 if (ps->data == NULL)
 499                 {
 500                         return False;
 501                 }
 502         }
 503         else
 504         {
 505                 prev_size = ps->data_size;
 506                 new_size  = prev_size + len;
 507                 DEBUG(10,("prs_add_data: prev_size: %d new_size: %d\n",
 508                                 prev_size, new_size));
 509                 if (!prs_realloc_data(ps, new_size))
 510                 {
 511                         return False;
 512                 }
 513         }
 514
 515         DEBUG(10,("ps->start: %d\n", ps->start));
 516         ps->start = 0x0;
 517
 518         to = prs_data(ps, prev_size);
 519         if (to == NULL)
 520         {
 521                 DEBUG(10,("prs_add_data: data could not be found\n"));
 522                 return False;
 523         }
 524         if (ps->data_size != new_size)
 525         {
 526                 DEBUG(10,("prs_add_data: ERROR: data used %d new_size %d\n",
 527                                 ps->data_size, new_size));
 528                 return False;
 529         }
 530         memcpy(to, data, len);
 531         return True;
 532 }
 533
 534 /*******************************************************************
 535  stream a uint8
 536  ********************************************************************/
 537 BOOL _prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
 538 {
 539         char *q;
 540         CHECK_STRUCT(ps);
 541         if (ps->error) return False;
 542         prs_grow(ps, ps->offset + 1);
 543         q = prs_data(ps, ps->offset);
 544         if (q == NULL)
 545         {
 546                 ps->error = True;
 547                 prs_debug_out(ps, "_prs_uint8 error", 5);
 548                 return False;
 549         }
 550
 551         DBG_RW_CVAL(name, depth, ps->offset, ps->io, q, *data8)
 552         ps->offset += 1;
 553
 554
 555         return True;
 556 }
 557
 558 /*******************************************************************
 559  stream a uint16
 560  ********************************************************************/
 561 BOOL _prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
 562 {
 563         char *q;
 564         CHECK_STRUCT(ps);
 565         if (ps->error) return False;
 566         prs_grow(ps, ps->offset + 2);
 567         q = prs_data(ps, ps->offset);
 568         if (q == NULL)
 569         {
 570                 ps->error = True;
 571                 prs_debug_out(ps, "_prs_uint16 error", 5);
 572                 return False;
 573         }
 574
 575         DBG_RW_SVAL(name, depth, ps->offset, ps->io, ps->bigendian, q, *data16)
 576         ps->offset += 2;
 577
 578         return True;
 579 }
 580
 581 /*******************************************************************
 582  hash a stream.
 583  ********************************************************************/
 584 BOOL _prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
 585 {
 586         char *q;
 587         CHECK_STRUCT(ps);
 588         if (ps->error) return False;
 589         q = prs_data(ps, ps->offset);
 590         if (q == NULL)
 591         {
 592                 ps->error = True;
 593                 prs_debug_out(ps, "_prs_hash1 error", 5);
 594                 return False;
 595         }
 596
 597 #ifdef DEBUG_PASSWORD
 598         DEBUG(100,("prs_hash1\n"));
 599         dump_data(100, sess_key, 16);
 600         dump_data(100, q, 68);
 601 #endif
 602         SamOEMhash((uchar*)q, sess_key, 2);
 603 #ifdef DEBUG_PASSWORD
 604         dump_data(100, q, 68);
 605 #endif
 606
 607         return True;
 608 }
 609
 610 /*******************************************************************
 611  stream a uint32
 612  ********************************************************************/
 613 BOOL _prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
 614 {
 615         char *q;
 616         CHECK_STRUCT(ps);
 617         if (ps->error) return False;
 618         prs_grow(ps, ps->offset + 4);
 619         q = prs_data(ps, ps->offset);
 620         if (q == NULL)
 621         {
 622                 fstring str;
 623                 slprintf(str, sizeof(str)-1, "_prs_uint32 error (%s)", name);
 624                 ps->error = True;
 625                 prs_debug_out(ps, str, 5);
 626                 return False;
 627         }
 628
 629         DBG_RW_IVAL(name, depth, ps->offset, ps->io, ps->bigendian, q, *data32)
 630         ps->offset += 4;
 631
 632         return True;
 633 }
 634
 635
 636 /******************************************************************
 637  stream an array of uint8s.  length is number of uint8s
 638  ********************************************************************/
 639 BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
 640 {
 641         char *q;
 642         int end_offset;
 643         char *e;
 644         CHECK_STRUCT(ps);
 645
 646         if (len == 0)
 647         {
 648                 return True;
 649         }
 650
 651         if (ps->error) return False;
 652         end_offset = ps->offset + len * sizeof(uint8);
 653         prs_grow(ps, end_offset);
 654         q = prs_data(ps, ps->offset);
 655         e = prs_data(ps, end_offset-1);
 656
 657         if (q == NULL || e == NULL)
 658         {
 659                 ps->error = True;
 660                 prs_debug_out(ps, "_prs_uint8s error", 5);
 661                 return False;
 662         }
 663
 664         DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, data8s, len)
 665         ps->offset = end_offset;
 666
 667         return True;
 668 }
 669
 670 /******************************************************************
 671  stream an array of uint16s.  length is number of uint16s
 672  ********************************************************************/
 673 BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
 674 {
 675         char *q;
 676         int end_offset;
 677         char *e;
 678         CHECK_STRUCT(ps);
 679         if (ps->error) return False;
 680
 681         if (len == 0)
 682         {
 683                 return True;
 684         }
 685
 686         end_offset = ps->offset + len * sizeof(uint16);
 687         prs_grow(ps, end_offset);
 688         q = prs_data(ps, ps->offset);
 689         e = prs_data(ps, end_offset-1);
 690
 691         if (q == NULL || e == NULL)
 692         {
 693                 ps->error = True;
 694                 prs_debug_out(ps, "_prs_uint16s error", 5);
 695                 return False;
 696         }
 697
 698         DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, ps->bigendian, q, data16s, len)
 699         ps->offset = end_offset;
 700
 701         return True;
 702 }
 703
 704 /******************************************************************
 705  stream an array of uint32s.  length is number of uint32s
 706  ********************************************************************/
 707 BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
 708 {
 709         char *q;
 710         int end_offset;
 711         char *e;
 712         CHECK_STRUCT(ps);
 713         if (ps->error) return False;
 714
 715         if (len == 0)
 716         {
 717                 return True;
 718         }
 719
 720         end_offset = ps->offset + len * sizeof(uint32);
 721         prs_grow(ps, end_offset);
 722         q = prs_data(ps, ps->offset);
 723         e = prs_data(ps, end_offset-1);
 724
 725         if (q == NULL || e == NULL)
 726         {
 727                 ps->error = True;
 728                 prs_debug_out(ps, "_prs_uint32s error", 5);
 729                 return False;
 730         }
 731
 732         DBG_RW_PIVAL(charmode, name, depth, ps->offset, ps->io, ps->bigendian, q, data32s, len)
 733         ps->offset = end_offset;
 734
 735         return True;
 736 }
 737
 738 /******************************************************************
 739  stream a "not" unicode string, length/buffer specified separately,
 740  in byte chars
 741  ********************************************************************/
 742 BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str)
 743 {
 744         char *q;
 745         int end_offset;
 746         char *e;
 747         CHECK_STRUCT(ps);
 748         if (ps->error) return False;
 749
 750         if (str->buf_len == 0)
 751         {
 752                 return True;
 753         }
 754
 755         end_offset = ps->offset + str->buf_len * sizeof(uint8);
 756         prs_grow(ps, end_offset);
 757         q = prs_data(ps, ps->offset);
 758         e = prs_data(ps, end_offset-1);
 759
 760         if (q == NULL || e == NULL)
 761         {
 762                 ps->error = True;
 763                 prs_debug_out(ps, "_prs_buffer2 error", 5);
 764                 return False;
 765         }
 766
 767         DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->buf_len)
 768         ps->offset = end_offset;
 769
 770         return True;
 771 }
 772
 773 /******************************************************************
 774  stream a string, length/buffer specified separately,
 775  in uint8 chars.
 776  ********************************************************************/
 777 BOOL _prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
 778 {
 779         char *q;
 780         int end_offset;
 781         char *e;
 782         CHECK_STRUCT(ps);
 783         if (ps->error) return False;
 784
 785         if (str->str_str_len == 0)
 786         {
 787                 return True;
 788         }
 789
 790         end_offset = ps->offset + str->str_str_len * sizeof(uint8);
 791         prs_grow(ps, end_offset);
 792         q = prs_data(ps, ps->offset);
 793         e = prs_data(ps, end_offset-1);
 794
 795         if (q == NULL || e == NULL)
 796         {
 797                 ps->error = True;
 798                 prs_debug_out(ps, "_prs_string2 error", 5);
 799                 return False;
 800         }
 801
 802         DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->str_str_len)
 803         ps->offset = end_offset;
 804
 805         return True;
 806 }
 807
 808 /******************************************************************
 809  stream a unicode string, length/buffer specified separately,
 810  in uint16 chars.
 811  ********************************************************************/
 812 BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
 813 {
 814         char *q;
 815         int end_offset;
 816         char *e;
 817         CHECK_STRUCT(ps);
 818         if (ps->error) return False;
 819
 820         if (str->uni_str_len == 0)
 821         {
 822                 return True;
 823         }
 824
 825         end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
 826         prs_grow(ps, end_offset);
 827         q = prs_data(ps, ps->offset);
 828         e = prs_data(ps, end_offset-1);
 829
 830         if (q == NULL || e == NULL)
 831         {
 832                 ps->error = True;
 833                 prs_debug_out(ps, "_prs_unistr2 error", 5);
 834                 return False;
 835         }
 836
 837         DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, ps->bigendian, q, str->buffer, str->uni_str_len)
 838         ps->offset = end_offset;
 839
 840         return True;
 841 }
 842
 843 /******************************************************************
 844  stream a unicode string, length/buffer specified separately,
 845  in uint16 chars.
 846  ********************************************************************/
 847 BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
 848 {
 849         char *q;
 850         int end_offset;
 851         char *e;
 852         CHECK_STRUCT(ps);
 853         if (ps->error) return False;
 854
 855         if (str->uni_str_len == 0)
 856         {
 857                 return True;
 858         }
 859
 860         end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
 861         prs_grow(ps, end_offset);
 862         q = prs_data(ps, ps->offset);
 863         e = prs_data(ps, end_offset-1);
 864
 865         if (q == NULL || e == NULL)
 866         {
 867                 ps->error = True;
 868                 prs_debug_out(ps, "_prs_unistr3 error", 5);
 869                 return False;
 870         }
 871
 872         DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, ps->bigendian, q, str->str.buffer, str->uni_str_len)
 873         ps->offset = end_offset;
 874
 875         return True;
 876 }
 877
 878 /*******************************************************************
 879  stream a unicode  null-terminated string
 880  ********************************************************************/
 881 BOOL _prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 882 {
 883         int i = -1;
 884         uint8 *start;
 885         CHECK_STRUCT(ps);
 886         if (ps->error) return False;
 887         start = (uint8*)prs_data(ps, ps->offset);
 888
 889         do
 890         {
 891                 char *q;
 892                 i++;
 893                 prs_grow(ps, ps->offset + (i+1)*2);
 894                 q = prs_data(ps, ps->offset + i*2);
 895                 if (q == NULL)
 896                 {
 897                         ps->error = True;
 898                         prs_debug_out(ps, "_prs_unistr error", 5);
 899                         return False;
 900                 }
 901                 RW_SVAL(ps->io, ps->bigendian, q, str->buffer[i],0);
 902         }
 903         while ((((size_t)i) < sizeof(str->buffer) / sizeof(str->buffer[0])) &&
 904                      (str->buffer[i] != 0));
 905
 906
 907         ps->offset += (i+1)*2;
 908
 909         dump_data(5+depth, (char *)start, i * 2);
 910
 911         return True;
 912 }
 913
 914 /*******************************************************************
 915  stream a null-terminated string.  len is strlen, and therefore does
 916  not include the null-termination character.
 917
 918  len == 0 indicates variable length string
 919  (up to max size of pstring - 1024 chars).
 920
 921  ********************************************************************/
 922 BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, uint16 max_buf_size)
 923 {
 924         int i = -1; /* start off at zero after 1st i++ */
 925         BOOL len_limited;
 926
 927         CHECK_STRUCT(ps);
 928         if (ps->error) return False;
 929
 930         len_limited = len == 0 || !ps->io;
 931
 932         DEBUG(200,("_prs_string: string %s len %d max %d\n",
 933                         str, len, max_buf_size));
 934
 935         DEBUG(10,("%s%04x %s: ", tab_depth(depth), ps->offset, name != NULL ? name : ""));
 936         do
 937         {
 938                 char *q;
 939                 i++;
 940
 941                 prs_grow(ps, ps->offset + i+1);
 942                 q = prs_data(ps, ps->offset + i);
 943                 if (q == NULL)
 944                 {
 945                         ps->error = True;
 946                         DEBUG(10,("%s\n", str));
 947                         prs_debug_out(ps, "_prs_string error", 5);
 948                         return False;
 949                 }
 950
 951                 if (i < len || len_limited)
 952                 {
 953                         RW_CVAL(ps->io, q, str[i], 0);
 954                 }
 955                 else
 956                 {
 957                         uint8 dummy = 0;
 958                         RW_CVAL(ps->io, q, dummy,0);
 959                 }
 960
 961         } while (i < max_buf_size && (len_limited ? str[i] != 0 : i < len) );
 962
 963         ps->offset += i+1;
 964
 965         DEBUG(10,("%s\n", str));
 966
 967         return True;
 968 }
 969
 970 /*******************************************************************
 971  prs_uint16 wrapper.  call this and it sets up a pointer to where the
 972  uint16 should be stored, or gets the size if reading
 973  ********************************************************************/
 974 BOOL _prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
 975 {
 976         CHECK_STRUCT(ps);
 977         if (ps->error) return False;
 978         (*offset) = ps->offset;
 979         if (ps->io)
 980         {
 981                 /* reading. */
 982                 return _prs_uint16(name, ps, depth, data16);
 983         }
 984         else
 985         {
 986                 ps->offset += sizeof(uint16);
 987         }
 988         return True;
 989 }
 990
 991 /*******************************************************************
 992  prs_uint16 wrapper.  call this and it retrospectively stores the size.
 993  does nothing on reading, as that is already handled by ...._pre()
 994  ********************************************************************/
 995 BOOL _prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
 996                                 uint32 ptr_uint16, uint32 start_offset)
 997 {
 998         CHECK_STRUCT(ps);
 999         if (ps->error) return False;
1000         if (!ps->io)
1001         {
1002                 /* storing: go back and do a retrospective job.  i hate this */
1003                 uint16 data_size = ps->offset - start_offset;
1004                 uint32 old_offset = ps->offset;
1005
1006                 ps->offset = ptr_uint16;
1007                 prs_uint16(name, ps, depth, &data_size);
1008                 ps->offset = old_offset;
1009         }
1010         else
1011         {
1012                 ps->offset = start_offset + (*data16);
1013         }
1014         return True;
1015 }
1016
1017 /*******************************************************************
1018  prs_uint32 wrapper.  call this and it sets up a pointer to where the
1019  uint32 should be stored, or gets the size if reading
1020  ********************************************************************/
1021 BOOL _prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
1022 {
1023         CHECK_STRUCT(ps);
1024         if (ps->error) return False;
1025         (*offset) = ps->offset;
1026         if (ps->io)
1027         {
1028                 /* reading. */
1029                 return _prs_uint32(name, ps, depth, data32);
1030         }
1031         else
1032         {
1033                 ps->offset += sizeof(uint32);
1034         }
1035         return True;
1036 }
1037
1038 /*******************************************************************
1039  prs_uint32 wrapper.  call this and it retrospectively stores the size.
1040  does nothing on reading, as that is already handled by ...._pre()
1041  ********************************************************************/
1042 BOOL _prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
1043                                 uint32 ptr_uint32, uint32 data_size)
1044 {
1045         CHECK_STRUCT(ps);
1046         if (ps->error) return False;
1047         if (!ps->io)
1048         {
1049                 /* storing: go back and do a retrospective job.  i hate this */
1050                 uint32 old_offset = ps->offset;
1051                 ps->offset = ptr_uint32;
1052                 prs_uint32(name, ps, depth, &data_size);
1053                 ps->offset = old_offset;
1054         }
1055         else
1056         {
1057                 ps->offset = data_size + (*data32);
1058         }
1059         return True;
1060 }
1061
1062 /*******************************************************************
1063  prs_tdb_store.  stores prs_struct data by prs_struct key
1064  ********************************************************************/
1065 int prs_tdb_delete(TDB_CONTEXT *tdb, prs_struct *pk)
1066 {
1067         TDB_DATA key;
1068
1069         key.dptr = (char*)prs_data(pk, 0);
1070         key.dsize = prs_buf_len(pk);
1071
1072         return tdb_delete(tdb, key);
1073 }
1074
1075 /*******************************************************************
1076  prs_tdb_store.  stores prs_struct data by prs_struct key
1077  ********************************************************************/
1078 int prs_tdb_store(TDB_CONTEXT *tdb, int flgs, prs_struct *pk, prs_struct *pd)
1079 {
1080         TDB_DATA key;
1081         TDB_DATA data;
1082
1083         key.dptr = (char*)prs_data(pk, 0);
1084         key.dsize = prs_buf_len(pk);
1085
1086         data.dptr = prs_data(pd, 0);
1087         data.dsize = prs_buf_len(pd);
1088
1089         return tdb_store(tdb, key, data, flgs);
1090 }
1091
1092 /*******************************************************************
1093  prs_tdb_fetch.  fetches prs_struct data by prs_struct key
1094  ********************************************************************/
1095 void prs_tdb_fetch(TDB_CONTEXT *tdb, prs_struct *pk, prs_struct *pd)
1096 {
1097         TDB_DATA key;
1098         TDB_DATA data;
1099
1100         key.dptr = (char*)prs_data(pk, 0);
1101         key.dsize = prs_buf_len(pk);
1102
1103         data = tdb_fetch(tdb, key);
1104
1105         prs_create(pd, data.dptr, data.dsize, 4, True);
1106 }