mongo_ext 0.18.1 → 0.18.2

data/Rakefile

@@ -1,3 +1,4 @@
+# -*- mode: ruby; -*-
 require 'rubygems'
 require 'rubygems/specification'
 require 'fileutils'
@@ -12,9 +13,6 @@ require 'rbconfig'
 include Config
 ENV['TEST_MODE'] = 'TRUE'
 
-gem_command = "gem"
-gem_command = "gem1.9" if $0.match(/1\.9$/) # use gem1.9 if we used rake1.9
-
 desc "Test the MongoDB Ruby driver."
 task :test do
   puts "\nThis option has changed."
@@ -95,20 +93,16 @@ namespace :gem do
 
   desc "Install the gem locally"
   task :install do
-    sh <<EOS
-#{gem_command} build mongo-ruby-driver.gemspec &&
-    #{gem_command} install mongo-*.gem &&
-    rm mongo-*.gem
-EOS
+    sh "gem build mongo-ruby-driver.gemspec"
+    sh "gem install mongo-*.gem"
+    sh "rm mongo-*.gem"
   end
 
   desc "Install the optional c extensions"
   task :install_extensions do
-    sh <<EOS
-#{gem_command} build mongo-extensions.gemspec &&
-    #{gem_command} install mongo_ext-*.gem &&
-    rm mongo_ext-*.gem
-EOS
+    sh "gem build mongo-extensions.gemspec"
+    sh "gem install mongo_ext-*.gem"
+    sh "rm mongo_ext-*.gem"
   end
 
 end

data/ext/cbson/cbson.c

@@ -51,7 +51,7 @@
 
 #define SAFE_WRITE_AT_POS(buffer, position, data, size)                 \
     if (buffer_write_at_position((buffer), (position), (data), (size)) != 0) \
-        rb_raise(rb_eNoMemError, "failed to allocate memory in buffer.c")
+        rb_raise(rb_eRuntimeError, "invalid write at position in buffer.c")
 
 #define MAX_HOSTNAME_LENGTH 256
 
@@ -64,6 +64,7 @@ static VALUE RegexpOfHolding;
 static VALUE OrderedHash;
 static VALUE InvalidName;
 static VALUE InvalidStringEncoding;
+static VALUE InvalidDocument;
 static VALUE DigestMD5;
 
 #if HAVE_RUBY_ENCODING_H
@@ -71,15 +72,26 @@ static VALUE DigestMD5;
 #define STR_NEW(p,n) rb_enc_str_new((p), (n), rb_utf8_encoding())
 /* MUST call TO_UTF8 before calling write_utf8. */
 #define TO_UTF8(string) rb_str_export_to_enc((string), rb_utf8_encoding())
