oj 3.17.4 → 3.17.6

data/ext/oj/oj.c

@@ -299,7 +299,8 @@ static VALUE only_array_from_string(const char *str) {
  *   floats, 0 indicates use Ruby
  * - *:float_format* [_String_] the C printf format string for printing floats.
  *   Default follows the float_precision and will be changed if float_precision is
- *   changed. The string can be no more than 6 bytes.
+ *   changed. The string can be no more than 6 bytes and can hold at most one
+ *   directive, which must be one of aAeEfgG and take no argument of its own.
  * - *:use_to_json* [_Boolean_|_nil_] call to_json() methods on dump, default is false
  * - *:use_as_json* [_Boolean_|_nil_] call as_json() methods on dump, default is false
  * - *:use_raw_json* [_Boolean_|_nil_] call raw_json() methods on dump, default is false
@@ -574,7 +575,8 @@ static VALUE get_def_opts(VALUE self) {
  *     when dumping the seconds portion of time.
  *   - *:float_format* [_String_] the C printf format string for printing floats.
  *     Default follows the float_precision and will be changed if float_precision
- *     is changed. The string can be no more than 6 bytes.
+ *     is changed. The string can be no more than 6 bytes and can hold at most one
+ *     directive, which must be one of aAeEfgG and take no argument of its own.
  *   - *:float_precision* [_Fixnum_|_nil_] number of digits of precision when dumping floats, 0 indicates use Ruby.
  *   - *:use_to_json* [_Boolean_|_nil_] call to_json() methods on dump, default is false.
  *   - *:use_as_json* [_Boolean_|_nil_] call as_json() methods on dump, default is false.
@@ -705,6 +707,46 @@ bool set_yesno_options(VALUE key, VALUE value, Options copts) {
     return false;
 }
 
+inline static bool in_set(const char *set, char c) {
+    return '\0' != c && NULL != strchr(set, c);
+}
+
+// The format is used with one double and nothing else, so a directive that
+// asks for anything more takes it from whatever is left in the argument
+// registers. %s reads it as a pointer and %n writes through it.
+static void validate_float_format(const char *str, size_t len) {
+    const char *s   = str;
+    const char *end = str + len;
+    int         cnt = 0;
+
+    for (; s < end; s++) {
+        if ('%' != *s) {
+            continue;
+        }
+        s++;
+        if (s < end && '%' == *s) {
+            continue;
+        }
+        if (1 < ++cnt) {
+            rb_raise(rb_eArgError, ":float_format must not have more than one directive.");
+        }
+        for (; s < end && in_set("-+ #0", *s); s++) {
+        }
+        for (; s < end && '0' <= *s && *s <= '9'; s++) {
+        }
+        if (s < end && '.' == *s) {
+            for (s++; s < end && '0' <= *s && *s <= '9'; s++) {
+            }
+        }
+        if (s < end && 'l' == *s) {
+            s++;
+        }
+        if (end <= s || !in_set("aAeEfgG", *s)) {
+            rb_raise(rb_eArgError, ":float_format directive must be one of aAeEfgG and take no argument of its own.");
+        }
+    }
+}
+
 static const char *make_only_value(VALUE v) {
     switch (rb_type(v)) {
     case RUBY_T_NIL:
@@ -794,12 +836,14 @@ static const char *make_only_value(VALUE v) {
     return NULL;
 }
 
-static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
-    Options copts = (Options)opts;
-    size_t  len;
+// Apply one key and value to copts. Returns true if the key named an option Oj
+// knows and false if it did not. An unrecognized key is still ignored rather
+// than an error; the return only lets a caller tell the two cases apart.
+static bool parse_one_option(VALUE k, VALUE v, Options copts) {
+    size_t len;
 
     if (set_yesno_options(k, v, copts)) {
-        return ST_CONTINUE;
+        return true;
     }
     if (oj_indent_sym == k) {
         switch (rb_type(v)) {
@@ -925,7 +969,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (bigdecimal_load_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
 
         if (bigdecimal_sym == v || Qtrue == v) {
@@ -941,7 +985,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (compat_bigdecimal_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         copts->compat_bigdec = (Qtrue == v);
     } else if (oj_decimal_class_sym == k) {
@@ -953,9 +997,13 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
             rb_raise(rb_eArgError, ":decimal_class must be BigDecimal or Float.");
         }
     } else if (create_id_sym == k) {
+        // A per call copy of the options aliases the buffer the default
+        // options own, so only the defaults may free it.
+        bool owned = (&oj_default_options == copts && NULL != copts->create_id && oj_json_class != copts->create_id);
+
         if (Qnil == v) {
-            if (oj_json_class != oj_default_options.create_id && NULL != copts->create_id) {
-                OJ_R_FREE((char *)oj_default_options.create_id);
+            if (owned) {
+                OJ_R_FREE((char *)copts->create_id);
             }
             copts->create_id     = NULL;
             copts->create_id_len = 0;
@@ -963,8 +1011,8 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
             const char *str = StringValuePtr(v);
 
             len = RSTRING_LEN(v);
-            if (len != copts->create_id_len || 0 != strcmp(copts->create_id, str)) {
-                if (&oj_default_options == copts && oj_json_class != copts->create_id) {
+            if (NULL == copts->create_id || len != copts->create_id_len || 0 != strcmp(copts->create_id, str)) {
+                if (owned) {
                     OJ_R_FREE((char *)copts->create_id);
                 }
                 copts->create_id = OJ_R_ALLOC_N(char, len + 1);
@@ -1032,7 +1080,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (nan_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         if (null_sym == v) {
             copts->dump_opts.nan_dump = NullNan;
@@ -1049,7 +1097,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (omit_nil_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         if (Qtrue == v) {
             copts->dump_opts.omit_nil = true;
@@ -1060,7 +1108,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (omit_null_byte_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         if (Qtrue == v) {
             copts->dump_opts.omit_null_byte = true;
@@ -1121,7 +1169,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (integer_range_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         if (rb_obj_class(v) == rb_cRange) {
             VALUE min = rb_funcall(v, oj_begin_id, 0);
@@ -1152,7 +1200,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (symbol_keys_sym == k || oj_symbolize_names_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         copts->sym_key = (Qtrue == v) ? Yes : No;
 
@@ -1172,6 +1220,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         if (6 < RSTRING_LEN(v)) {
             rb_raise(rb_eArgError, ":float_format must be 6 bytes or less.");
         }
+        validate_float_format(RSTRING_PTR(v), (size_t)RSTRING_LEN(v));
         strncpy(copts->float_fmt, RSTRING_PTR(v), (size_t)RSTRING_LEN(v));
         copts->float_fmt[RSTRING_LEN(v)] = '\0';
     } else if (only_sym == k) {
@@ -1186,21 +1235,51 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
             OJ_R_FREE((void *)copts->dump_opts.except);
         }
         copts->dump_opts.except = make_only_value(v);
+    } else {
+        return false;
+    }
+    return true;
+}
+
+// Collects the return of parse_one_option() over every key in a hash.
+struct _optsParse {
+    Options copts;
+    bool    consumed;
+};
+
+static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
+    struct _optsParse *op = (struct _optsParse *)opts;
+
+    if (parse_one_option(k, v, op->copts)) {
+        op->consumed = true;
     }
     return ST_CONTINUE;
 }
 
-void oj_parse_options(VALUE ropts, Options copts) {
+// Apply the options in ropts to copts and report whether any key was
+// recognized. A hash of nothing but unknown keys leaves copts untouched and
+// returns false.
+bool oj_parse_options_consumed(VALUE ropts, Options copts) {
+    struct _optsParse op = {copts, false};
+
     if (T_HASH != rb_type(ropts)) {
-        return;
+        return false;
+    }
+    rb_hash_foreach(ropts, parse_options_cb, (VALUE)&op);
+    if (Qnil != rb_hash_lookup(ropts, match_string_sym)) {
+        op.consumed = true;
     }
-    rb_hash_foreach(ropts, parse_options_cb, (VALUE)copts);
     oj_parse_opt_match_string(&copts->str_rx, ropts);
 
     copts->dump_opts.use = (0 < copts->dump_opts.indent_size || 0 < copts->dump_opts.after_size ||
                             0 < copts->dump_opts.before_size || 0 < copts->dump_opts.hash_size ||
                             0 < copts->dump_opts.array_size);
-    return;
+
+    return op.consumed;
+}
+
+void oj_parse_options(VALUE ropts, Options copts) {
+    oj_parse_options_consumed(ropts, copts);
 }
 
 // Free the option buffers that oj_parse_options() allocated for a single call.

data/ext/oj/oj.h

@@ -197,6 +197,7 @@ typedef struct _out {
     bool      allocated;
     bool      omit_nil;
     bool      omit_null_byte;
+    bool      key_filter_off;  // rails: suppress the :only/:except key filter for an as_json result
     int       argc;
     VALUE    *argv;
     ROptTable ropts;
@@ -256,6 +257,7 @@ extern VALUE oj_custom_parse_cstr(int argc, VALUE *argv, char *json, size_t len)
 
 extern bool oj_hash_has_key(VALUE hash, VALUE key);
 extern void oj_parse_options(VALUE ropts, Options copts);
+extern bool oj_parse_options_consumed(VALUE ropts, Options copts);
 extern void oj_free_call_options(Options copts);
 extern void oj_options_take_ownership(Options copts);
 extern void oj_options_release(Options copts);
@@ -325,7 +327,6 @@ extern VALUE oj_max_nesting_sym;
 extern VALUE oj_object_class_sym;
 extern VALUE oj_object_nl_sym;
 extern VALUE oj_quirks_mode_sym;
-extern VALUE oj_skip_null_byte_sym;
 extern VALUE oj_space_before_sym;
 extern VALUE oj_space_sym;
 extern VALUE oj_symbolize_names_sym;

data/ext/oj/parse.c

@@ -414,6 +414,11 @@ static void read_escaped_str(ParseInfo pi, const char *start) {
 
         if ('\\' == *s) {
             s++;
+            if (pi->end <= s) {
+                oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "quoted string not terminated");
+                buf_cleanup(&buf);
+                return;
+            }
             switch (*s) {
             case 'n': buf_append(&buf, '\n'); break;
             case 'r': buf_append(&buf, '\r'); break;
@@ -1096,7 +1101,9 @@ void oj_set_error_at(ParseInfo pi, VALUE err_clas, const char *file, int line, c
     }
     va_end(ap);
     pi->err.clas = err_clas;
-    if (p + 3 < end) {
+    // The eight bytes below, plus the ')' and the terminator that the two bytes
+    // held back from end are for.
+    if (p + 8 <= end) {
         *p++  = ' ';
         *p++  = '(';
         *p++  = 'a';

data/ext/oj/parser.c

@@ -892,10 +892,10 @@ static void parse(ojParser p, const byte *json, size_t len, bool more) {
         case EXP_DIGIT:
             p->map = exp_map;
             for (; NUM_DIGIT == digit_map[*b]; b++) {
-                int16_t x = p->num.exp * 10 + (int16_t)(*b - '0');
+                int x = p->num.exp * 10 + (*b - '0');
 
                 if (x <= MAX_EXP) {
-                    p->num.exp = x;
+                    p->num.exp = (int16_t)x;
                 } else {
                     big_change(p);
                     p->map = big_exp_map;
@@ -1282,7 +1282,8 @@ static int opt_cb(VALUE rkey, VALUE value, VALUE ptr) {
  * Oj::Parser.new(:usual, cache_keys: true).
  */
 static VALUE parser_new(int argc, VALUE *argv, VALUE self) {
-    ojParser p = OJ_R_ALLOC(struct _ojParser);
+    ojParser       p = OJ_R_ALLOC(struct _ojParser);
+    volatile VALUE pv;
 
 #if HAVE_RB_EXT_RACTOR_SAFE
     // This doesn't seem to do anything.
@@ -1292,6 +1293,10 @@ static VALUE parser_new(int argc, VALUE *argv, VALUE self) {
     buf_init(&p->key);
     buf_init(&p->buf);
     p->map = value_map;
+    // Until the parser is wrapped the GC can not free it, so the mode and the
+    // options, both of which raise on a value they do not take, are handled
+    // after the wrap.
+    pv = TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
 
     if (argc < 1) {
         oj_set_parser_validator(p);
@@ -1332,7 +1337,7 @@ static VALUE parser_new(int argc, VALUE *argv, VALUE self) {
             rb_hash_foreach(ropts, opt_cb, (VALUE)p);
         }
     }
-    return TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
+    return pv;
 }
 
 // Create a new parser without setting the delegate. The parser is
@@ -1524,6 +1529,39 @@ static VALUE parser_load(VALUE self, VALUE reader) {
     return p->result(p);
 }
 
+struct _fileParse {
+    ojParser    p;
+    const char *path;
+    int         fd;
+};
+
+static VALUE file_parse(VALUE x) {
+    struct _fileParse *fp = (struct _fileParse *)x;
+    byte               buf[16385];
+    size_t             size = sizeof(buf) - 1;
+    ssize_t            rsize;
+
+    while (true) {
+        if (0 > (rsize = read(fp->fd, buf, size))) {
+            rb_raise(rb_eIOError, "error reading from %s", fp->path);
+        }
+        if (0 == rsize) {
+            break;
+        }
+        buf[rsize] = '\0';
+        parse(fp->p, buf, rsize, true);
+    }
+    validate_document_end(fp->p);
+
+    return fp->p->result(fp->p);
+}
+
+static VALUE file_close(VALUE x) {
+    close(((struct _fileParse *)x)->fd);
+
+    return Qnil;
+}
+
 /* Document-method: file(filename)
  * call-seq: file(filename)
  *
@@ -1532,9 +1570,10 @@ static VALUE parser_load(VALUE self, VALUE reader) {
  * Returns the result according to the delegate of the parser.
  */
 static VALUE parser_file(VALUE self, VALUE filename) {
-    ojParser    p;
-    const char *path;
-    int         fd;
+    struct _fileParse fp;
+    ojParser          p;
+    const char       *path;
+    int               fd;
 
     TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);
 
@@ -1553,26 +1592,15 @@ static VALUE parser_file(VALUE self, VALUE filename) {
         // Use threaded version.
         // TBD only if has pthreads
         // TBD parse_large(p, fd);
+        close(fd);
         return p->result(p);
     }
 #endif
-    byte   buf[16385];
-    size_t size = sizeof(buf) - 1;
-    size_t rsize;
+    fp.p    = p;
+    fp.path = path;
+    fp.fd   = fd;
 
-    while (true) {
-        if (0 < (rsize = read(fd, buf, size))) {
-            buf[rsize] = '\0';
-            parse(p, buf, rsize, true);
-        }
-        if (rsize <= 0) {
-            if (0 != rsize) {
-                rb_raise(rb_eIOError, "error reading from %s", path);
-            }
-            break;
-        }
-    }
-    return p->result(p);
+    return rb_ensure(file_parse, (VALUE)&fp, file_close, (VALUE)&fp);
 }
 
 /* Document-method: just_one
@@ -1685,15 +1713,19 @@ static VALUE parser_safe(int argc, VALUE *argv, VALUE self) {
         options = rb_hash_new();
     }
 
-    ojParser p = OJ_R_ALLOC(struct _ojParser);
+    ojParser       p = OJ_R_ALLOC(struct _ojParser);
+    volatile VALUE pv;
 
     memset(p, 0, sizeof(struct _ojParser));
     buf_init(&p->key);
     buf_init(&p->buf);
     p->map = value_map;
+    // The limits raise on a value that is not an Integer, so the parser has to
+    // be wrapped before they are read.
+    pv = TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
     oj_set_parser_safe(p, options);
 
-    return TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
+    return pv;
 }
 
 /* Document-class: Oj::Parser