diff --git a/include/zmq.h b/include/zmq.h
index a6465d9c..67fa73bd 100644
--- a/include/zmq.h
+++ b/include/zmq.h
@@ -200,7 +200,7 @@ ZMQ_EXPORT int zmq_ctx_destroy (void *context);
 /*  0MQ message definition.                                                   */
 /******************************************************************************/
 
-typedef struct zmq_msg_t {unsigned char _ [40];} zmq_msg_t;
+typedef struct zmq_msg_t {unsigned char _ [48];} zmq_msg_t;
 
 typedef void (zmq_free_fn) (void *data, void *hint);
 
diff --git a/src/msg.cpp b/src/msg.cpp
index 0b9aade1..03ca150c 100644
--- a/src/msg.cpp
+++ b/src/msg.cpp
@@ -41,6 +41,7 @@ bool zmq::msg_t::check ()
 
 int zmq::msg_t::init ()
 {
+    u.vsm.properties = NULL;
     u.vsm.type = type_vsm;
     u.vsm.flags = 0;
     u.vsm.size = 0;
@@ -52,11 +53,13 @@ int zmq::msg_t::init_size (size_t size_)
 {
     file_desc = -1;
     if (size_ <= max_vsm_size) {
+        u.vsm.properties = NULL;
         u.vsm.type = type_vsm;
         u.vsm.flags = 0;
         u.vsm.size = (unsigned char) size_;
     }
     else {
+        u.lmsg.properties = NULL;
         u.lmsg.type = type_lmsg;
         u.lmsg.flags = 0;
         u.lmsg.content =
@@ -81,17 +84,19 @@ int zmq::msg_t::init_data (void *data_, size_t size_, msg_free_fn *ffn_,
     //  If data is NULL and size is not 0, a segfault
     //  would occur once the data is accessed
     zmq_assert (data_ != NULL || size_ == 0);
-    
+
     file_desc = -1;
 
     //  Initialize constant message if there's no need to deallocate
-    if(ffn_ == NULL) {
+    if (ffn_ == NULL) {
+        u.cmsg.properties = NULL;
         u.cmsg.type = type_cmsg;
         u.cmsg.flags = 0;
         u.cmsg.data = data_;
         u.cmsg.size = size_;
     }
     else {
+        u.lmsg.properties = NULL;
         u.lmsg.type = type_lmsg;
         u.lmsg.flags = 0;
         u.lmsg.content = (content_t*) malloc (sizeof (content_t));
@@ -112,6 +117,7 @@ int zmq::msg_t::init_data (void *data_, size_t size_, msg_free_fn *ffn_,
 
 int zmq::msg_t::init_delimiter ()
 {
+    u.delimiter.properties = NULL;
     u.delimiter.type = type_delimiter;
     u.delimiter.flags = 0;
     return 0;
@@ -336,4 +342,3 @@ bool zmq::msg_t::rm_refs (int refs_)
 
     return true;
 }
-
diff --git a/src/msg.hpp b/src/msg.hpp
index 6fac144e..bd0c09b9 100644
--- a/src/msg.hpp
+++ b/src/msg.hpp
@@ -86,9 +86,12 @@ namespace zmq
 
     private:
 
+        class i_properties;
+
         //  Size in bytes of the largest message that is still copied around
         //  rather than being reference-counted.
-        enum {max_vsm_size = 29};
+        enum { msg_t_size = 48 };
+        enum { max_vsm_size = msg_t_size - (8 + sizeof (i_properties *) + 3) };
 
         //  Shared message buffer. Message data are either allocated in one
         //  continuous block along with this structure - thus avoiding one
@@ -120,42 +123,47 @@ namespace zmq
             type_cmsg = 104,
             type_max = 104
         };
-  
+
         // the file descriptor where this message originated, needs to be 64bit due to alignment
         int64_t file_desc;
 
         //  Note that fields shared between different message types are not
-        //  moved to tha parent class (msg_t). This way we ger tighter packing
+        //  moved to tha parent class (msg_t). This way we get tighter packing
         //  of the data. Shared fields can be accessed via 'base' member of
         //  the union.
         union {
             struct {
-                unsigned char unused [max_vsm_size + 1];
+                i_properties *properties;
+                unsigned char unused [msg_t_size - (8 + sizeof (i_properties *) + 2)];
                 unsigned char type;
                 unsigned char flags;
             } base;
             struct {
+                i_properties *properties;
                 unsigned char data [max_vsm_size];
                 unsigned char size;
                 unsigned char type;
                 unsigned char flags;
             } vsm;
             struct {
+                i_properties *properties;
                 content_t *content;
-                unsigned char unused [max_vsm_size + 1 - sizeof (content_t*)];
+                unsigned char unused [msg_t_size - (8 + sizeof (i_properties *) + sizeof (content_t*) + 2)];
                 unsigned char type;
                 unsigned char flags;
             } lmsg;
             struct {
+                i_properties *properties;
                 void* data;
                 size_t size;
                 unsigned char unused
-                    [max_vsm_size + 1 - sizeof (void*) - sizeof (size_t)];
+                    [msg_t_size - (8 + sizeof (i_properties *) + sizeof (void*) + sizeof (size_t) + 2)];
                 unsigned char type;
                 unsigned char flags;
             } cmsg;
             struct {
-                unsigned char unused [max_vsm_size + 1];
+                i_properties *properties;
+                unsigned char unused [msg_t_size - (8 + sizeof (i_properties *) + 2)];
                 unsigned char type;
                 unsigned char flags;
             } delimiter;