source3/registry/reg_parse_prs.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba memory buffer functions
   4    Copyright (C) Andrew Tridgell              1992-1997
   5    Copyright (C) Luke Kenneth Casson Leighton 1996-1997
   6    Copyright (C) Jeremy Allison               1999
   7    Copyright (C) Andrew Bartlett              2003.
   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 3 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, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "includes.h"
  24 #include "reg_parse_prs.h"
  25 #include "rpc_dce.h"
  26
  27 #undef DBGC_CLASS
  28 #define DBGC_CLASS DBGC_RPC_PARSE
  29
  30 /*******************************************************************
  31  Debug output for parsing info
  32
  33  XXXX side-effect of this function is to increase the debug depth XXXX.
  34
  35 ********************************************************************/
  36
  37 void prs_debug(prs_struct *ps, int depth, const char *desc, const char *fn_name)
  38 {
  39         DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(5+depth,depth), ps->data_offset, fn_name, desc));
  40 }
  41
  42 /**
  43  * Initialise an expandable parse structure.
  44  *
  45  * @param size Initial buffer size.  If >0, a new buffer will be
  46  * created with talloc().
  47  *
  48  * @return False if allocation fails, otherwise True.
  49  **/
  50
  51 bool prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, bool io)
  52 {
  53         ZERO_STRUCTP(ps);
  54         ps->io = io;
  55         ps->bigendian_data = RPC_LITTLE_ENDIAN;
  56         ps->align = RPC_PARSE_ALIGN;
  57         ps->is_dynamic = False;
  58         ps->data_offset = 0;
  59         ps->buffer_size = 0;
  60         ps->data_p = NULL;
  61         ps->mem_ctx = ctx;
  62
  63         if (size != 0) {
  64                 ps->buffer_size = size;
  65                 ps->data_p = (char *)talloc_zero_size(ps->mem_ctx, size);
  66                 if(ps->data_p == NULL) {
  67                         DEBUG(0,("prs_init: talloc fail for %u bytes.\n", (unsigned int)size));
  68                         return False;
  69                 }
  70                 ps->is_dynamic = True; /* We own this memory. */
  71         } else if (MARSHALLING(ps)) {
  72                 /* If size is zero and we're marshalling we should allocate memory on demand. */
  73                 ps->is_dynamic = True;
  74         }
  75
  76         return True;
  77 }
  78
  79 /*******************************************************************
  80  Delete the memory in a parse structure - if we own it.
  81
  82  NOTE: Contrary to the somewhat confusing naming, this function is not
  83        intended for freeing memory allocated by prs_alloc_mem().
  84        That memory is also attached to the talloc context given by
  85        ps->mem_ctx, but is only freed when that talloc context is
  86        freed. prs_mem_free() is used to delete "dynamic" memory
  87        allocated in marshalling/unmarshalling.
  88  ********************************************************************/
  89
  90 void prs_mem_free(prs_struct *ps)
  91 {
  92         if(ps->is_dynamic) {
  93                 TALLOC_FREE(ps->data_p);
  94         }
  95         ps->is_dynamic = False;
  96         ps->buffer_size = 0;
  97         ps->data_offset = 0;
  98 }
  99
 100 /*******************************************************************
 101  Allocate memory when unmarshalling... Always zero clears.
 102  ********************************************************************/
 103
 104 #if defined(PARANOID_MALLOC_CHECKER)
 105 char *prs_alloc_mem_(prs_struct *ps, size_t size, unsigned int count)
 106 #else
 107 char *prs_alloc_mem(prs_struct *ps, size_t size, unsigned int count)
 108 #endif
 109 {
 110         char *ret = NULL;
 111
 112         if (size && count) {
 113                 /* We can't call the type-safe version here. */
 114                 ret = (char *)_talloc_zero_array(ps->mem_ctx, size, count,
 115                                                  "parse_prs");
 116         }
 117         return ret;
 118 }
 119
 120 /*******************************************************************
 121  Return the current talloc context we're using.
 122  ********************************************************************/
 123
 124 TALLOC_CTX *prs_get_mem_context(prs_struct *ps)
 125 {
 126         return ps->mem_ctx;
 127 }
 128
 129 /*******************************************************************
 130  Attempt, if needed, to grow a data buffer.
 131  Also depends on the data stream mode (io).
 132  ********************************************************************/
 133
 134 bool prs_grow(prs_struct *ps, uint32 extra_space)
 135 {
 136         uint32 new_size;
 137
 138         ps->grow_size = MAX(ps->grow_size, ps->data_offset + extra_space);
 139
 140         if(ps->data_offset + extra_space <= ps->buffer_size)
 141                 return True;
 142
 143         /*
 144          * We cannot grow the buffer if we're not reading
 145          * into the prs_struct, or if we don't own the memory.
 146          */
 147
 148         if(UNMARSHALLING(ps) || !ps->is_dynamic) {
 149                 DEBUG(0,("prs_grow: Buffer overflow - unable to expand buffer by %u bytes.\n",
 150                                 (unsigned int)extra_space));
 151                 return False;
 152         }
 153
 154         /*
 155          * Decide how much extra space we really need.
 156          */
 157
 158         extra_space -= (ps->buffer_size - ps->data_offset);
 159         if(ps->buffer_size == 0) {
 160
 161                 /*
 162                  * Start with 128 bytes (arbitrary value), enough for small rpc
 163                  * requests
 164                  */
 165                 new_size = MAX(128, extra_space);
 166
 167                 ps->data_p = (char *)talloc_zero_size(ps->mem_ctx, new_size);
 168                 if(ps->data_p == NULL) {
 169                         DEBUG(0,("prs_grow: talloc failure for size %u.\n", (unsigned int)new_size));
 170                         return False;
 171                 }
 172         } else {
 173                 /*
 174                  * If the current buffer size is bigger than the space needed,
 175                  * just double it, else add extra_space. Always keep 64 bytes
 176                  * more, so that after we added a large blob we don't have to
 177                  * realloc immediately again.
 178                  */
 179                 new_size = MAX(ps->buffer_size*2,
 180                                ps->buffer_size + extra_space + 64);
 181
 182                 ps->data_p = talloc_realloc(ps->mem_ctx,
 183                                                 ps->data_p,
 184                                                 char,
 185                                                 new_size);
 186                 if (ps->data_p == NULL) {
 187                         DEBUG(0,("prs_grow: Realloc failure for size %u.\n",
 188                                 (unsigned int)new_size));
 189                         return False;
 190                 }
 191
 192                 memset(&ps->data_p[ps->buffer_size], '\0', (size_t)(new_size - ps->buffer_size));
 193         }
 194         ps->buffer_size = new_size;
 195
 196         return True;
 197 }
 198
 199 /*******************************************************************
 200  Get the data pointer (external interface).
 201 ********************************************************************/
 202
 203 char *prs_data_p(prs_struct *ps)
 204 {
 205         return ps->data_p;
 206 }
 207
 208 /*******************************************************************
 209  Get the current data size (external interface).
 210  ********************************************************************/
 211
 212 uint32 prs_data_size(prs_struct *ps)
 213 {
 214         return ps->buffer_size;
 215 }
 216
 217 /*******************************************************************
 218  Fetch the current offset (external interface).
 219  ********************************************************************/
 220
 221 uint32 prs_offset(prs_struct *ps)
 222 {
 223         return ps->data_offset;
 224 }
 225
 226 /*******************************************************************
 227  Set the current offset (external interface).
 228  ********************************************************************/
 229
 230 bool prs_set_offset(prs_struct *ps, uint32 offset)
 231 {
 232         if ((offset > ps->data_offset)
 233             && !prs_grow(ps, offset - ps->data_offset)) {
 234                 return False;
 235         }
 236
 237         ps->data_offset = offset;
 238         return True;
 239 }
 240
 241 /*******************************************************************
 242  Append the data from a buffer into a parse_struct.
 243  ********************************************************************/
 244
 245 bool prs_copy_data_in(prs_struct *dst, const char *src, uint32 len)
 246 {
 247         if (len == 0)
 248                 return True;
 249
 250         if(!prs_grow(dst, len))
 251                 return False;
 252
 253         memcpy(&dst->data_p[dst->data_offset], src, (size_t)len);
 254         dst->data_offset += len;
 255
 256         return True;
 257 }
 258
 259 /*******************************************************************
 260  Align a the data_len to a multiple of align bytes - filling with
 261  zeros.
 262  ********************************************************************/
 263
 264 bool prs_align(prs_struct *ps)
 265 {
 266         uint32 mod = ps->data_offset & (ps->align-1);
 267
 268         if (ps->align != 0 && mod != 0) {
 269                 uint32 extra_space = (ps->align - mod);
 270                 if(!prs_grow(ps, extra_space))
 271                         return False;
 272                 memset(&ps->data_p[ps->data_offset], '\0', (size_t)extra_space);
 273                 ps->data_offset += extra_space;
 274         }
 275
 276         return True;
 277 }
 278
 279 /******************************************************************
 280  Align on a 8 byte boundary
 281  *****************************************************************/
 282
 283 bool prs_align_uint64(prs_struct *ps)
 284 {
 285         bool ret;
 286         uint8 old_align = ps->align;
 287
 288         ps->align = 8;
 289         ret = prs_align(ps);
 290         ps->align = old_align;
 291
 292         return ret;
 293 }
 294
 295 /*******************************************************************
 296  Ensure we can read/write to a given offset.
 297  ********************************************************************/
 298
 299 char *prs_mem_get(prs_struct *ps, uint32 extra_size)
 300 {
 301         if(UNMARSHALLING(ps)) {
 302                 /*
 303                  * If reading, ensure that we can read the requested size item.
 304                  */
 305                 if (ps->data_offset + extra_size > ps->buffer_size) {
 306                         DEBUG(0,("prs_mem_get: reading data of size %u would overrun "
 307                                 "buffer by %u bytes.\n",
 308                                 (unsigned int)extra_size,
 309                                 (unsigned int)(ps->data_offset + extra_size - ps->buffer_size) ));
 310                         return NULL;
 311                 }
 312         } else {
 313                 /*
 314                  * Writing - grow the buffer if needed.
 315                  */
 316                 if(!prs_grow(ps, extra_size))
 317                         return NULL;
 318         }
 319         return &ps->data_p[ps->data_offset];
 320 }
 321
 322 /*******************************************************************
 323  Change the struct type.
 324  ********************************************************************/
 325
 326 void prs_switch_type(prs_struct *ps, bool io)
 327 {
 328         if ((ps->io ^ io) == True)
 329                 ps->io=io;
 330 }
 331
 332 /*******************************************************************
 333  Stream a uint8.
 334  ********************************************************************/
 335
 336 bool prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8)
 337 {
 338         char *q = prs_mem_get(ps, 1);
 339         if (q == NULL)
 340                 return False;
 341
 342         if (UNMARSHALLING(ps))
 343                 *data8 = CVAL(q,0);
 344         else
 345                 SCVAL(q,0,*data8);
 346
 347         DEBUGADD(5,("%s%04x %s: %02x\n", tab_depth(5,depth), ps->data_offset, name, *data8));
 348
 349         ps->data_offset += 1;
 350
 351         return True;
 352 }
 353
 354 /*******************************************************************
 355  Stream a uint16.
 356  ********************************************************************/
 357
 358 bool prs_uint16(const char *name, prs_struct *ps, int depth, uint16 *data16)
 359 {
 360         char *q = prs_mem_get(ps, sizeof(uint16));
 361         if (q == NULL)
 362                 return False;
 363
 364         if (UNMARSHALLING(ps)) {
 365                 if (ps->bigendian_data)
 366                         *data16 = RSVAL(q,0);
 367                 else
 368                         *data16 = SVAL(q,0);
 369         } else {
 370                 if (ps->bigendian_data)
 371                         RSSVAL(q,0,*data16);
 372                 else
 373                         SSVAL(q,0,*data16);
 374         }
 375
 376         DEBUGADD(5,("%s%04x %s: %04x\n", tab_depth(5,depth), ps->data_offset, name, *data16));
 377
 378         ps->data_offset += sizeof(uint16);
 379
 380         return True;
 381 }
 382
 383 /*******************************************************************
 384  Stream a uint32.
 385  ********************************************************************/
 386
 387 bool prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
 388 {
 389         char *q = prs_mem_get(ps, sizeof(uint32));
 390         if (q == NULL)
 391                 return False;
 392
 393         if (UNMARSHALLING(ps)) {
 394                 if (ps->bigendian_data)
 395                         *data32 = RIVAL(q,0);
 396                 else
 397                         *data32 = IVAL(q,0);
 398         } else {
 399                 if (ps->bigendian_data)
 400                         RSIVAL(q,0,*data32);
 401                 else
 402                         SIVAL(q,0,*data32);
 403         }
 404
 405         DEBUGADD(5,("%s%04x %s: %08x\n", tab_depth(5,depth), ps->data_offset, name, *data32));
 406
 407         ps->data_offset += sizeof(uint32);
 408
 409         return True;
 410 }
 411
 412 /*******************************************************************
 413  Stream a uint64_struct
 414  ********************************************************************/
 415 bool prs_uint64(const char *name, prs_struct *ps, int depth, uint64 *data64)
 416 {
 417         if (UNMARSHALLING(ps)) {
 418                 uint32 high, low;
 419
 420                 if (!prs_uint32(name, ps, depth+1, &low))
 421                         return False;
 422
 423                 if (!prs_uint32(name, ps, depth+1, &high))
 424                         return False;
 425
 426                 *data64 = ((uint64_t)high << 32) + low;
 427
 428                 return True;
 429         } else {
 430                 uint32 high = (*data64) >> 32, low = (*data64) & 0xFFFFFFFF;
 431                 return prs_uint32(name, ps, depth+1, &low) &&
 432                            prs_uint32(name, ps, depth+1, &high);
 433         }
 434 }
 435
 436 /******************************************************************
 437  Stream an array of uint8s. Length is number of uint8s.
 438  ********************************************************************/
 439
 440 bool prs_uint8s(bool charmode, const char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
 441 {
 442         int i;
 443         char *q = prs_mem_get(ps, len);
 444         if (q == NULL)
 445                 return False;
 446
 447         if (UNMARSHALLING(ps)) {
 448                 for (i = 0; i < len; i++)
 449                         data8s[i] = CVAL(q,i);
 450         } else {
 451                 for (i = 0; i < len; i++)
 452                         SCVAL(q, i, data8s[i]);
 453         }
 454
 455         DEBUGADD(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset ,name));
 456         if (charmode)
 457                 print_asc(5, (unsigned char*)data8s, len);
 458         else {
 459                 for (i = 0; i < len; i++)
 460                         DEBUGADD(5,("%02x ", data8s[i]));
 461         }
 462         DEBUGADD(5,("\n"));
 463
 464         ps->data_offset += len;
 465
 466         return True;
 467 }