diff --git a/lib/cpp/src/protocol/TBinaryProtocol.cpp b/lib/cpp/src/protocol/TBinaryProtocol.cpp
index 5116e86..2645601 100644
--- a/lib/cpp/src/protocol/TBinaryProtocol.cpp
+++ b/lib/cpp/src/protocol/TBinaryProtocol.cpp
@@ -19,34 +19,34 @@
 // understanding_strict_aliasing.html
 template <typename To, typename From>
 static inline To bitwise_cast(From from) {
-	BOOST_STATIC_ASSERT(sizeof(From) == sizeof(To));
+  BOOST_STATIC_ASSERT(sizeof(From) == sizeof(To));
 
-	// BAD!!!  These are all broken with -O2.
-	//return *reinterpret_cast<To*>(&from);  // BAD!!!
-	//return *static_cast<To*>(static_cast<void*>(&from));  // BAD!!!
-	//return *(To*)(void*)&from;  // BAD!!!
+  // BAD!!!  These are all broken with -O2.
+  //return *reinterpret_cast<To*>(&from);  // BAD!!!
+  //return *static_cast<To*>(static_cast<void*>(&from));  // BAD!!!
+  //return *(To*)(void*)&from;  // BAD!!!
+  
+  // Super clean and paritally blessed by section 3.9 of the standard.
+  //unsigned char c[sizeof(from)];
+  //memcpy(c, &from, sizeof(from));
+  //To to;
+  //memcpy(&to, c, sizeof(c));
+  //return to;
 
-	// Super clean and paritally blessed by section 3.9 of the standard.
-	//unsigned char c[sizeof(from)];
-	//memcpy(c, &from, sizeof(from));
-	//To to;
-	//memcpy(&to, c, sizeof(c));
-	//return to;
+  // Slightly more questionable.
+  // Same code emitted by GCC.
+  //To to;
+  //memcpy(&to, &from, sizeof(from));
+  //return to;
 
-	// Slightly more questionable.
-	// Same code emitted by GCC.
-	//To to;
-	//memcpy(&to, &from, sizeof(from));
-	//return to;
-
-	// Technically undefined, but almost universally supported,
-	// and the most efficient implementation.
-	union {
-		From f;
-		To t;
-	} u;
-	u.f = from;
-	return u.t;
+  // Technically undefined, but almost universally supported,
+  // and the most efficient implementation.
+  union {
+    From f;
+    To t;
+  } u;
+  u.f = from;
+  return u.t;
 }
 
 
@@ -55,10 +55,18 @@
 uint32_t TBinaryProtocol::writeMessageBegin(const std::string& name,
                                             const TMessageType messageType,
                                             const int32_t seqid) {
-  return 
-    writeString(name) + 
-    writeByte((int8_t)messageType) +
-    writeI32(seqid);
+  if (strict_write_) {
+    int32_t version = (VERSION_1) | ((int32_t)messageType);
+    return
+      writeI32(version) +
+      writeString(name) +
+      writeI32(seqid);
+  } else {
+    return 
+      writeString(name) + 
+      writeByte((int8_t)messageType) +
+      writeI32(seqid);
+  }
 }
 
 uint32_t TBinaryProtocol::writeMessageEnd() {
@@ -181,13 +189,31 @@
 uint32_t TBinaryProtocol::readMessageBegin(std::string& name,
 					   TMessageType& messageType,
 					   int32_t& seqid) {
-
   uint32_t result = 0;
-  int8_t type;
-  result+= readString(name);
-  result+=  readByte(type);
-  messageType = (TMessageType)type;
-  result+= readI32(seqid);
+  int32_t sz;
+  result += readI32(sz);
+
+  if (sz < 0) {
+    // Check for correct version number
+    int32_t version = sz & VERSION_MASK;
+    if (version != VERSION_1) {
+      throw TProtocolException(TProtocolException::BAD_VERSION, "Bad version identifier");
+    }
+    messageType = (TMessageType)(sz & 0x000000ff);
+    result += readString(name);
+    result += readI32(seqid);
+  } else {
+    if (strict_read_) {
+      throw TProtocolException(TProtocolException::BAD_VERSION, "No version identifier... old protocol client in strict mode?");
+    } else {
+      // Handle pre-versioned input
+      int8_t type;
+      result += readStringBody(name, sz);
+      result += readByte(type);
+      messageType = (TMessageType)type;
+      result += readI32(seqid);
+    }
+  }
   return result;
 }
 
@@ -344,6 +370,11 @@
   uint32_t result;
   int32_t size;
   result = readI32(size);
+  return result + readStringBody(str, size);
+}
+
+uint32_t TBinaryProtocol::readStringBody(string& str, int32_t size) {
+  uint32_t result = 0;
 
   // Catch error cases
   if (size < 0) {
@@ -370,8 +401,7 @@
   }
   trans_->readAll(string_buf_, size);
   str = string((char*)string_buf_, size);
-
-  return result + (uint32_t)size;
+  return (uint32_t)size;
 }
 
 }}} // facebook::thrift::protocol
