msgpack 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb08f890b2d9a36312600e284933cd0de93a00a6b949507bfc3d7c5c7eab1638
-  data.tar.gz: 11e536f8bde329edbc966e5e1050134350024f89f1cb911878f86fd59ff1fc79
+  metadata.gz: 1414cbfba4f8503d851d6084ef42eb39cfe652d0cadedcf75523e5f472bf425b
+  data.tar.gz: a863d42ac8880a77afe84398b103f4b27d0782db70dd31aad4c785759bcfa20f
 SHA512:
-  metadata.gz: 9491cdf494d1826cce7f5e420d73a65ce88c029e060338d9c28fb1e20e4d01dc71fdb46b91859d025bbcc8f5a0471100b171cb9b3bac5fed6f0f0715fd76abb2
-  data.tar.gz: 8d0b4db4f93ebf98063f275c0629648ab9316c7cc3cd81738f7f083c6ed4c47fc647c2fc5df1308089b96c36d7e13944028e75bae7e5897b5bb357701c0bcfd9
+  metadata.gz: 9ffd9d63c8354684cedfcd682beaf525823646aa9b0b6854175e81f1879eea22fcbf3fba560744210129001263ff80b2fc83ebc99a7405d9f03570921567b1d7
+  data.tar.gz: 4bd0b851caa3d39c05e32d6d90f9f52c376aae4f799247d3d9569db9bc273171c85973e6229de6b9c55e956e2f8c9790a9a4c23e8482944233ed499b421f30c6

data/ChangeLog

