Home | History | Annotate | Download | only in bsdiff
      1 // Copyright 2015 The Chromium OS Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "extents.h"
      6 
      7 #include <assert.h>
      8 #include <errno.h>
      9 #include <limits.h>
     10 #include <stdint.h>
     11 #include <stdlib.h>
     12 
     13 #include <algorithm>
     14 #include <limits>
     15 
     16 namespace bsdiff {
     17 
     18 /* The maximum accepted value for a given integer type when parsed as a signed
     19  * long long integer. This is defined to be the smaller of the maximum value
     20  * that can be represented by this type and LLONG_MAX. This bound allows us to
     21  * properly check that parsed values do not exceed the capacity of their
     22  * intended store, regardless of how its size relates to that of a signed long
     23  * long integer.  Note: this may mean that we are losing the most significant
     24  * bit of an unsigned 64-bit field (e.g. size_t on some platforms), however
     25  * still permitting values up to 2^62, which is more than enough for all
     26  * practical purposes. */
     27 #define MAX_ALLOWED(t)                                            \
     28   (std::min(static_cast<uint64_t>(std::numeric_limits<t>::max()), \
     29             static_cast<uint64_t>(std::numeric_limits<long long>::max())))
     30 
     31 /* Get the type of a struct field. */
     32 #define FIELD_TYPE(t, f) decltype(((t*)0)->f)
     33 
     34 
     35 /* Reads a long long integer from |s| into |*val_p|. Returns a pointer to the
     36  * character immediately following the specified |delim|, unless (a) parsing
     37  * failed (overflow or no valid digits); (b) the read value is less than
     38  * |min_val| or greater than |max_val|; (c) the delimiter character is not
     39  * |delim|, or the string ends although |may_end| is false. In any of these
     40  * cases, returns NULL. */
     41 const char* read_llong(const char* s,
     42                        long long* val_p,
     43                        long long min_val,
     44                        long long max_val,
     45                        char delim,
     46                        int may_end) {
     47   assert(val_p);
     48   const char* next_s;
     49   errno = 0;
     50   long long val = strtoll(s, (char**)&next_s, 10);
     51   if (((val == LLONG_MAX || val == LLONG_MIN) && errno == ERANGE) ||
     52       next_s == s || val < min_val || val > max_val ||
     53       (*next_s ? *next_s != delim : !may_end))
     54     return NULL; /* bad value or delimiter */
     55   *val_p = val;
     56   if (*next_s)
     57     next_s++; /* skip delimeter */
     58   return next_s;
     59 }
     60 
     61 
     62 /* Reads a comma-separated list of "offset:length" extents from |ex_str|. If
     63  * |ex_arr| is NULL, then |ex_count| is ignored and it attempts to parse valid
     64  * extents until the end of the string is reached. Otherwise, stores up to
     65  * |ex_count| extents into |ex_arr|, which must be of at least this size.
     66  * Returns the number of correctly parsed extents, or -1 if a malformed extent
     67  * was found. */
     68 static ssize_t extents_read(const char* ex_str, ex_t* ex_arr, size_t ex_count) {
     69   size_t i;
     70   size_t last_i = ex_count - 1;
     71   if (!ex_arr) {
     72     ex_count = SIZE_MAX;
     73     last_i = 0;
     74   }
     75   for (i = 0; *ex_str && i < ex_count; i++) {
     76     long long raw_off = 0, raw_len = 0;
     77     if (!((ex_str =
     78                read_llong(ex_str, &raw_off, -1,
     79                           MAX_ALLOWED(FIELD_TYPE(ex_t, off)), ':', false)) &&
     80           (ex_str = read_llong(ex_str, &raw_len, 1,
     81                                MAX_ALLOWED(FIELD_TYPE(ex_t, len)), ',',
     82                                i >= last_i))))
     83       return -1; /* parsing error */
     84     if (ex_arr) {
     85       ex_arr[i].off = raw_off;
     86       ex_arr[i].len = raw_len;
     87     }
     88   }
     89   return i;
     90 }
     91 
     92 
     93 bool ParseExtentStr(const char* ex_str, std::vector<ex_t>* extents) {
     94   // Sanity check: a string must be provided.
     95   if (!ex_str)
     96     return false;
     97 
     98   /* Parse string and count extents. */
     99   ssize_t ret = extents_read(ex_str, NULL, 0);
    100   if (ret < 0)
    101     return false;  // parsing error.
    102 
    103   // Input is good, commit to extent count.
    104   extents->resize(ret);
    105   if (ret == 0)
    106     return true;  // No extents, nothing to do.
    107 
    108   // Populate the extent array.
    109   extents_read(ex_str, extents->data(), extents->size());
    110   return true;
    111 }
    112 
    113 }  // namespace bsdiff
    114