diff --git a/lib/cpp/src/protocol/TBinaryProtocol.h b/lib/cpp/src/protocol/TBinaryProtocol.h
index 89220e2..6cf2c4b 100644
--- a/lib/cpp/src/protocol/TBinaryProtocol.h
+++ b/lib/cpp/src/protocol/TBinaryProtocol.h
@@ -20,20 +20,30 @@
  * @author Mark Slee <mcslee@facebook.com>
  */
 class TBinaryProtocol : public TProtocol {
+ protected:
+  static const int32_t VERSION_MASK = 0xffff0000;
+  static const int32_t VERSION_1 = 0x80010000;
+
  public:
   TBinaryProtocol(boost::shared_ptr<TTransport> trans) :
     TProtocol(trans),
     string_limit_(0),
     container_limit_(0),
+    strict_read_(false),
+    strict_write_(true),
     string_buf_(NULL),
     string_buf_size_(0) {}
 
   TBinaryProtocol(boost::shared_ptr<TTransport> trans,
                   int32_t string_limit,
-                  int32_t container_limit) :
+                  int32_t container_limit,
+                  bool strict_read,
+                  bool strict_write) :
     TProtocol(trans),
     string_limit_(string_limit),
     container_limit_(container_limit),
+    strict_read_(strict_read),
+    strict_write_(strict_write),
     string_buf_(NULL),
     string_buf_size_(0) {}
 
@@ -52,6 +62,11 @@
     container_limit_ = container_limit;
   }
 
+  void setStrict(bool strict_read, bool strict_write) {
+    strict_read_ = strict_read;
+    strict_write_ = strict_write;
+  }
+
   /**
    * Writing functions.
    */
@@ -157,10 +172,17 @@
 
   uint32_t readString(std::string& str);
 
+ protected:
+  uint32_t readStringBody(std::string& str, int32_t sz);
+
  private:
   int32_t string_limit_;
   int32_t container_limit_;
 
+  // Enforce presence of version identifier
+  bool strict_read_;
+  bool strict_write_;
+
   // Buffer for reading strings, save for the lifetime of the protocol to
   // avoid memory churn allocating memory on every string read
   uint8_t* string_buf_;
@@ -175,11 +197,15 @@
  public:
   TBinaryProtocolFactory() :
     string_limit_(0),
-    container_limit_(0) {}
+    container_limit_(0),
+    strict_read_(false),
+    strict_write_(true) {}
 
-  TBinaryProtocolFactory(int32_t string_limit, int32_t container_limit) :
+  TBinaryProtocolFactory(int32_t string_limit, int32_t container_limit, bool strict_read, bool strict_write) :
     string_limit_(string_limit),
-    container_limit_(container_limit) {}
+    container_limit_(container_limit),
+    strict_read_(strict_read),
+    strict_write_(strict_write) {}
 
   virtual ~TBinaryProtocolFactory() {}
 
@@ -191,13 +217,20 @@
     container_limit_ = container_limit;
   }
 
+  void setStrict(bool strict_read, bool strict_write) {
+    strict_read_ = strict_read;
+    strict_write_ = strict_write;
+  }
+
   boost::shared_ptr<TProtocol> getProtocol(boost::shared_ptr<TTransport> trans) {
-    return boost::shared_ptr<TProtocol>(new TBinaryProtocol(trans, string_limit_, container_limit_));
+    return boost::shared_ptr<TProtocol>(new TBinaryProtocol(trans, string_limit_, container_limit_, strict_read_, strict_write_));
   }
 
  private:
   int32_t string_limit_;
   int32_t container_limit_;
+  bool strict_read_;
+  bool strict_write_;
 
 };
 