-static void write_utf8(buffer_t buffer, VALUE string) {
+static void write_utf8(buffer_t buffer, VALUE string, char check_null) {
+    result_t status = check_string(RSTRING_PTR(string), RSTRING_LEN(string),
+                                   0, check_null);
+    if (status == HAS_NULL) {
+        buffer_free(buffer);
+        rb_raise(InvalidDocument, "Key names / regex patterns must not contain the NULL byte");
+    }
     SAFE_WRITE(buffer, RSTRING_PTR(string), RSTRING_LEN(string));
 }
 #else
 #define STR_NEW(p,n) rb_str_new((p), (n))
 /* MUST call TO_UTF8 before calling write_utf8. */
 #define TO_UTF8(string) (string)
-static void write_utf8(buffer_t buffer, VALUE string) {
-    if (!is_legal_utf8_string(RSTRING_PTR(string), RSTRING_LEN(string))) {
+static void write_utf8(buffer_t buffer, VALUE string, char check_null) {
+    result_t status = check_string(RSTRING_PTR(string), RSTRING_LEN(string),
+                                   1, check_null);
+    if (status == HAS_NULL) {
+        buffer_free(buffer);
+        rb_raise(InvalidDocument, "Key names / regex patterns must not contain the NULL byte");
+    } else if (status == NOT_UTF_8) {
         buffer_free(buffer);
         rb_raise(InvalidStringEncoding, "String not valid UTF-8");
     }
@@ -100,7 +112,9 @@ static void write_utf8(buffer_t buffer, VALUE string) {
 
 /* TODO we ought to check that the malloc or asprintf was successful
  * and raise an exception if not. */
-#ifdef _MSC_VER
+/* TODO maybe we can use something more portable like vsnprintf instead
+ * of this hack. And share it with the Python extension ;) */
+#ifndef HAVE_ASPRINTF
 #define INT2STRING(buffer, i)                   \
     {                                           \
         int vslength = _scprintf("%d", i) + 1;  \
@@ -112,9 +126,8 @@ static void write_utf8(buffer_t buffer, VALUE string) {
 #endif
 
 // this sucks too.
-#ifndef RREGEXP_SRC_PTR
-#define RREGEXP_SRC_PTR(r) RREGEXP(r)->str
-#define RREGEXP_SRC_LEN(r) RREGEXP(r)->len
+#ifndef RREGEXP_SRC
+#define RREGEXP_SRC(r) rb_str_new(RREGEXP((r))->str, RREGEXP((r))->len)
 #endif
 
 static char zero = 0;
@@ -135,7 +148,7 @@ static VALUE pack_extra(buffer_t buffer, VALUE check_keys) {
 static void write_name_and_type(buffer_t buffer, VALUE name, char type) {
     SAFE_WRITE(buffer, &type, 1);
     name = TO_UTF8(name);
-    write_utf8(buffer, name);
+    write_utf8(buffer, name, 1);
     SAFE_WRITE(buffer, &zero, 1);
 }
 
@@ -285,7 +298,7 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
                 value = TO_UTF8(value);
                 length = RSTRING_LEN(value) + 1;
                 SAFE_WRITE(buffer, (char*)&length, 4);
-                write_utf8(buffer, value);
+                write_utf8(buffer, value, 0);
                 SAFE_WRITE(buffer, &zero, 1);
                 break;
             }
@@ -356,6 +369,9 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
                 SAFE_WRITE_AT_POS(buffer, length_location, (const char*)&obj_length, 4);
                 break;
             }
+            buffer_free(buffer);
+            rb_raise(InvalidDocument, "Unsupported type for BSON (%d)", TYPE(value));
+            break;
         }
     case T_DATA:
         {
@@ -371,14 +387,14 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
         }
     case T_REGEXP:
         {
-            int length = RREGEXP_SRC_LEN(value);
-            char* pattern = (char*)RREGEXP_SRC_PTR(value);
+            VALUE pattern = RREGEXP_SRC(value);
             long flags = RREGEXP(value)->ptr->options;
             VALUE has_extra;
 
             write_name_and_type(buffer, key, 0x0B);
 
-            SAFE_WRITE(buffer, pattern, length);
+            pattern = TO_UTF8(pattern);
+            write_utf8(buffer, pattern, 1);
             SAFE_WRITE(buffer, &zero, 1);
 
             if (flags & IGNORECASE) {
@@ -408,7 +424,7 @@ static int write_element_allow_id(VALUE key, VALUE value, VALUE extra, int allow
     default:
         {
             buffer_free(buffer);
-            rb_raise(rb_eTypeError, "no c encoder for this type yet (%d)", TYPE(value));
+            rb_raise(InvalidDocument, "Unsupported type for BSON (%d)", TYPE(value));
             break;
         }
     }
@@ -455,6 +471,13 @@ static void write_doc(buffer_t buffer, VALUE hash, VALUE check_keys) {
     // write null byte and fill in length
     SAFE_WRITE(buffer, &zero, 1);
     length = buffer_get_position(buffer) - start_position;
+
+    // make sure that length doesn't exceed 4MB
+    if (length > 4 * 1024 * 1024) {
+      buffer_free(buffer);
+      rb_raise(InvalidDocument, "Document too large: BSON documents are limited to 4MB.");
+      return;
+    }
     SAFE_WRITE_AT_POS(buffer, length_location, &length, 4);
 }
 
@@ -489,8 +512,8 @@ static VALUE get_value(const char* buffer, int* position, int type) {
     case 13:
         {
             int value_length;
+            value_length = *(int*)(buffer + *position) - 1;
             *position += 4;
-            value_length = strlen(buffer + *position);
             value = STR_NEW(buffer + *position, value_length);
             *position += value_length + 1;
             break;
@@ -500,10 +523,11 @@ static VALUE get_value(const char* buffer, int* position, int type) {
             int size;
             memcpy(&size, buffer + *position, 4);
             if (strcmp(buffer + *position + 5, "$ref") == 0) { // DBRef
-                int offset = *position + 14;
+                int offset = *position + 10;
                 VALUE argv[2];
-                int collection_length = strlen(buffer + offset);
+                int collection_length = *(int*)(buffer + offset) - 1;
                 char id_type;
+                offset += 4;
 
                 argv[0] = STR_NEW(buffer + offset, collection_length);
                 offset += collection_length + 1;
@@ -629,8 +653,8 @@ static VALUE get_value(const char* buffer, int* position, int type) {
         {
             int collection_length;
             VALUE collection, str, oid, id, argv[2];
+            collection_length = *(int*)(buffer + *position) - 1;
             *position += 4;
-            collection_length = strlen(buffer + *position);
             collection = STR_NEW(buffer + *position, collection_length);
             *position += collection_length + 1;
 
@@ -656,8 +680,9 @@ static VALUE get_value(const char* buffer, int* position, int type) {
         {
             int code_length, scope_size;
             VALUE code, scope, argv[2];
-            *position += 8;
-            code_length = strlen(buffer + *position);
+            *position += 4;
+            code_length = *(int*)(buffer + *position) - 1;
+            *position += 4;
             code = STR_NEW(buffer + *position, code_length);
             *position += code_length + 1;
 
@@ -799,6 +824,7 @@ void Init_cbson() {
     rb_require("mongo/errors");
     InvalidName = rb_const_get(mongo, rb_intern("InvalidName"));
     InvalidStringEncoding = rb_const_get(mongo, rb_intern("InvalidStringEncoding"));
+    InvalidDocument = rb_const_get(mongo, rb_intern("InvalidDocument"));
     rb_require("mongo/util/ordered_hash");
     OrderedHash = rb_const_get(rb_cObject, rb_intern("OrderedHash"));
 

data/ext/cbson/encoding_helpers.c

@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 
+#include "encoding_helpers.h"
+
 /*
- * Copyright 2001 Unicode, Inc.
+ * Portions Copyright 2001 Unicode, Inc.
  *
  * Disclaimer
  *
@@ -85,23 +87,32 @@ static unsigned char isLegalUTF8(const unsigned char* source, int length) {
     return 1;
 }
 
-/* --------------------------------------------------------------------- */
-
-/*
- * Return whether a string containing UTF-8 is legal.
- */
-unsigned char is_legal_utf8_string(const unsigned char* string, const int length) {
+result_t check_string(const unsigned char* string, const int length,
+                      const char check_utf8, const char check_null) {
     int position = 0;
+    /* By default we go character by character. Will be different for checking
+     * UTF-8 */
+    int sequence_length = 1;
+
+    if (!check_utf8 && !check_null) {
+        return VALID;
+    }
 
     while (position < length) {
-        int sequence_length = trailingBytesForUTF8[*(string + position)] + 1;
-        if ((position + sequence_length) > length) {
-            return 0;
+        if (check_null && *(string + position) == 0) {
+            return HAS_NULL;
         }
-        if (!isLegalUTF8(string + position, sequence_length)) {
-            return 0;
+        if (check_utf8) {
+            sequence_length = trailingBytesForUTF8[*(string + position)] + 1;
+            if ((position + sequence_length) > length) {
+                return NOT_UTF_8;
+            }
+            if (!isLegalUTF8(string + position, sequence_length)) {
+                return NOT_UTF_8;
+            }
         }
         position += sequence_length;
     }
-    return 1;
+
+    return VALID;
 }

data/ext/cbson/encoding_helpers.h

@@ -17,6 +17,13 @@
 #ifndef ENCODING_HELPERS_H
 #define ENCODING_HELPERS_H
 
-unsigned char is_legal_utf8_string(const unsigned char* string, const int length);
+typedef enum {
+    VALID,
+    NOT_UTF_8,
+    HAS_NULL
+} result_t;
+
+result_t check_string(const unsigned char* string, const int length,
+                      const char check_utf8, const char check_null);
 
 #endif

data/ext/cbson/extconf.rb

@@ -1,5 +1,7 @@
 require 'mkmf'
 
+have_func("asprintf")
+
 have_header("ruby/st.h") || have_header("st.h")
 have_header("ruby/regex.h") || have_header("regex.h")
 have_header("ruby/encoding.h")

data/ext/cbson/version.h

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 
-#define VERSION "0.18.1"
+#define VERSION "0.18.2"

data/mongo-extensions.gemspec

@@ -1,5 +1,5 @@
 require 'lib/mongo'
-VERSION_HEADER = File.open(File.join(File.dirname(__FILE__), 'ext', 'cbson', 'version.h'), "r") 
+VERSION_HEADER = File.open(File.join(File.dirname(__FILE__), 'ext', 'cbson', 'version.h'), "r")
 VERSION        = VERSION_HEADER.read.scan(/VERSION\s+"(\d+\.\d+(\.\d+)?)\"/)[0][0]
 Gem::Specification.new do |s|
   s.name = 'mongo_ext'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mongo_ext
 version: !ruby/object:Gem::Version 
-  version: 0.18.1
+  version: 0.18.2
 platform: ruby
 authors: 
 - Mike Dirolf
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-05 00:00:00 -05:00
+date: 2009-12-29 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -33,6 +33,8 @@ files:
 - ext/cbson/version.h
 has_rdoc: false
 homepage: http://www.mongodb.org
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -53,9 +55,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: C extensions for the MongoDB Ruby driver
 test_files: []