bson 4.14.1 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5ec11b42a8128c41cd06cd8fc23d2ebee4018efa84de8a59d5676a0802fa3c4
-  data.tar.gz: 58c7ef8d648b9ad1b35c6aef6e3521be706c73b366644e4d7b6727534542b5d1
+  metadata.gz: 12132ecbf12cd3f9d72a97a4131985275206bd493afd61b38f723111e4f3d564
+  data.tar.gz: bbde2fa0d1b0cf9114a9c03ae971ecda873508602270d6ce4e9cc07052a73ba1
 SHA512:
-  metadata.gz: ca0a5c1c642319eddbe69dfea59ad845316baabb0207658cdc7b389bea2295a284d52d62e4c675305b7ac985350ca430653fb5244002d5e7d2854a24199d4fc6
-  data.tar.gz: f1aa3987ed9bba6ca90dcc1739c26ca7e70130d56a55bbaf4a8f92611ba96908a89309d346a1608cfb19c276378c238c3fbcbd10b8b813b9a2027b454a295890
+  metadata.gz: 75d4fc461601cb54b33371441414a35762578c4620ebd28301649bd8ff564fe41a495055c6cda98b2b61f7ef3678f6375e3e89eebeea23cd0736f7ed4b93a525
+  data.tar.gz: 5a64b2fca65a1117fbac73d68144387d5f0a4bc6737f0533926f2e2af5ac02a6bf9393f0307bdf17ca085380d1b14234fad1bba3103e8f64e1868bda2840491d

data/README.md

@@ -10,19 +10,19 @@ An implementation of the BSON specification in Ruby.
 Compatibility
 -------------
 
-BSON is tested against MRI (2.5) and JRuby (9.2+).
+BSON is tested against MRI (2.6) and JRuby (9.2+).
 
 Documentation
 -------------
 
 Current documentation can be found