@@ -1,3 +1,17 @@
+2023-03-29 1.7.0:
+
+* Fix a possible double-free issue when GC triggers inside `_msgpack_rmem_alloc2`.
+* `Unpacker#feed` now always directly read in provided strings instead of copying content in its buffer.
+* `Unpacker#feed` is now an alias of `Unpacker#feed_reference`.
+* Implement `Factory::Pool#unpacker` and `Factory::Pool#packer` to allow for more precise serialization.
+* Require Ruby 2.5+.
+
+2023-03-03 1.6.1:
+
+* Undefine `#clone` and `#dup` on `MessagePack::Buffer`, `MessagePack::Packer` and `MessagePack::Unpacker`.
+  These methods were never intended, and using them could cause leaks or crashes or worse.
+* Fix a possible GC crash when GC trigger inside `MessagePack::Buffer.new` (#314).
+
 2022-09-30 1.6.0:
 
 * Fix a potential use-after-free bug in Buffer_free when accessing a packer or unpacker buffer. 

data/README.md

@@ -211,6 +211,33 @@ factory.register_type(
 factory.load(factory.dump(Point.new(12, 34))) # => #<struct Point x=12, y=34>
 ```
 
+## Pooling
+
+Creating `Packer` and `Unpacker` objects is expensive. For best performance it is preferable to re-use these objects.
+
+`MessagePack::Factory#pool` makes that easier:
+
+```ruby
+factory = MessagePack::Factory.new
+factory.register_type(
+  0x01,
+  Point,
+  packer: ->(point, packer) {
+    packer.write(point.x)
+    packer.write(point.y)
+  },
+  unpacker: ->(unpacker) {
+    x = unpacker.read
+    y = unpacker.read
+    Point.new(x, y)
+  },
+  recursive: true,
+)
+pool = factory.pool(5) # The pool size should match the number of threads expected to use the factory concurrently.
+
+pool.load(pool.dump(Point.new(12, 34))) # => #<struct Point x=12, y=34>
+```
+
 ## Buffer API
 
 MessagePack for Ruby provides a buffer API so that you can read or write data by hand, not via Packer or Unpacker API.

data/ext/java/org/msgpack/jruby/ExtensionRegistry.java

@@ -18,22 +18,17 @@ public class ExtensionRegistry {
   private final ExtensionEntry[] extensionsByTypeId;
 
   public ExtensionRegistry() {
-    this(new HashMap<RubyModule, ExtensionEntry>());
+    this(new HashMap<RubyModule, ExtensionEntry>(), new ExtensionEntry[256]);
   }
 
-  private ExtensionRegistry(Map<RubyModule, ExtensionEntry> extensionsByModule) {
+  private ExtensionRegistry(Map<RubyModule, ExtensionEntry> extensionsByModule, ExtensionEntry[] extensionsByTypeId) {
     this.extensionsByModule = new HashMap<RubyModule, ExtensionEntry>(extensionsByModule);
     this.extensionsByAncestor = new HashMap<RubyModule, ExtensionEntry>();
-    this.extensionsByTypeId = new ExtensionEntry[256];
-    for (ExtensionEntry entry : extensionsByModule.values()) {
-      if (entry.hasUnpacker()) {
-        extensionsByTypeId[entry.getTypeId() + 128] = entry;
-      }
-    }
+    this.extensionsByTypeId = extensionsByTypeId.clone();
   }
 
   public ExtensionRegistry dup() {
-    return new ExtensionRegistry(extensionsByModule);
+    return new ExtensionRegistry(extensionsByModule, extensionsByTypeId);
   }
 
   public IRubyObject toInternalPackerRegistry(ThreadContext ctx) {

data/ext/java/org/msgpack/jruby/Factory.java

@@ -92,7 +92,7 @@ public class Factory extends RubyObject {
     RubyHash options = null;
 
     if (isFrozen()) {
-        throw runtime.newRuntimeError("can't modify frozen Factory");
+        throw runtime.newFrozenError("MessagePack::Factory");
     }
 
     if (args.length == 2) {

data/ext/java/org/msgpack/jruby/Packer.java

@@ -96,6 +96,9 @@ public class Packer extends RubyObject {
   @JRubyMethod(name = "register_type", required = 2, optional = 1)
   public IRubyObject registerType(ThreadContext ctx, IRubyObject[] args, final Block block) {
     Ruby runtime = ctx.runtime;
+    if (isFrozen()) {
+        throw runtime.newFrozenError("MessagePack::Packer");
+    }
     IRubyObject type = args[0];
     IRubyObject mod = args[1];
 

data/ext/java/org/msgpack/jruby/Unpacker.java

@@ -130,6 +130,9 @@ public class Unpacker extends RubyObject {
   @JRubyMethod(name = "register_type", required = 1, optional = 2)
   public IRubyObject registerType(ThreadContext ctx, IRubyObject[] args, final Block block) {
     Ruby runtime = ctx.runtime;
+    if (isFrozen()) {
+        throw runtime.newFrozenError("MessagePack::Unpacker");
+    }
     IRubyObject type = args[0];
 
     RubyModule extModule;

data/ext/msgpack/buffer.c

@@ -19,10 +19,6 @@
 #include "buffer.h"
 #include "rmem.h"
 
-#ifndef HAVE_RB_STR_REPLACE
-static ID s_replace;
-#endif
-
 int msgpack_rb_encindex_utf8;
 int msgpack_rb_encindex_usascii;
 int msgpack_rb_encindex_ascii8bit;
@@ -40,10 +36,6 @@ void msgpack_buffer_static_init(void)
     msgpack_rb_encindex_ascii8bit = rb_ascii8bit_encindex();
 
     msgpack_rmem_init(&s_rmem);
-
-#ifndef HAVE_RB_STR_REPLACE
-    s_replace = rb_intern("replace");
-#endif
 }
 
 void msgpack_buffer_static_destroy(void)
@@ -66,7 +58,11 @@ void msgpack_buffer_init(msgpack_buffer_t* b)
 static void _msgpack_buffer_chunk_destroy(msgpack_buffer_chunk_t* c)
 {
     if(c->mem != NULL) {
-        if(!msgpack_rmem_free(&s_rmem, c->mem)) {
+        if(c->rmem) {
+            if(!msgpack_rmem_free(&s_rmem, c->mem)) {
+                rb_bug("Failed to free an rmem pointer, memory leak?");
+            }
+        } else {
             xfree(c->mem);
         }
         /* no needs to update rmem_owner because chunks will not be
@@ -330,14 +326,12 @@ static inline void _msgpack_buffer_append_reference(msgpack_buffer_t* b, VALUE s
 
 void _msgpack_buffer_append_long_string(msgpack_buffer_t* b, VALUE string)
 {
-    size_t length = RSTRING_LEN(string);
-
     if(b->io != Qnil) {
         msgpack_buffer_flush(b);
         if (ENCODING_GET(string) == msgpack_rb_encindex_ascii8bit) {
             rb_funcall(b->io, b->io_write_all_method, 1, string);
         } else {
-            msgpack_buffer_append(b, RSTRING_PTR(string), length);
+            msgpack_buffer_append(b, RSTRING_PTR(string), RSTRING_LEN(string));
         }
     } else {
        _msgpack_buffer_append_reference(b, string);
@@ -349,6 +343,8 @@ static inline void* _msgpack_buffer_chunk_malloc(
         size_t required_size, size_t* allocated_size)
 {
     if(required_size <= MSGPACK_RMEM_PAGE_SIZE) {
+        c->rmem = true;
+
         if((size_t)(b->rmem_end - b->rmem_last) < required_size) {
             /* alloc new rmem page */
             *allocated_size = MSGPACK_RMEM_PAGE_SIZE;
@@ -379,6 +375,7 @@ static inline void* _msgpack_buffer_chunk_malloc(
     *allocated_size = required_size;
     void* mem = xmalloc(required_size);
     c->mem = mem;
+    c->rmem = false;
     return mem;
 }
 

data/ext/msgpack/buffer.h

@@ -78,6 +78,7 @@ struct msgpack_buffer_chunk_t {
     void* mem;
     msgpack_buffer_chunk_t* next;
     VALUE mapped_string;  /* RBString or NO_MAPPED_STRING */
+    bool rmem;
 };
 
 union msgpack_buffer_cast_block_t {
@@ -267,14 +268,7 @@ static inline size_t msgpack_buffer_append_string(msgpack_buffer_t* b, VALUE str
 static inline size_t msgpack_buffer_append_string_reference(msgpack_buffer_t* b, VALUE string)
 {
     size_t length = RSTRING_LEN(string);
-
-    if(length > MSGPACK_BUFFER_STRING_WRITE_REFERENCE_MINIMUM) {
-        _msgpack_buffer_append_long_string(b, string);
-
-    } else {
-        msgpack_buffer_append(b, RSTRING_PTR(string), length);
-    }
-
+    _msgpack_buffer_append_long_string(b, string);
     return length;
 }
 
@@ -479,7 +473,6 @@ static inline VALUE msgpack_buffer_read_top_as_string(msgpack_buffer_t* b, size_
         result = rb_str_new(b->read_buffer, length);
     }
 
-#if STR_UMINUS_DEDUPE
     if (will_be_frozen) {
 #if STR_UMINUS_DEDUPE_FROZEN
         // Starting from MRI 2.8 it is preferable to freeze the string
@@ -491,7 +484,6 @@ static inline VALUE msgpack_buffer_read_top_as_string(msgpack_buffer_t* b, size_
         // frozen.
         result = rb_funcall(result, s_uminus, 0);
     }
-#endif // STR_UMINUS_DEDUPE
     _msgpack_buffer_consumed(b, length);
     return result;
 

data/ext/msgpack/buffer_class.c

@@ -56,7 +56,7 @@ static size_t Buffer_memsize(const void *data)
     return sizeof(msgpack_buffer_t) + msgpack_buffer_memsize(data);
 }
 
-const rb_data_type_t buffer_data_type = {
+static const rb_data_type_t buffer_data_type = {
     .wrap_struct_name = "msgpack:buffer",
     .function = {
         .dmark = msgpack_buffer_mark,
@@ -66,10 +66,10 @@ const rb_data_type_t buffer_data_type = {
     .flags = RUBY_TYPED_FREE_IMMEDIATELY
 };
 
-const rb_data_type_t buffer_view_data_type = {
+static const rb_data_type_t buffer_view_data_type = {
     .wrap_struct_name = "msgpack:buffer_view",
     .function = {
-        .dmark = msgpack_buffer_mark,
+        .dmark = NULL,
         .dfree = NULL,
         .dsize = NULL,
     },
@@ -91,8 +91,8 @@ static VALUE Buffer_alloc(VALUE klass)
 {
     msgpack_buffer_t* b;
     VALUE buffer = TypedData_Make_Struct(klass, msgpack_buffer_t, &buffer_data_type, b);
-    rb_ivar_set(buffer, s_at_owner, Qnil);
     msgpack_buffer_init(b);
+    rb_ivar_set(buffer, s_at_owner, Qnil);
     return buffer;
 }
 

data/ext/msgpack/extconf.rb

@@ -5,11 +5,13 @@ have_header("st.h")
 have_func("rb_enc_interned_str", "ruby.h") # Ruby 3.0+
 have_func("rb_hash_new_capa", "ruby.h") # Ruby 3.2+
 
+$CFLAGS << " -fvisibility=hidden "
+
 unless RUBY_PLATFORM.include? 'mswin'
   $CFLAGS << %[ -I.. -Wall -O3 #{RbConfig::CONFIG["debugflags"]} -std=gnu99]
 end
 
-if RUBY_VERSION.start_with?('3.0.')
+if RUBY_VERSION.start_with?('3.0.') && RUBY_VERSION <= '3.0.5'
   # https://bugs.ruby-lang.org/issues/18772
   $CFLAGS << ' -DRB_ENC_INTERNED_STR_NULL_CHECK=1 '
 end
@@ -26,20 +28,6 @@ else
   $CFLAGS << ' -DHASH_ASET_DEDUPE=0 '
 end
 
-
-# checking if String#-@ (str_uminus) dedupes... ' (Ruby 2.5+)
-begin
-  a = -(%w(t e s t).join)
-  b = -(%w(t e s t).join)
-  if a.equal?(b)
-    $CFLAGS << ' -DSTR_UMINUS_DEDUPE=1 '
-  else
-    $CFLAGS += ' -DSTR_UMINUS_DEDUPE=0 '
-  end
-rescue NoMethodError
-  $CFLAGS << ' -DSTR_UMINUS_DEDUPE=0 '
-end
-
 # checking if String#-@ (str_uminus) directly interns frozen strings... ' (Ruby 3.0+)
 begin
   s = rand.to_s.freeze

data/ext/msgpack/factory_class.c

@@ -212,7 +212,7 @@ static VALUE Factory_register_type(int argc, VALUE* argv, VALUE self)
     VALUE packer_proc, unpacker_proc;
 
     if (OBJ_FROZEN(self)) {
-        rb_raise(rb_eRuntimeError, "can't modify frozen Factory");
+        rb_raise(rb_eFrozenError, "can't modify frozen MessagePack::Factory");
     }
 
     switch (argc) {

data/ext/msgpack/packer.c

@@ -43,6 +43,7 @@ void msgpack_packer_mark(msgpack_packer_t* pk)
     /* See MessagePack_Buffer_wrap */
     /* msgpack_buffer_mark(PACKER_BUFFER_(pk)); */
     rb_gc_mark(pk->buffer_ref);
+    rb_gc_mark(pk->to_msgpack_arg);
 }
 
 void msgpack_packer_reset(msgpack_packer_t* pk)

data/ext/msgpack/packer_class.c

@@ -47,6 +47,7 @@ static void Packer_free(void *ptr)
 static void Packer_mark(void *ptr)
 {
     msgpack_packer_t* pk = ptr;
+    msgpack_buffer_mark(pk);
     msgpack_packer_mark(pk);
     msgpack_packer_ext_registry_mark(&pk->ext_registry);
 }
@@ -106,7 +107,7 @@ VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self)
     msgpack_packer_t *pk = MessagePack_Packer_get(self);
 
     msgpack_packer_ext_registry_init(&pk->ext_registry);
-    pk->buffer_ref = MessagePack_Buffer_wrap(PACKER_BUFFER_(pk), self);
+    pk->buffer_ref = Qnil;
 
     MessagePack_Buffer_set_options(PACKER_BUFFER_(pk), io, options);
 
@@ -129,6 +130,9 @@ static VALUE Packer_compatibility_mode_p(VALUE self)
 static VALUE Packer_buffer(VALUE self)
 {
     msgpack_packer_t *pk = MessagePack_Packer_get(self);
+    if (!RTEST(pk->buffer_ref)) {
+        pk->buffer_ref = MessagePack_Buffer_wrap(PACKER_BUFFER_(pk), self);
+    }
     return pk->buffer_ref;
 }
 
@@ -334,18 +338,6 @@ static VALUE Packer_write_to(VALUE self, VALUE io)
     return SIZET2NUM(sz);
 }
 
-//static VALUE Packer_append(VALUE self, VALUE string_or_buffer)
-//{
-//    msgpack_packer_t *pk = MessagePack_Packer_get(self);
-//
-//    // TODO if string_or_buffer is a Buffer
-//    VALUE string = string_or_buffer;
-//
-//    msgpack_buffer_append_string(PACKER_BUFFER_(pk), string);
-//
-//    return self;
-//}
-
 static VALUE Packer_registered_types_internal(VALUE self)
 {
     msgpack_packer_t *pk = MessagePack_Packer_get(self);
@@ -357,6 +349,10 @@ static VALUE Packer_registered_types_internal(VALUE self)
 
 static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self)
 {
+    if (OBJ_FROZEN(self)) {
+        rb_raise(rb_eFrozenError, "can't modify frozen MessagePack::Packer");
+    }
+
     msgpack_packer_t *pk = MessagePack_Packer_get(self);
 
     int ext_type;
@@ -463,15 +459,9 @@ void MessagePack_Packer_module_init(VALUE mMessagePack)
     rb_define_method(cMessagePack_Packer, "to_str", Packer_to_str, 0);
     rb_define_alias(cMessagePack_Packer, "to_s", "to_str");
     rb_define_method(cMessagePack_Packer, "to_a", Packer_to_a, 0);
-    //rb_define_method(cMessagePack_Packer, "append", Packer_append, 1);
-    //rb_define_alias(cMessagePack_Packer, "<<", "append");
 
     rb_define_private_method(cMessagePack_Packer, "registered_types_internal", Packer_registered_types_internal, 0);
     rb_define_method(cMessagePack_Packer, "register_type", Packer_register_type, -1);
 
-    //s_packer_value = MessagePack_Packer_alloc(cMessagePack_Packer);
-    //rb_gc_register_address(&s_packer_value);
-    //Data_Get_Struct(s_packer_value, msgpack_packer_t, s_packer);
-
     rb_define_method(cMessagePack_Packer, "full_pack", Packer_full_pack, 0);
 }

data/ext/msgpack/rbinit.c

@@ -22,7 +22,7 @@
 #include "factory_class.h"
 #include "extension_value_class.h"
 
-void Init_msgpack(void)
+RUBY_FUNC_EXPORTED void Init_msgpack(void)
 {
     VALUE mMessagePack = rb_define_module("MessagePack");
 

data/ext/msgpack/rmem.c

@@ -65,11 +65,10 @@ void* _msgpack_rmem_alloc2(msgpack_rmem_t* pm)
     /* allocate new chunk */
     c = pm->array_last++;
 
-    /* move to head */
-    msgpack_rmem_chunk_t tmp = pm->head;
-    pm->head = *c;
-    *c = tmp;
+    /* move head to array */
+    *c = pm->head;
 
+    pm->head.pages = NULL; /* make sure we don't point to another chunk's pages in case xmalloc triggers GC */
     pm->head.mask = 0xffffffff & (~1);  /* "& (~1)" means first chunk is already allocated */
     pm->head.pages = xmalloc(MSGPACK_RMEM_PAGE_SIZE * 32);
 

data/ext/msgpack/unpacker.c

@@ -20,19 +20,17 @@
 #include "rmem.h"
 #include "extension_value_class.h"
 
-#if !defined(DISABLE_UNPACKER_STACK_RMEM) && \
-        MSGPACK_UNPACKER_STACK_CAPACITY * MSGPACK_UNPACKER_STACK_SIZE <= MSGPACK_RMEM_PAGE_SIZE
-#define UNPACKER_STACK_RMEM
-#endif
+_Static_assert(
+    sizeof(msgpack_unpacker_stack_entry_t) * MSGPACK_UNPACKER_STACK_CAPACITY <= MSGPACK_RMEM_PAGE_SIZE,
+    "msgpack_unpacker_stack_entry_t is too big to fit MSGPACK_UNPACKER_STACK_CAPACITY in MSGPACK_RMEM_PAGE_SIZE"
+);
 
 static int RAW_TYPE_STRING = 256;
 static int RAW_TYPE_BINARY = 257;
 
 static ID s_call;
 
-#ifdef UNPACKER_STACK_RMEM
 static msgpack_rmem_t s_stack_rmem;
-#endif
 
 #if !defined(HAVE_RB_HASH_NEW_CAPA)
 static inline VALUE rb_hash_new_capa(long capa)
@@ -43,18 +41,14 @@ static inline VALUE rb_hash_new_capa(long capa)
 
 void msgpack_unpacker_static_init(void)
 {
-#ifdef UNPACKER_STACK_RMEM
     msgpack_rmem_init(&s_stack_rmem);
-#endif
 
     s_call = rb_intern("call");
 }
 
 void msgpack_unpacker_static_destroy(void)
 {
-#ifdef UNPACKER_STACK_RMEM
     msgpack_rmem_destroy(&s_stack_rmem);
-#endif
 }
 
 #define HEAD_BYTE_REQUIRED 0xc1
@@ -62,13 +56,8 @@ void msgpack_unpacker_static_destroy(void)
 static inline msgpack_unpacker_stack_t* _msgpack_unpacker_new_stack(void) {
     msgpack_unpacker_stack_t *stack = ZALLOC(msgpack_unpacker_stack_t);
     stack->capacity = MSGPACK_UNPACKER_STACK_CAPACITY;
-#ifdef UNPACKER_STACK_RMEM
     stack->data = msgpack_rmem_alloc(&s_stack_rmem);
     /*memset(uk->stack, 0, MSGPACK_UNPACKER_STACK_CAPACITY);*/
-#else
-    /*uk->stack = calloc(MSGPACK_UNPACKER_STACK_CAPACITY, sizeof(msgpack_unpacker_stack_entry_t));*/
-    stack->data = xmalloc(MSGPACK_UNPACKER_STACK_CAPACITY * sizeof(msgpack_unpacker_stack_entry_t));
-#endif
     return stack;
 }
 
@@ -85,11 +74,9 @@ void _msgpack_unpacker_init(msgpack_unpacker_t* uk)
 }
 
 static inline void _msgpack_unpacker_free_stack(msgpack_unpacker_stack_t* stack) {
-    #ifdef UNPACKER_STACK_RMEM
-        msgpack_rmem_free(&s_stack_rmem, stack->data);
-    #else
-        xfree(stack->data);
-    #endif
+    if (!msgpack_rmem_free(&s_stack_rmem, stack->data)) {
+        rb_bug("Failed to free an rmem pointer, memory leak?");
+    }
     xfree(stack);
 }
 
@@ -120,6 +107,7 @@ void msgpack_unpacker_mark(msgpack_unpacker_t* uk)
     /* See MessagePack_Buffer_wrap */
     /* msgpack_buffer_mark(UNPACKER_BUFFER_(uk)); */
     rb_gc_mark(uk->buffer_ref);
+    rb_gc_mark(uk->self);
 }
 
 void _msgpack_unpacker_reset(msgpack_unpacker_t* uk)

data/ext/msgpack/unpacker.h

@@ -21,9 +21,7 @@
 #include "buffer.h"
 #include "unpacker_ext_registry.h"
 
-#ifndef MSGPACK_UNPACKER_STACK_CAPACITY
 #define MSGPACK_UNPACKER_STACK_CAPACITY 128
-#endif
 
 struct msgpack_unpacker_t;
 typedef struct msgpack_unpacker_t msgpack_unpacker_t;
@@ -49,8 +47,6 @@ struct msgpack_unpacker_stack_t {
     msgpack_unpacker_stack_t *parent;
 };
 
-#define MSGPACK_UNPACKER_STACK_SIZE (8+4+8+8)  /* assumes size_t <= 64bit, enum <= 32bit, VALUE <= 64bit */
-
 struct msgpack_unpacker_t {
     msgpack_buffer_t buffer;
     msgpack_unpacker_stack_t *stack;

data/ext/msgpack/unpacker_class.c

@@ -51,6 +51,7 @@ static void Unpacker_free(void *ptr)
 static void Unpacker_mark(void *ptr)
 {
     msgpack_unpacker_t* uk = ptr;
+    msgpack_buffer_mark(uk);
     msgpack_unpacker_mark(uk);
     msgpack_unpacker_ext_registry_mark(uk->ext_registry);
 }
@@ -117,7 +118,7 @@ VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self)
 
     msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
 
-    uk->buffer_ref = MessagePack_Buffer_wrap(UNPACKER_BUFFER_(uk), self);
+    uk->buffer_ref = Qnil;
 
     MessagePack_Buffer_set_options(UNPACKER_BUFFER_(uk), io, options);
 
@@ -177,6 +178,9 @@ NORETURN(static void raise_unpacker_error(int r))
 static VALUE Unpacker_buffer(VALUE self)
 {
     msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
+    if (!RTEST(uk->buffer_ref)) {
+        uk->buffer_ref = MessagePack_Buffer_wrap(UNPACKER_BUFFER_(uk), self);
+    }
     return uk->buffer_ref;
 }
 
@@ -245,18 +249,6 @@ static VALUE Unpacker_read_map_header(VALUE self)
     return ULONG2NUM(size); // long at least 32 bits
 }
 
-
-static VALUE Unpacker_feed(VALUE self, VALUE data)
-{
-    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
-
-    StringValue(data);
-
-    msgpack_buffer_append_string(UNPACKER_BUFFER_(uk), data);
-
-    return self;
-}
-
 static VALUE Unpacker_feed_reference(VALUE self, VALUE data)
 {
     msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
@@ -356,6 +348,10 @@ static VALUE Unpacker_registered_types_internal(VALUE self)
 
 static VALUE Unpacker_register_type(int argc, VALUE* argv, VALUE self)
 {
+    if (OBJ_FROZEN(self)) {
+        rb_raise(rb_eFrozenError, "can't modify frozen MessagePack::Unpacker");
+    }
+
     msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
 
     int ext_type;
@@ -453,8 +449,8 @@ void MessagePack_Unpacker_module_init(VALUE mMessagePack)
     rb_define_method(cMessagePack_Unpacker, "skip_nil", Unpacker_skip_nil, 0);
     rb_define_method(cMessagePack_Unpacker, "read_array_header", Unpacker_read_array_header, 0);
     rb_define_method(cMessagePack_Unpacker, "read_map_header", Unpacker_read_map_header, 0);
-    rb_define_method(cMessagePack_Unpacker, "feed", Unpacker_feed, 1);
-    rb_define_method(cMessagePack_Unpacker, "feed_reference", Unpacker_feed_reference, 1);
+    rb_define_method(cMessagePack_Unpacker, "feed", Unpacker_feed_reference, 1);
+    rb_define_alias(cMessagePack_Unpacker, "feed_reference", "feed");
     rb_define_method(cMessagePack_Unpacker, "each", Unpacker_each, 0);
     rb_define_method(cMessagePack_Unpacker, "feed_each", Unpacker_feed_each, 1);
     rb_define_method(cMessagePack_Unpacker, "reset", Unpacker_reset, 0);
@@ -462,11 +458,5 @@ void MessagePack_Unpacker_module_init(VALUE mMessagePack)
     rb_define_private_method(cMessagePack_Unpacker, "registered_types_internal", Unpacker_registered_types_internal, 0);
     rb_define_method(cMessagePack_Unpacker, "register_type", Unpacker_register_type, -1);
 
-    //s_unpacker_value = MessagePack_Unpacker_alloc(cMessagePack_Unpacker);
-    //rb_gc_register_address(&s_unpacker_value);
-    //Data_Get_Struct(s_unpacker_value, msgpack_unpacker_t, s_unpacker);
-    /* prefer reference than copying */
-    //msgpack_buffer_set_write_reference_threshold(UNPACKER_BUFFER_(s_unpacker), 0);
-
     rb_define_method(cMessagePack_Unpacker, "full_unpack", Unpacker_full_unpack, 0);
 }

data/lib/msgpack/buffer.rb

@@ -0,0 +1,9 @@
+module MessagePack
+  class Buffer
+    # see ext for other methods
+
+    # The semantic of duping a buffer is just too weird.
+    undef_method :dup
+    undef_method :clone
+  end
+end