diff --git a/lib/cpp/src/protocol/TProtocolException.h b/lib/cpp/src/protocol/TProtocolException.h
index 8f939c6..50959b7 100644
--- a/lib/cpp/src/protocol/TProtocolException.h
+++ b/lib/cpp/src/protocol/TProtocolException.h
@@ -31,7 +31,8 @@
     UNKNOWN = 0,
     INVALID_DATA = 1,
     NEGATIVE_SIZE = 2,
-    SIZE_LIMIT = 3
+    SIZE_LIMIT = 3,
+    BAD_VERSION = 4,
   };
 
   TProtocolException() :
diff --git a/lib/java/src/protocol/TBinaryProtocol.java b/lib/java/src/protocol/TBinaryProtocol.java
index be02a3e..7dff485 100644
--- a/lib/java/src/protocol/TBinaryProtocol.java
+++ b/lib/java/src/protocol/TBinaryProtocol.java
@@ -16,12 +16,30 @@
  */
 public class TBinaryProtocol extends TProtocol {
 
+  protected static final int VERSION_MASK = 0xffff0000;
+  protected static final int VERSION_1 = 0x80010000;
+
+  protected boolean strictRead_ = false;
+  protected boolean strictWrite_ = true;
+
   /**
    * Factory
    */
   public static class Factory implements TProtocolFactory {
+    protected boolean strictRead_ = false;
+    protected boolean strictWrite_ = true;
+    
+    public Factory() {
+      this(false, false);
+    }
+
+    public Factory(boolean strictRead, boolean strictWrite) {
+      strictRead_ = strictRead;
+      strictWrite_ = strictWrite;
+    }
+
     public TProtocol getProtocol(TTransport trans) {
-      return new TBinaryProtocol(trans);
+      return new TBinaryProtocol(trans, strictRead_, strictWrite_);
     }
   }
 
@@ -29,13 +47,27 @@
    * Constructor
    */
   public TBinaryProtocol(TTransport trans) {
-    super(trans);
+    this(trans, false, false);
   }
 
+  public TBinaryProtocol(TTransport trans, boolean strictRead, boolean strictWrite) {
+    super(trans);
+    strictRead_ = strictRead;
+    strictWrite_ = strictWrite;
+  }
+
+
   public void writeMessageBegin(TMessage message) throws TException {
-    writeString(message.name);
-    writeByte(message.type);
-    writeI32(message.seqid);
+    if (strictWrite_) {
+      int version = VERSION_1 | message.type;
+      writeI32(version);
+      writeString(message.name);
+      writeI32(message.seqid);
+    } else {
+      writeString(message.name);
+      writeByte(message.type);
+      writeI32(message.seqid);
+    }
   }
 
   public void writeMessageEnd() {}
@@ -137,9 +169,24 @@
 
   public TMessage readMessageBegin() throws TException {
     TMessage message = new TMessage();
-    message.name = readString();
-    message.type = readByte();
-    message.seqid = readI32();
+
+    int size = readI32();
+    if (size < 0) {
+      int version = size & VERSION_MASK;
+      if (version != VERSION_1) {
+        throw new TProtocolException(TProtocolException.BAD_VERSION, "Bad version in readMessageBegin");
+      }
+      message.type = (byte)(version & 0x000000ff);
+      message.name = readString();
+      message.seqid = readI32();
+    } else {
+      if (strictRead_) {
+        throw new TProtocolException(TProtocolException.BAD_VERSION, "Missing version in readMessageBegin, old client?");
+      }
+      message.name = readStringBody(size);
+      message.type = readByte();
+      message.seqid = readI32();
+    }
     return message;
   }
 
@@ -239,6 +286,10 @@
 
   public String readString() throws TException {
     int size = readI32();
+    return readStringBody(size);
+  }
+
+  public String readStringBody(int size) throws TException {
     byte[] buf = new byte[size];
     trans_.readAll(buf, 0, size);
     return new String(buf);
diff --git a/lib/java/src/protocol/TProtocolException.java b/lib/java/src/protocol/TProtocolException.java
index efc54b4..783b5be 100644
--- a/lib/java/src/protocol/TProtocolException.java
+++ b/lib/java/src/protocol/TProtocolException.java
@@ -19,6 +19,7 @@
   public static final int INVALID_DATA = 1;
   public static final int NEGATIVE_SIZE = 2;
   public static final int SIZE_LIMIT = 3;
+  public static final int BAD_VERSION = 4;
 
   protected int type_ = UNKNOWN;
 
diff --git a/lib/java/src/server/TThreadPoolServer.java b/lib/java/src/server/TThreadPoolServer.java
index 22930d5..0945fbe 100644
--- a/lib/java/src/server/TThreadPoolServer.java
+++ b/lib/java/src/server/TThreadPoolServer.java
@@ -58,6 +58,15 @@
 
   public TThreadPoolServer(TProcessor processor,
                            TServerTransport serverTransport,
+                           TProtocolFactory protocolFactory) {
+    this(processor, serverTransport,
+         new TTransportFactory(), new TTransportFactory(),
+         protocolFactory, protocolFactory,
+         new Options());
+  }
+
+  public TThreadPoolServer(TProcessor processor,
+                           TServerTransport serverTransport,
                            TTransportFactory transportFactory,
                            TProtocolFactory protocolFactory) {
     this(processor, serverTransport, 
diff --git a/lib/perl/lib/Thrift/BinaryProtocol.pm b/lib/perl/lib/Thrift/BinaryProtocol.pm
index c17fe91..c31e1d7 100644
--- a/lib/perl/lib/Thrift/BinaryProtocol.pm
+++ b/lib/perl/lib/Thrift/BinaryProtocol.pm
@@ -26,6 +26,9 @@
 package Thrift::BinaryProtocol;
 use base('Thrift::Protocol');
 
+use constant VERSION_MASK   => 0xffff0000;
+use constant VERSION_1      => 0x80010000;
+
 sub new
 {
     my $classname = shift;
@@ -41,8 +44,8 @@
     my ($name, $type, $seqid) = @_;
 
     return
+        $self->writeI32(VERSION_1 | $type) +
         $self->writeString($name) +
-        $self->writeByte($type) +
         $self->writeI32($seqid);
 }
 
@@ -224,9 +227,15 @@
     my $self = shift;
     my ($name, $type, $seqid) = @_;
 
+    my $version = 0;
+    my $result = $self->readI32($version);
+    if ($version & VERSION_MASK != VERSION_1) {
+      die new Thrift::TException('Missing version identifier')
+    }
+    $$type = $version & 0x000000ff;
     return
+        $result +
         $self->readString($name) +
-        $self->readByte($type) +
         $self->readI32($seqid);
 }
 
diff --git a/lib/perl/lib/Thrift/Protocol.pm b/lib/perl/lib/Thrift/Protocol.pm
index ceea52e..d58d8b0 100644
--- a/lib/perl/lib/Thrift/Protocol.pm
+++ b/lib/perl/lib/Thrift/Protocol.pm
@@ -26,7 +26,7 @@
 use constant INVALID_DATA  => 1;
 use constant NEGATIVE_SIZE => 2;
 use constant SIZE_LIMIT    => 3;
-
+use constant BAD_VERSION   => 4;
 
 sub new {
     my $classname = shift;
diff --git a/lib/php/src/protocol/TBinaryProtocol.php b/lib/php/src/protocol/TBinaryProtocol.php
index 962fcfe..69723da 100644
--- a/lib/php/src/protocol/TBinaryProtocol.php
+++ b/lib/php/src/protocol/TBinaryProtocol.php
@@ -19,15 +19,31 @@
  */
 class TBinaryProtocol extends TProtocol {
 
-  public function __construct($trans) {
+  const VERSION_MASK = 0xffff0000;
+  const VERSION_1 = 0x80010000;
+
+  private $strictRead_ = false;
+  private $strictWrite_ = true;
+
+  public function __construct($trans, $strictRead=false, $strictWrite=true) {
     parent::__construct($trans);
+    $this->strictRead_ = $strictRead;
+    $this->strictWrite_ = $strictWrite;
   }
 
   public function writeMessageBegin($name, $type, $seqid) {
-    return 
-      $this->writeString($name) +
-      $this->writeByte($type) +
-      $this->writeI32($seqid);
+    if ($this->strictWrite_) {
+      $version = self::VERSION_1 | $type;
+      return
+        $this->writeI32($version) +
+        $this->writeString($name) +
+        $this->writeI32($seqid);
+    } else {
+      return 
+        $this->writeString($name) +
+        $this->writeByte($type) +
+        $this->writeI32($seqid);
+    }
   }
 
   public function writeMessageEnd() {
@@ -50,7 +66,7 @@
 
   public function writeFieldEnd() {
     return 0;
-  } 
+  }
 
   public function writeFieldStop() {
     return
@@ -115,29 +131,29 @@
   public function writeI64($value) {
     // If we are on a 32bit architecture we have to explicitly deal with
     // 64-bit twos-complement arithmetic since PHP wants to treat all ints
-    // as signed and any int over 2^31 - 1 as a float   
+    // as signed and any int over 2^31 - 1 as a float
     if (PHP_INT_SIZE == 4) {
       $neg = $value < 0;
 
       if ($neg) {
-	$value *= -1;
+        $value *= -1;
       }
-   
+
       $hi = (int)($value / 4294967296);
       $lo = (int)$value;
-    
+
       if ($neg) {
-	$hi = ~$hi;
-	$lo = ~$lo;
-	if (($lo & (int)0xffffffff) == (int)0xffffffff) {
-	  $lo = 0;
-	  $hi++;
-	} else {
-	  $lo++;
-	}
+        $hi = ~$hi;
+        $lo = ~$lo;
+        if (($lo & (int)0xffffffff) == (int)0xffffffff) {
+          $lo = 0;
+          $hi++;
+        } else {
+          $lo++;
+        }
       }
       $data = pack('N2', $hi, $lo);
-    
+
     } else {
       $hi = $value >> 32;
       $lo = $value & 0xFFFFFFFF;
@@ -164,10 +180,29 @@
   }
 
   public function readMessageBegin(&$name, &$type, &$seqid) {
-    return 
-      $this->readString($name) +
-      $this->readByte($type) +
-      $this->readI32($seqid);
+    $result = $this->readI32($sz);
+    if ($sz < 0) {
+      $version = $sz & self::VERSION_MASK;
+      if ($version != self::VERSION_1) {
+        throw new TProtocolException('Bad version identifier: '.$sz, TProtocolException::BAD_VERSION);
+      }
+      $type = $sz & 0x000000ff;
+      $result +=
+        $this->readString($name) +
+        $this->readI32($seqid);
+    } else {
+      if ($this->strictRead_) {
+        throw new TProtocolException('No version identifier, old protocol client?', TProtocolException::BAD_VERSION);
+      } else {
+        // Handle pre-versioned input
+        $name = $this->trans_->readAll($sz);
+        $result += 
+          $sz +
+          $this->readByte($type) +
+          $this->readI32($seqid);
+      }
+    }
+    return $result;
   }
 
   public function readMessageEnd() {
@@ -266,7 +301,7 @@
     $data = $this->trans_->readAll(8);
 
     $arr = unpack('N2', $data);
-    
+
     // If we are on a 32bit architecture we have to explicitly deal with
     // 64-bit twos-complement arithmetic since PHP wants to treat all ints
     // as signed and any int over 2^31 - 1 as a float
@@ -350,8 +385,16 @@
  * Binary Protocol Factory
  */
 class TBinaryProtocolFactory implements TProtocolFactory {
+  private $strictRead_ = false;
+  private $strictWrite_ = false;
+
+  public function __construct($strictRead=false, $strictWrite=false) {
+    $this->strictRead_ = $strictRead;
+    $this->strictWrite_ = $strictWrite;
+  } 
+
   public function getProtocol($trans) {
-    return new TBinaryProtocol($trans);
+    return new TBinaryProtocol($trans, $this->strictRead, $this->strictWrite);
   }
 }
 
diff --git a/lib/php/src/protocol/TProtocol.php b/lib/php/src/protocol/TProtocol.php
index deddfa2..658e54c 100644
--- a/lib/php/src/protocol/TProtocol.php
+++ b/lib/php/src/protocol/TProtocol.php
@@ -28,6 +28,7 @@
   const INVALID_DATA = 1;
   const NEGATIVE_SIZE = 2;
   const SIZE_LIMIT = 3;
+  const BAD_VERSION = 4;
 
   function __construct($message=null, $code=0) {
     parent::__construct($message, $code);
diff --git a/lib/py/src/protocol/TBinaryProtocol.py b/lib/py/src/protocol/TBinaryProtocol.py
index 93734d4..3c236fb 100644
--- a/lib/py/src/protocol/TBinaryProtocol.py
+++ b/lib/py/src/protocol/TBinaryProtocol.py
@@ -13,13 +13,23 @@
 
   """Binary implementation of the Thrift protocol driver."""
 
-  def __init__(self, trans):
+  VERSION_MASK = 0xffff0000
+  VERSION_1 = 0x80010000
+
+  def __init__(self, trans, strictRead=False, strictWrite=True):
     TProtocolBase.__init__(self, trans)
+    self.strictRead = strictRead
+    self.strictWrite = strictWrite
 
   def writeMessageBegin(self, name, type, seqid):
-    self.writeString(name)
-    self.writeByte(type)
-    self.writeI32(seqid)
+    if self.strictWrite:
+      self.writeI32(VERSION_1 | type)
+      self.writeString(name)
+      self.writeI32(seqid)
+    else:
+      self.writeString(name)
+      self.writeByte(type)
+      self.writeI32(seqid)
 
   def writeMessageEnd(self):
     pass
@@ -93,9 +103,20 @@
     self.trans.write(str)
 
   def readMessageBegin(self):
-    name = self.readString()
-    type = self.readByte()
-    seqid = self.readI32()
+    sz = self.readI32()
+    if sz < 0:
+      version = sz & VERSION_MASK
+      if version != VERSION_1:
+        raise TProtocolException(TProtocolException.BAD_VERSION, 'Bad version in readMessageBegin: %d' % (sz))
+      type = version & 0x000000ff
+      name = self.readString()
+      seqid = self.readI32()
+    else:
+      if self.strictRead:
+        raise TProtocolException(TProtocolException.BAD_VERSION, 'No protocol version header')
+      name = self.trans.readAll(sz)
+      type = self.readByte()
+      seqid = self.readI32()
     return (name, type, seqid)
 
   def readMessageEnd(self):
@@ -179,6 +200,10 @@
     return str
 
 class TBinaryProtocolFactory:
+  def __init__(self, strictRead=False, strictWrite=True):
+    self.strictRead = strictRead
+    self.strictWrite = strictWrite
+
   def getProtocol(self, trans):
-    prot = TBinaryProtocol(trans)
+    prot = TBinaryProtocol(trans, self.strictRead, self.strictWrite)
     return prot
diff --git a/lib/py/src/protocol/TProtocol.py b/lib/py/src/protocol/TProtocol.py
index f7d0b34..146a802 100644
--- a/lib/py/src/protocol/TProtocol.py
+++ b/lib/py/src/protocol/TProtocol.py
@@ -16,6 +16,7 @@
   INVALID_DATA = 1
   NEGATIVE_SIZE = 2
   SIZE_LIMIT = 3
+  BAD_VERSION = 4
 
   def __init__(self, type=UNKNOWN, message=None):
     TException.__init__(self, message)
diff --git a/lib/rb/lib/thrift/protocol/tbinaryprotocol.rb b/lib/rb/lib/thrift/protocol/tbinaryprotocol.rb
index aaf7776..c8fa57d 100644
--- a/lib/rb/lib/thrift/protocol/tbinaryprotocol.rb
+++ b/lib/rb/lib/thrift/protocol/tbinaryprotocol.rb
@@ -11,13 +11,17 @@
 require 'thrift/protocol/tprotocol'
 
 class TBinaryProtocol < TProtocol
+
+  VERSION_MASK = 0xffff0000
+  VERSION_1 = 0x80010000
+
   def initialize(trans)
     super(trans)
   end
 
   def writeMessageBegin(name, type, seqid)
+    writeI32(VERSION_1 & type)
     writeString(name)
-    writeByte(type)
     writeI32(seqid)
   end
 
@@ -82,8 +86,12 @@
   end
 
   def readMessageBegin()
+    version = readI32()
+    if (version & VERSION_MASK != VERSION_1)
+      raise TProtocolException.new(TProtocolException::BAD_VERSION, 'Missing version identifier')
+    end
+    type = version & 0x000000ff
     name = readString()
-    type = readByte()
     seqid = readI32()
     return name, type, seqid
   end
diff --git a/lib/rb/lib/thrift/protocol/tprotocol.rb b/lib/rb/lib/thrift/protocol/tprotocol.rb
index 3c13b4b..da079d1 100644
--- a/lib/rb/lib/thrift/protocol/tprotocol.rb
+++ b/lib/rb/lib/thrift/protocol/tprotocol.rb
@@ -11,6 +11,23 @@
 
 require 'thrift/thrift'
 
+class TProtocolException < TException
+
+  UNKNOWN = 0
+  INVALID_DATA = 1
+  NEGATIVE_SIZE = 2
+  SIZE_LIMIT = 3
+  BAD_VERSION = 4
+
+  attr_reader :type
+
+  def initialize(type=UNKNOWN, message=nil)
+    super(message)
+    @type = type
+  end
+
+end
+
 class TProtocol
   
   attr_reader :trans