-[here](http://docs.mongodb.org/ecosystem/tutorial/ruby-bson-tutorial/#ruby-bson-tutorial).
+[here](https://www.mongodb.com/docs/ruby-driver/current/bson-tutorials/).
 
 API Documentation
 -----------------
 
-The [API Documentation](https://api.mongodb.com/bson-ruby/current/) is
-located at api.mongodb.com.
+The [API Documentation](https://www.mongodb.com/docs/ruby-driver/master/api/) is
+located at mongodb.com/docs.
 
 BSON Specification
 ------------------

data/Rakefile

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
 # Copyright (C) 2009-2013 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -32,6 +35,8 @@ if jruby?
     ext.name = "bson-ruby"
     ext.ext_dir = "src"
     ext.lib_dir = "lib"
+    ext.target_version = ENV['TARGET_VERSION'] if ENV['TARGET_VERSION']
+    ext.source_version = ENV['SOURCE_VERSION'] if ENV['SOURCE_VERSION']
   end
 else
   require "rake/extensiontask"

data/ext/bson/bson-native.h

@@ -17,6 +17,7 @@
 #include <ruby.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include <stdlib.h>
 #include <unistd.h>
 #include <time.h>
 #include "bson-endian.h"
@@ -91,14 +92,16 @@ VALUE rb_bson_byte_buffer_put_uint32(VALUE self, VALUE i);
 VALUE rb_bson_byte_buffer_put_int64(VALUE self, VALUE i);
 VALUE rb_bson_byte_buffer_put_string(VALUE self, VALUE string);
 VALUE rb_bson_byte_buffer_put_symbol(VALUE self, VALUE symbol);
-VALUE rb_bson_byte_buffer_put_hash(VALUE self, VALUE hash, VALUE validating_keys);
-VALUE rb_bson_byte_buffer_put_array(VALUE self, VALUE array, VALUE validating_keys);
+VALUE rb_bson_byte_buffer_put_hash(VALUE self, VALUE hash);
+VALUE rb_bson_byte_buffer_put_array(VALUE self, VALUE array);
 VALUE rb_bson_byte_buffer_read_position(VALUE self);
 VALUE rb_bson_byte_buffer_replace_int32(VALUE self, VALUE index, VALUE i);
 VALUE rb_bson_byte_buffer_rewind(VALUE self);
 VALUE rb_bson_byte_buffer_write_position(VALUE self);
 VALUE rb_bson_byte_buffer_to_s(VALUE self);
+
 VALUE rb_bson_object_id_generator_next(int argc, VALUE* args, VALUE self);
+VALUE rb_bson_object_id_generator_reset_counter(int argc, VALUE* args, VALUE self);
 
 size_t rb_bson_byte_buffer_memsize(const void *ptr);
 void rb_bson_byte_buffer_free(void *ptr);
@@ -113,6 +116,13 @@ VALUE pvt_const_get_3(const char *c1, const char *c2, const char *c3);
 
 int pvt_get_mode_option(int argc, VALUE *argv);
 
+#define BSON_OBJECT_ID_RANDOM_VALUE_LENGTH  ( 5 )
+
+uint8_t* pvt_get_object_id_random_value();
+void pvt_init_rand();
+void pvt_rand_buf(uint8_t* bytes, int len, int pid);
+int pvt_rand();
+
 /**
  * The counter for incrementing object ids.
  */
@@ -120,8 +130,6 @@ extern uint32_t rb_bson_object_id_counter;
 
 extern VALUE rb_bson_registry;
 
-extern VALUE rb_bson_illegal_key;
-
 extern const rb_data_type_t rb_byte_buffer_data_type;
 
 extern VALUE _ref_str, _id_str, _db_str;

data/ext/bson/extconf.rb

@@ -1,3 +1,8 @@
-require "mkmf"
-$CFLAGS << " -Wall -g -std=c99"
-create_makefile("bson_native")
+# frozen_string_literal: true
+# rubocop:disable all
+
+require 'mkmf'
+
+$CFLAGS << ' -Wall -g -std=c99'
+
+create_makefile('bson_native')

data/ext/bson/init.c

@@ -23,8 +23,6 @@ uint32_t rb_bson_object_id_counter;
 
 VALUE rb_bson_registry;
 
-VALUE rb_bson_illegal_key;
-
 const rb_data_type_t rb_byte_buffer_data_type = {
   "bson/byte_buffer",
   { NULL, rb_bson_byte_buffer_free, rb_bson_byte_buffer_memsize }
@@ -46,6 +44,8 @@ void Init_bson_native()
   _db_str = rb_str_new_cstr("$db");
   rb_gc_register_mark_object(_db_str);
 
+  rb_require("digest/md5");
+
   VALUE rb_bson_module = rb_define_module("BSON");
 
   /* Document-class: BSON::ByteBuffer
@@ -60,9 +60,6 @@ void Init_bson_native()
   VALUE rb_digest_class = rb_const_get(rb_cObject, rb_intern("Digest"));
   VALUE rb_md5_class = rb_const_get(rb_digest_class, rb_intern("MD5"));
 
-  rb_bson_illegal_key = rb_const_get(rb_const_get(rb_bson_module, rb_intern("String")),rb_intern("IllegalKey"));
-  rb_gc_register_mark_object(rb_bson_illegal_key);
-
   rb_define_alloc_func(rb_byte_buffer_class, rb_bson_byte_buffer_allocate);
   rb_define_method(rb_byte_buffer_class, "initialize", rb_bson_byte_buffer_initialize, -1);
 
@@ -116,7 +113,7 @@ void Init_bson_native()
   rb_define_method(rb_byte_buffer_class, "get_array", rb_bson_byte_buffer_get_array, -1);
 
   rb_define_method(rb_byte_buffer_class, "get_int32", rb_bson_byte_buffer_get_int32, 0);
-  
+
   /*
    * call-seq:
    *   buffer.get_uint32(buffer) -> Fixnum
@@ -285,13 +282,13 @@ void Init_bson_native()
 
   /*
    * call-seq:
-   *   buffer.put_hash(hash, validating_keys) -> ByteBuffer
+   *   buffer.put_hash(hash) -> ByteBuffer
    *
    * Writes a Hash into the byte buffer.
    *
    * Returns the modified +self+.
    */
-  rb_define_method(rb_byte_buffer_class, "put_hash", rb_bson_byte_buffer_put_hash, 2);
+  rb_define_method(rb_byte_buffer_class, "put_hash", rb_bson_byte_buffer_put_hash, 1);
 
   /*
    * call-seq:
@@ -301,7 +298,7 @@ void Init_bson_native()
    *
    * Returns the modified +self+.
    */
-  rb_define_method(rb_byte_buffer_class, "put_array", rb_bson_byte_buffer_put_array, 2);
+  rb_define_method(rb_byte_buffer_class, "put_array", rb_bson_byte_buffer_put_array, 1);
 
   /*
    * call-seq:
@@ -349,6 +346,7 @@ void Init_bson_native()
   rb_define_method(rb_byte_buffer_class, "to_s", rb_bson_byte_buffer_to_s, 0);
 
   rb_define_method(rb_bson_object_id_generator_class, "next_object_id", rb_bson_object_id_generator_next, -1);
+  rb_define_method(rb_bson_object_id_generator_class, "reset_counter", rb_bson_object_id_generator_reset_counter, -1);
 
   // Get the object id machine id and hash it.
   rb_require("digest/md5");
@@ -356,8 +354,10 @@ void Init_bson_native()
   rb_bson_machine_id[255] = '\0';
   rb_bson_generate_machine_id(rb_md5_class, rb_bson_machine_id);
 
-  // Set the object id counter to a random number
-  rb_bson_object_id_counter = FIX2INT(rb_funcall(rb_mKernel, rb_intern("rand"), 1, INT2FIX(0x1000000)));
+  pvt_init_rand();
+
+  // Set the object id counter to a random 3-byte integer
+  rb_bson_object_id_counter = pvt_rand() % 0xFFFFFF;
 
   rb_bson_registry = rb_const_get(rb_bson_module, rb_intern("Registry"));
   rb_gc_register_mark_object(rb_bson_registry);

data/ext/bson/read.c

@@ -80,8 +80,23 @@ VALUE pvt_read_field(byte_buffer_t *b, VALUE rb_buffer, uint8_t type, int argc,
     case BSON_TYPE_BOOLEAN: return pvt_get_boolean(b);
     default:
     {
-      VALUE klass = rb_funcall(rb_bson_registry,rb_intern("get"),1, INT2FIX(type));
-      VALUE value = rb_funcall(klass, rb_intern("from_bson"),1, rb_buffer);
+      VALUE klass = rb_funcall(rb_bson_registry, rb_intern("get"), 1, INT2FIX(type));
+      VALUE value;
+      if (argc > 1) {
+        rb_raise(rb_eArgError, "At most one argument is allowed");
+      } else if (argc > 0) {
+        VALUE call_args[2];
+        call_args[0] = rb_buffer;
+        Check_Type(argv[0], T_HASH);
+        call_args[1] = argv[0];
+#ifdef RB_PASS_KEYWORDS /* Ruby 2.7+ */
+        value = rb_funcallv_kw(klass, rb_intern("from_bson"), 2, call_args, RB_PASS_KEYWORDS);
+#else /* Ruby 2.6 and below */
+        value = rb_funcallv(klass, rb_intern("from_bson"), 2, call_args);
+#endif
+      } else {
+        value = rb_funcall(klass, rb_intern("from_bson"), 1, rb_buffer);
+      }
       RB_GC_GUARD(klass);
       return value;
     }
@@ -366,17 +381,17 @@ static int pvt_is_dbref(VALUE doc) {
   if (NIL_P(ref) || !RB_TYPE_P(ref, T_STRING)) {
     return 0;
   }
-  
+
   id = rb_hash_aref(doc, _id_str);
   if (NIL_P(id)) {
     return 0;
   }
-  
+
   db = rb_hash_aref(doc, _db_str);
   if (!NIL_P(db) && !RB_TYPE_P(db, T_STRING)) {
     return 0;
   }
-  
+
   return 1;
 }
 
@@ -404,7 +419,7 @@ VALUE rb_bson_byte_buffer_get_hash(int argc, VALUE *argv, VALUE self){
   if (READ_PTR(b) - start_ptr != length) {
     pvt_raise_decode_error(rb_sprintf("Expected to read %d bytes for the hash but read %ld bytes", length, READ_PTR(b) - start_ptr));
   }
-  
+
   if (pvt_is_dbref(doc)) {
     VALUE cDBRef = pvt_const_get_2("BSON", "DBRef");
     doc = rb_funcall(cDBRef, rb_intern("new"), 1, doc);

data/ext/bson/util.c

@@ -21,6 +21,18 @@
  */
 static char rb_bson_machine_id_hash[HOST_NAME_HASH_MAX];
 
+/**
+ * Holds a reference to the SecureRandom module, or Qnil if the modle is
+ * not available.
+ */
+static VALUE pvt_SecureRandom = Qnil;
+
+/**
+ * Indicates whether or not the SecureRandom module responds to the
+ * `random_number` method (depends on Ruby version).
+ */
+static int pvt_has_random_number = 0;
+
 void rb_bson_generate_machine_id(VALUE rb_md5_class, char *rb_bson_machine_id)
 {
   VALUE digest = rb_funcall(rb_md5_class, rb_intern("digest"), 1, rb_str_new2(rb_bson_machine_id));
@@ -29,31 +41,69 @@ void rb_bson_generate_machine_id(VALUE rb_md5_class, char *rb_bson_machine_id)
 
 /**
  * Generate the next object id.
+ *
+ * Specification:
+ * https://github.com/mongodb/specifications/blob/master/source/objectid.rst
+ *
+ * The ObjectID BSON type is a 12-byte value consisting of three different portions (fields):
+ *   * a 4-byte value representing the seconds since the Unix epoch in the highest order bytes,
+ *   * a 5-byte random number unique to a machine and process,
+ *   * a 3-byte counter, starting with a random value.
  */
 VALUE rb_bson_object_id_generator_next(int argc, VALUE* args, VALUE self)
 {
   char bytes[12];
-  uint32_t t;
-  uint32_t c;
-  uint16_t pid = BSON_UINT16_TO_BE(getpid());
+  uint32_t time_component;
+  uint8_t* random_component;
+  uint32_t counter_component;
+  VALUE timestamp;
+  VALUE rb_bson_object_id_class;
 
-  if (argc == 0 || (argc == 1 && *args == Qnil)) {
-    t = BSON_UINT32_TO_BE((int) time(NULL));
-  }
-  else {
-    t = BSON_UINT32_TO_BE(NUM2ULONG(rb_funcall(*args, rb_intern("to_i"), 0)));
-  }
+  rb_bson_object_id_class = pvt_const_get_2("BSON", "ObjectId");
+
+  /* "Drivers SHOULD have an accessor method on an ObjectID class for
+   * obtaining the timestamp value." */
+
+  timestamp = rb_funcall(rb_bson_object_id_class, rb_intern("timestamp"), 0);
+  time_component = BSON_UINT32_TO_BE(NUM2INT(timestamp));
+
+  /* "A 5-byte field consisting of a random value generated once per process.
+   * This random value is unique to the machine and process.
+   *
+   * "Drivers MUST NOT have an accessor method on an ObjectID class for
+   * obtaining this value."
+   */
 
-  c = BSON_UINT32_TO_BE(rb_bson_object_id_counter << 8);
+  random_component = pvt_get_object_id_random_value();
+
+  /* shift left 8 bits, so that the first three bytes of the result are
+   * the meaningful ones */
+  counter_component = BSON_UINT32_TO_BE(rb_bson_object_id_counter << 8);
+
+  memcpy(&bytes, &time_component, 4);
+  memcpy(&bytes[4], random_component, 5);
+  memcpy(&bytes[9], &counter_component, 3);
+
+  rb_bson_object_id_counter = (rb_bson_object_id_counter + 1) % 0x1000000;
 
-  memcpy(&bytes, &t, 4);
-  memcpy(&bytes[4], rb_bson_machine_id_hash, 3);
-  memcpy(&bytes[7], &pid, 2);
-  memcpy(&bytes[9], &c, 3);
-  rb_bson_object_id_counter++;
   return rb_str_new(bytes, 12);
 }
 
+/**
+ * Reset the counter. This is purely as an aid for testing.
+ *
+ * @param [ Integer ] i the value to set the counter to (default is 0)
+ */
+VALUE rb_bson_object_id_generator_reset_counter(int argc, VALUE* args, VALUE self) {
+  switch(argc) {
+    case 0: rb_bson_object_id_counter = 0; break;
+    case 1: rb_bson_object_id_counter = FIX2INT(args[0]); break;
+    default: rb_raise(rb_eArgError, "Expected 0 or 1 arguments, got %d", argc);
+  }
+
+  return T_NIL;
+}
+
 /**
  * Returns a Ruby constant nested one level, e.g. BSON::Document.
  */
@@ -77,7 +127,7 @@ VALUE pvt_const_get_3(const char *c1, const char *c2, const char *c3) {
 int pvt_get_mode_option(int argc, VALUE *argv) {
   VALUE opts;
   VALUE mode;
-  
+
   rb_scan_args(argc, argv, ":", &opts);
   if (NIL_P(opts)) {
     return BSON_MODE_DEFAULT;
@@ -93,3 +143,105 @@ int pvt_get_mode_option(int argc, VALUE *argv) {
     }
   }
 }
+
+/**
+ * Returns the random number associated with this host and process. If the
+ * process ID changes (e.g. via fork), this will detect the change and
+ * generate another random number.
+ */
+uint8_t* pvt_get_object_id_random_value() {
+  static pid_t remembered_pid = 0;
+  static uint8_t remembered_value[BSON_OBJECT_ID_RANDOM_VALUE_LENGTH] = {0};
+  pid_t pid = getpid();
+
+  if (remembered_pid != pid) {
+    remembered_pid = pid;
+    pvt_rand_buf(remembered_value, BSON_OBJECT_ID_RANDOM_VALUE_LENGTH, pid);
+  }
+
+  return remembered_value;
+}
+
+/**
+ * Attempts to load the SecureRandom module
+ */
+VALUE pvt_load_secure_random(VALUE _arg) {
+  rb_require("securerandom");
+  pvt_SecureRandom = rb_const_get(rb_cObject, rb_intern("SecureRandom"));
+  pvt_has_random_number = rb_respond_to(pvt_SecureRandom, rb_intern("random_number"));
+
+  return Qnil;
+}
+
+/**
+ * The fallback, if loading `securerandom` fails.
+ */
+VALUE pvt_rescue_load_secure_random(VALUE _arg, VALUE _exception) {
+  pvt_SecureRandom = Qnil;
+
+  return Qnil;
+}
+
+/**
+ * Initializes the RNG.
+ */
+void pvt_init_rand() {
+  // SecureRandom may fail to load because it's not present (LoadError), or
+  // because it can't find a random device (NotImplementedError).
+  rb_rescue2(pvt_load_secure_random, Qnil, pvt_rescue_load_secure_random, Qnil,
+    rb_eLoadError, rb_eNotImpError, 0);
+}
+
+/**
+ * Fills the buffer with random bytes. It prefers to use SecureRandom for
+ * this, but in the very unlikely event that SecureRandom is not available,
+ * it will fall back to a much-less-ideal generator using srand/rand.
+ *
+ * The `pid` argument is only used by the fallback, if SecureRandom is not
+ * available.
+ */
+void pvt_rand_buf(uint8_t* bytes, int len, int pid) {
+  if (pvt_SecureRandom != Qnil) {
+    VALUE rb_bytes = rb_funcall(pvt_SecureRandom, rb_intern("bytes"), 1, INT2NUM(len));
+    memcpy(bytes, StringValuePtr(rb_bytes), len);
+
+  } else {
+    time_t t;
+    uint32_t seed;
+    int ofs = 0;
+
+    t = time(NULL);
+    seed = ((uint32_t)t << 16) + ((uint32_t)pid % 0xFFFF);
+    srand(seed);
+
+    while (ofs < len) {
+      int n = rand();
+      unsigned remaining = len - ofs;
+
+      if (remaining > sizeof(n)) remaining = sizeof(n);
+      memcpy(bytes+ofs, &n, remaining);
+
+      ofs += remaining;
+    }
+  }
+}
+
+/**
+ * Returns a random integer between 0 and INT_MAX.
+ */
+int pvt_rand() {
+  if (pvt_has_random_number) {
+    VALUE result = rb_funcall(pvt_SecureRandom, rb_intern("random_number"), 1, INT2NUM(INT_MAX));
+    return NUM2INT(result);
+
+  } else if (pvt_SecureRandom != Qnil) {
+    int result;
+    VALUE rb_result = rb_funcall(pvt_SecureRandom, rb_intern("bytes"), 1, INT2NUM(sizeof(result)));
+    memcpy(&result, StringValuePtr(rb_result), sizeof(result));
+    return result;
+
+  } else {
+    srand((unsigned)time(NULL));
+    return rand();
+  }
+}