rstyx 0.2.0 → 0.3.0

data/lib/rstyx/messages.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/ruby
 #
-# Copyright (C) 2005 Rafael Sevilla
+# Copyright (C) 2005,2006 Rafael Sevilla
 # This file is part of RStyx
 #
 # RStyx is free software; you can redistribute it and/or modify
@@ -15,16 +15,16 @@
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with RStyx; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-# 02111-1307 USA.
+# Foundation, Inc., 51 Franklin St., Fifth Floor, Boston, MA
+# 02110-1301 USA.
 #
 # Styx Message classes and utility functions
 #
 # Author:: Rafael R. Sevilla (mailto:dido@imperium.ph)
-# Copyright:: Copyright (c) 2005 Rafael R. Sevilla
+# Copyright:: Copyright (c) 2005,2006 Rafael R. Sevilla
 # License:: GNU Lesser General Public License
 #
-# $Id: messages.rb,v 1.26 2005/11/01 11:40:26 dido Exp $
+# $Id: messages.rb 229 2007-08-10 08:03:58Z dido $
 #
 
 require 'rstyx/errors'
@@ -32,52 +32,6 @@ require 'rstyx/errors'
 module RStyx
 
   module Message
-    ##
-    # Utility class
-    #
-    class Util
-      ##
-      # Extract a Ruby string given a byte string, with an offset pointing
-      # to the start of the Styx string to extract.  Returns the Styx string
-      # plus the offset of the first character just after the end of the
-      # string thus extracted.
-      #
-      # +str+:: [String] the byte string to extract from
-      # +offset+:: [Fixnum] an offset into str for the Styx string to be
-      #            extracted
-      # return value::  [Array]
-      #   0:: [String] the Ruby string
-      #   1:: [Fixnum] the offset of the first character after
-      #
-      # raises:: StyxException, if no length was found or if the length
-      #          of the string is different from its declared length.
-      #
-      def Util.strextract(str, offset)
-        length = (str[offset..(offset + 1)].unpack("v"))[0]
-        if length.nil?
-          raise StyxException.new("invalid string, no length found")
-        end
-
-        offset += 2
-        nstr = (str[offset..(offset + length - 1)])
-        if (nstr.length != length)
-          raise StyxException.new("invalid string")
-        end
-        return([nstr, offset + length])
-      end
-    
-      ##
-      # Pack a string into the canonical format of number of bytes as short
-      # unsigned int followed by the string itself
-      #
-      # +str+:: [String] the Ruby string to pack
-      # return value:: [String] the corresponding Styx string
-      #
-      def Util.strpack(str)
-        return([str.length, str].pack("vA*"))
-      end
-    end
-
     ##
     # Class representing the server's view of a file.
     #
@@ -100,6 +54,13 @@ module RStyx
         @path = path
       end
 
+      ##
+      # Equality
+      #
+      def ==(x)
+        return(self.to_bytes == x.to_bytes)
+      end
+
       ##
       # Get the byte string representation of the Qid
       #
@@ -118,7 +79,7 @@ module RStyx
       # return value:: [Qid] the Qid represented by the byte string.
       # raises:: StyxException if the string cannot be decoded as a Qid
       #
-      def Qid.decode(msgbytes)
+      def self.from_bytes(msgbytes)
         qtype, version, pathlo, pathhi = msgbytes.unpack("CVVV")
         if qtype.nil? || version.nil? || pathlo.nil? || pathhi.nil?
           raise StyxException.new("QID failed decode")
@@ -134,23 +95,38 @@ module RStyx
       # return value:: [String] a textual representation of the Qid
       #
       def to_s
-        return(sprintf("qid(%s, %s, %s)", @qtype, @version, @path))
+        val = sprintf("(Qid 0x%02x %d 0x%02x)", @qtype, @version, @path)
+        return(val)
       end
     end
 
     ##
     # Class representing an entry in a directory (e.g. the result of a
-    # stat message)
+    # stat message).  See Inferno man page stat(5) for more details.
     #
-    class DirEntry
+    class Stat
       attr_accessor :size, :dtype, :dev, :qid, :mode, :atime, :mtime
       attr_accessor :length, :name, :uid, :gid, :muid
 
+      def self.strextract(str, offset)
+        length = (str[offset..(offset + 1)].unpack("v"))[0]
+        if length.nil?
+          raise StyxException.new("invalid string, no length found")
+        end
+
+        offset += 2
+        nstr = (str[offset..(offset + length - 1)])
+        if (nstr.length != length)
+          raise StyxException.new("invalid string")
+        end
+        return([nstr, offset + length])
+      end
+
       ##
-      # Serialize a DirEntry.  This also calculates the size of the
-      # DirEntry in bytes.
+      # Serialize a Stat.  This also calculates the size of the
+      # Stat in bytes.
       #
-      # return value:: [String] the serialized version of the DirEntry
+      # return value:: [String] the serialized version of the Stat
       #
       def to_bytes
         str = [@dtype, @dev].pack("vV")
@@ -158,24 +134,27 @@ module RStyx
         lengthlo = @length & 0xffffffff
         lengthhi = (@length >> 32) & 0xffffffff
         str << [@mode, @atime, @mtime, lengthlo, lengthhi].pack("VVVVV")
-        str << Util.strpack(@name)
-        str << Util.strpack(@uid)
-        str << Util.strpack(@gid)
-        str << Util.strpack(@muid)
+        str << [@name.length, @name].pack("va*")
+        @uid ||= ""
+        @gid ||= ""
+        @muid ||= ""
+        str << [@uid.length, @uid].pack("va*")
+        str << [@gid.length, @gid].pack("va*")
+        str << [@muid.length, @muid].pack("va*")
         @size = str.length
         return([@size].pack("v") + str)
       end
 
       ##
-      # Unserialize a DirEntry
+      # Unserialize a Stat
       #
-      # +bytes+:: [String] serialized string representation of a DirEntry
-      # return value:: [DirEntry] the DirEntry corresponding to the
+      # +bytes+:: [String] serialized string representation of a Stat
+      # return value:: [Stat] the Stat corresponding to the
       #                passed string
       # raises:: StyxException if +bytes+ cannot be properly decoded as
-      #          a DirEntry
+      #          a Stat
       #
-      def DirEntry.decode(bytes)
+      def self.from_bytes(bytes)
         # From Inferno stat(5)
         #
         # 0-1 = size
@@ -193,1240 +172,525 @@ module RStyx
         # 43 + namelen to 44 + namelen = uid length
         # 45 + namelen to 44 + namelen + uidlen = uid
         # 45 + namelen + uidlen
-        de = DirEntry.new
+        de = Stat.new
         de.size, de.dtype, de.dev = (bytes[0..7]).unpack("vvV")
         if de.size.nil? || de.dtype.nil? || de.dev.nil?
-          raise RStyx::StyxException.new("failed to decode DirEntry")
+          raise RStyx::StyxException.new("failed to decode Stat")
         end
-        de.qid = Qid.decode(bytes[8..20])
+        de.qid = Qid.from_bytes(bytes[8..20])
         de.mode, de.atime, de.mtime, lengthlo, lengthhi =
           (bytes[21..40]).unpack("VVVVV")
 
         if de.mode.nil? || de.atime.nil? || de.mtime.nil? || 
             lengthlo.nil? || lengthhi.nil?
-          raise RStyx::StyxException.new("failed to decode DirEntry")
+          raise RStyx::StyxException.new("failed to decode Stat")
         end
         # combine in little-endian
         de.length = lengthlo | (lengthhi << 32)
-        de.name, offset = Util.strextract(bytes, 41)
-        de.uid, offset = Util.strextract(bytes, offset)
-        de.gid, offset = Util.strextract(bytes, offset)
-        de.muid, offset = Util.strextract(bytes, offset)
+        de.name, offset = self.strextract(bytes, 41)
+        de.uid, offset = self.strextract(bytes, offset)
+        de.gid, offset = self.strextract(bytes, offset)
+        de.muid, offset = self.strextract(bytes, offset)
         return(de)
       end
 
       ##
-      # convert a DirEntry to a human-readable string
+      # convert a Stat to a human-readable string
       #
-      # return value:: a string representation of the DirEntry
+      # return value:: a string representation of the Stat
       #
       def to_s
-        s = sprintf("DirEntry(%s, %s, %s, ", @size, @dtype, @dev)
-        s << sprintf("%s, %s, %s, %s, ", @qid.to_s, @mode, @atime, @mtime)
-        s << sprintf("%s, %s, %s, ", @length, @name, @uid)
-        s << sprintf("%s, %s)", @gid, @muid)
+        s = sprintf("(Stat %d 0x%02x, 0x%04x ", @size, @dtype, @dev)
+        s << sprintf("%s, 0x%04x 0x%04x 0x%04x ",
+                     @qid.to_s, @mode, @atime, @mtime)
+        s << sprintf("%d %s %s ", @length, @name, @uid)
+        s << sprintf("%s %s)", @gid, @muid)
         return(s)
       end
     end
 
     ##
-    # Abstract class representing a message in the Styx protocol.
-    # The basic attributes are the length, type, tag, messagebody,
-    # and (printable) body.
+    # Base class of a Styx message.
     #
     class StyxMessage
-      attr_accessor :length, :mtype, :tag, :messagebody, :body
+      attr_accessor :fieldvals
+      MESSAGE_IDS = {}
 
       ##
-      # Convert the message to a string of bytes for transmission.
+      # Add a field to the StyxMessage.  Used by subclasses to define
+      # the message field.  The +name+ should be a Symbol that gives
+      # the name of the field (preferably the canonical name given in the
+      # Inferno manual page intro(5)), and the type may be:
       #
-      # +tag+:: [Fixnum] The tag value to use for the message.  If
-      #         not specified, leave the tag value as is.
-      # return value:: [String] The marshalled byte string of the message
+      # 1. Any valid format string used by String#unpack or Array#pack.
+      # 2. Cstr, which is a UTF-8 string, which will be serialized as
+      #    a two-byte unsigned length (in bytes) followed by the string's
+      #    data itself, and deserialized from this representation into
+      #    a standard Ruby string.
+      # 3. CstrList, which deserializes into an array of Ruby strings,
+      #    and is serialized into a two-byte unsigned count of strings
+      #    followed by each of the strings itself, as in Cstr.
+      # 3. Bstr, which is a binary string.  It will be serialized to a
+      #    four-byte unsigned length (in bytes) followed by the string's
+      #    data itself, and deserialized from this representation into
+      #    a standard Ruby string.
+      # 4. Qid, which deserializes into a Qid object instance and is
+      #    serialized into a 13-byte binary representation.
+      # 5. QidList, which deserializes into an array of Qids and is
+      #    serialized into a two-byte unsigned count of Qids followed
+      #    by the serialized representations of each of the Qids.
+      # 6. ULongLong, which deserializes into a Ruby Fixnum and is
+      #    serialized into a 64-bit little-endian value.
+      # 7. Stat, which deserializes into a Stat object instance and is
+      #    serialized into the stat format described in the Inferno
+      #    man page stat(5).  See the Stat class for more details.
       #
-      def to_bytes(tag=nil)
-        unless tag.nil?
-          @tag = tag
+      def self.add_field(name, type)
+        self.fields << [name, type]
+
+        # Create accessor methods for the field
+        define_method(name) do
+          instance_variable_get("@fieldvals")[name]
+        end
+
+        define_method(name.to_s + "=") do |val|
+          fname = instance_variable_get("@fieldvals")
+          fname[name] = val
         end
-        val = [@length, @mtype, @tag].pack("VCv") + @messagebody
-        return(val)
       end
 
       ##
-      # Dump the Styx message to a string.  The StyxMessage subclass
-      # must define the @body variable to something meaningful for
-      # this to work.
+      # The fields of the Styx message.
       #
-      # return value:: human-readable string representing the Styx message
-      #
-      def to_s
-        return(sprintf("%s: %s, %s, %s, %s",
-                       self.class.name, @length, @mtype, @tag, @body))
+      def self.fields
+        # Default fields (excluding the size[4] field)
+        @fields ||= [[:ident, 'C'], [:tag, 'v']]
       end
 
-      TVERSION = 100
-      RVERSION = 101
-
-      TAUTH = 102
-      RAUTH = 103
- 
-      TATTACH = 104
-      RATTACH = 105
-
-      # illegal
-      TERROR = 106
-      RERROR = 107
-
-      TFLUSH = 108
-      RFLUSH = 109
-
-      TWALK = 110
-      RWALK = 111
-
-      TOPEN = 112
-      ROPEN = 113
-
-      TCREATE = 114
-      RCREATE = 115
-
-      TREAD = 116
-      RREAD = 117
-
-      TWRITE = 118
-      RWRITE = 119
-
-      TCLUNK = 120
-      RCLUNK = 121
-
-      TREMOVE = 122
-      RREMOVE = 123
-
-      TSTAT = 124
-      RSTAT = 125
-
-      TWSTAT = 126
-      RWSTAT = 127
-
       ##
-      # Decode an arbitrary Styx message, returning the appropriate
-      # subclass instance.
-      #
-      # +message+:: [String] The Styx message in serialized form
-      # return value:: [StyxMessage] instance of StyxMessage subclass
-      #                corresponding to the message.
-      # raises:: StyxException if a Styx message could not be decoded
-      #
-      def StyxMessage.decode(message)
-        length, type, tag = message[0..6].unpack("VCv")
-        if length.nil? || type.nil? || tag.nil?
-          raise RStyx::StyxException.new("invalid Styx message")
-        end
-        msgclass = case type
-                   when TVERSION then Tversion
-                   when RVERSION then Rversion
-                   when TAUTH then Tauth
-                   when RAUTH then Rauth
-                   when TATTACH then Tattach
-                   when RATTACH then Rattach
-                   when RERROR then Rerror
-                   when TFLUSH then Tflush
-                   when RFLUSH then Rflush
-                   when TWALK then Twalk
-                   when RWALK then Rwalk
-                   when TOPEN then Topen
-                   when ROPEN then Ropen
-                   when TCREATE then Tcreate
-                   when RCREATE then Rcreate
-                   when TREAD then Tread
-                   when RREAD then Rread
-                   when TWRITE then Twrite
-                   when RWRITE then Rwrite
-                   when TCLUNK then Tclunk
-                   when RCLUNK then Rclunk
-                   when TREMOVE then Tremove
-                   when RREMOVE then Rremove
-                   when TSTAT then Tstat
-                   when RSTAT then Rstat
-                   when TWSTAT then Twstat
-                   when RWSTAT then Rwstat
-                   else raise StyxException.new("invalid message type #{type}")
-                   end
-        msgobj = msgclass.decode(message)
-        msgobj.length = length
-        msgobj.mtype = type
-        msgobj.tag = tag
-        return(msgobj)
+      # Create a new StyxMessage class.  This takes a hash of field
+      # names and values, and this is put into a hash.
+      def initialize(fieldvals={})
+        ident = MESSAGE_IDS[self.class]
+        @fieldvals = {:ident=>ident}.merge(fieldvals)
       end
 
-    end
-
-    ##
-    # Message sent to negotiate the protocol version and message size.
-    # This should be the first message sent on the Styx connection.
-    #
-    class Tversion < StyxMessage
-      attr_accessor :msize, :version
-
       ##
-      # Construct a new Tversion message
-      #
-      # +msize+:: [Fixnum] maximum message size
-      # +version+:: [String] the version number we use
+      # Return the identifier of the message (code).  This cannot
+      # be changed.
       #
-      def initialize(msize=8216, version="9P2000")
-        @msize = msize
-        @version = version
-        @length = 13 + @version.length
-        @mtype = TVERSION
-        @messagebody = [@msize].pack("V") + Util.strpack(@version)
-        @body = sprintf("%s, %s", @msize, @version)
+      def ident
+        return(@fieldvals[:ident])
       end
 
       ##
-      # Decode a Tversion message.  Do not call this method directly.
+      # Return the tag of the message
       #
-      # +message+:: [String] raw message string
-      # return value:: [Tversion] Tversion instance
-      # raises:: StyxException if the message could not be decoded
-      #
-      def Tversion.decode(message)
-        msize = message[7..10].unpack("V")[0]
-        if msize.nil?
-          raise StyxException.new("Invalid Tversion message")
-        end
-        version, offset = Util.strextract(message, 11)
-        return(Tversion.new(msize, version))
+      def tag
+        return(@fieldvals[:tag])
       end
 
-    end
-
-    ##
-    # Response by Styx server to Tversion message sent by client when
-    # a connection is initiated.
-    #
-    class Rversion < StyxMessage
-      attr_accessor :msize, :version
-
       ##
-      # Construct a new Rversion message
-      #
-      # +msize+:: [Fixnum] maximum message size
-      # +version+:: [String] the version number we use
-      #
-      def initialize(msize=8216, version="9P2000")
-        @msize = msize
-        @version = version
-        @length = 13 + @version.length
-        @mtype = RVERSION
-        @messagebody = [@msize].pack("V") + Util.strpack(@version)
-        @body = sprintf("%s, %s", @msize, @version)
+      # Set the tag of the message
+      def tag=(t)
+        return(@fieldvals[:tag] = t)
       end
 
       ##
-      # Decode an Rversion message.  Do not call this method directly.
-      #
-      # +message+:: [String] raw message string
-      # return value:: [Rversion] Rversion instance
-      # raises:: StyxException if the message could not be decoded.
+      # Deserialize a byte string into a StyxMessage subclass of some
+      # kind.
       #
-      def Rversion.decode(message)
-        msize = message[7..10].unpack("V")[0]
-        if msize.nil?
-          raise StyxException.new("Invalid Rversion message")
+      def self.from_bytes(str)
+        origlength = str.length
+        # get the length, identifier, and the rest of the string
+        len, ident, str = str.unpack("VCa*")
+        if len.nil? || len > origlength
+          raise StyxException.new("message string too short: #{len} bytes expected, only #{origlength} available")
+        end
+        c = MESSAGE_IDS.index(ident)
+        if c.nil?
+          raise StyxException.new("Unknown message type identifier #{ident.inspect}")
         end
-        version, offset = Util.strextract(message, 11)
-        return(Rversion.new(msize, version))
+        obj = c.new
+        c.fields.each do |name,type|
+          if name == :ident
+            next
+          end
+          val = nil
+          case type
+          when "Cstr"
+            len, str = str.unpack("va*")
+            val, str = str.unpack("a#{len}a*")
+          when "CstrList"
+            nstr, str = str.unpack("va*")
+            val = []
+            1.upto(nstr) do
+              len, str = str.unpack("va*")
+              xstr, str = str.unpack("a#{len}a*")
+              val << xstr
+            end
+          when "Bstr"
+            len, str = str.unpack("Va*")
+            val, str = str.unpack("a#{len}a*")
+          when "Qid"
+            qid, str = str.unpack("a#{Qid::QID_LENGTH}a*")
+            val = Qid.from_bytes(qid)
+          when "QidList"
+            nqid, str = str.unpack("va*")
+            val = []
+            1.upto(nqid) do
+              qid,str = str.unpack("a#{Qid::QID_LENGTH}a*")
+              val << Qid.from_bytes(qid)
+            end
+          when "Stat"
+            # See the corresponding comments under to_bytes
+            # (from when "Stat") for why we do it this way.
+            slen1 = str.unpack("v")
+            slen1, stat, str = str.unpack("va#{slen1}a*")
+            val = Stat.from_bytes(stat)
+          when "ULongLong"
+            v1, v2, str = str.unpack("VVa*")
+            # v1 - low word, v2 = high word
+            val = v2 << 32 | v1
+          else
+            val, str = str.unpack(type + "a*")
+          end
+          obj.fieldvals[name] = val
+        end
+        return(obj)
       end
 
-    end
-
-    ##
-    # Message sent to authenticate a user to the server
-    #
-    class Tauth < StyxMessage
-      attr_accessor :afid, :uname, :aname
-
-      NOFID = 0xffffffff
-
       ##
-      # Construct a new Tauth message.
+      # Serialize a Styx message subclass into a byte string.
       #
-      # +uname+:: [String] user name to attach as
-      # +afid+:: [Fixnum] authenticated fid from auth protocol
-      # +aname+:: [String] file tree to access
-      # 
-      def initialize(uname, afid, aname)
-        @afid = afid
-        @uname = uname
-        @aname = aname
-        @length = 15 + @uname.length + @aname.length
-        @mtype = TAUTH
-        @messagebody = [@afid].pack("V")
-        @messagebody << Util.strpack(uname)
-        @messagebody << Util.strpack(aname)
-        @body = sprintf("%s, %s, %s", @afid, @uname, @aname)
+      def to_bytes
+        str = ""
+        self.class.fields.each do |name,type|
+          case type
+          when "Cstr"
+            str << [@fieldvals[name].length, @fieldvals[name]].pack("va*")
+          when "CstrList"
+            strlist = @fieldvals[name]
+            str << [strlist.length].pack("v")
+            strlist.each do |s|
+              str << [s.length, s].pack("va*")
+            end
+          when "Bstr"
+            str << [@fieldvals[name].length, @fieldvals[name]].pack("Va*")
+          when "Qid"
+            str << @fieldvals[name].to_bytes
+          when "QidList"
+            qlist = @fieldvals[name]
+            str << [qlist.length].pack("v")
+            qlist.each do |q|
+              str << q.to_bytes
+            end
+          when "ULongLong"
+            # low dword
+            str << [@fieldvals[name] & 0xffffffff].pack("V")
+            # high dword
+            str << [(@fieldvals[name] >> 32) & 0xffffffff].pack("V")
+          when "Stat"
+            # From the Inferno stat(5) man page:
+            #
+            #   To make the contents of a directory, such as returned
+            #   by read(5), easy to  parse, each directory entry
+            #   begins with a size field.  For consistency, the entries
+            #   in Twstat and Rstat  messages  also contain their
+            #   size, which means the size appears twice.
+            #
+            # And so this is why we prefix the serialized version of
+            # the stat message with the size here, and when deserializing
+            # we do the same thing.
+            #
+            statstr = @fieldvals[name].to_bytes
+            str << [statstr.length, statstr].pack("va*")
+          else
+            # format string for Array#pack
+            str << [@fieldvals[name]].pack(type)
+          end
+        end
+        # add length
+        str = [str.length + 4].pack("V") + str
+        return(str)
       end
 
       ##
-      # Decode a Tauth message.
-      #
-      # +message+:: [String] the message to decode
-      # return:: [Tauth] the Tauth object
-      #
-      def Tauth.decode(message)
-        afid = message[7..10].unpack("V")[0]
-        if afid.nil?
-          raise RStyx::StyxException.new("invalid Tauth message")
+      # Convert a Styx message into a human-readable string.
+      def to_s
+        # First, start with the Styx message class name
+        str = "(" + self.class.to_s.split("::")[-1]
+        self.class.fields.each do |name, type|
+          # Ignore ident (redundant, as it is already expressed in
+          # the class name)
+          if name == :ident
+            next
+          end
+          str << " " + name.inspect + "=>" + @fieldvals[name].to_s.inspect
         end
-        uname, offset = Util.strextract(message, 11)
-        aname, offset = Util.strextract(message, offset)
-        return(Tauth.new(uname, afid, aname))
+        str << ")"
       end
 
     end
 
     ##
-    # Server response to Rauth message, giving qid of authenticator qid.
+    # Class representing a Tversion message sent by a Styx client.
     #
-    class Rauth < StyxMessage
-      attr_accessor :aqid
-
-      ##
-      # Construct a new Rauth message
-      #
-      # +qid+:: [Qid] The qid of the authenticator file
-      #
-      def initialize(qid)
-        @aqid = qid
-        @length = 20            # exact length
-        @mtype = RAUTH
-        @messagebody = @aqid.to_bytes
-      end
-
-      ##
-      # Decode an Rauth message.
-      #
-      # +message+:: [String] the message to decode
-      # return:: [Rauth] the Rauth object
-      #
-      def Rauth.decode(message)
-        qid = Qid.decode(message[7..19])
-        return(Rauth.new(qid))
-      end
+    class Tversion < StyxMessage
+      StyxMessage::MESSAGE_IDS[Tversion] = 100
+      # 
+      add_field(:msize, 'V')
+      add_field(:version, 'Cstr')
     end
 
     ##
-    # Message returned to indicate an error condition
+    # Class representing an Rversion message sent by a Styx server.
     #
-    class Rerror < StyxMessage
-      attr_accessor :ename
-
-      ##
-      # Construct a new Rerror message given the error name
-      #
-      # +ename+:: [String] error name for error object
-      #
-      def initialize(ename)
-        @ename = ename
-        @length = 9 + @ename.length
-        @mtype = RERROR
-        @body = ename
-        @messagebody = Util.strpack(@ename)
-      end
-
-      ##
-      # Decode an Rerror message.  Do not use this method directly.
-      # Use only from within StyxMessage.decode.
-      #
-      # +message+:: [String] raw message string
-      # return:: [Rerror] Rerror instance
-      #
-      def Rerror.decode(message)
-        ename, offset = Util.strextract(message, 7)
-        return(Rerror.new(ename))
-      end
-
+    class Rversion < StyxMessage
+      StyxMessage::MESSAGE_IDS[Rversion] = 101
+      add_field(:msize, 'V')
+      add_field(:version, 'Cstr')
     end
 
     ##
-    # Message sent to abort a previous message.
+    # Class representing a Tauth message sent by a Styx client.
     #
-    class Tflush < StyxMessage
-      attr_accessor :oldtag
-
-      ##
-      # Construct a new Tflush message given the tag to flush
-      #
-      # +oldtag+:: the tag to flush
-      #
-      def initialize(oldtag)
-        @length = 9
-        @mtype = TFLUSH
-        @oldtag = oldtag
-        @messagebody = [@oldtag].pack("v")
-        @body = sprintf("%s", oldtag)
-      end
-
-      ##
-      # Decode a Tflush message.  Do not use this method directly.
-      # Use only from within StyxMessage.decode.
-      #
-      # +message+:: [String] raw message string
-      # return:: [Tflush] Tflush instance represented by string
-      #
-      def Tflush.decode(message)
-        oldtag = message[7..8].unpack("v")[0]
-        if (oldtag.nil?)
-          raise RStyx::StyxException.new("invalid Tflush message")
-        end
-        return(Tflush.new(oldtag))
-      end
-
+    class Tauth < StyxMessage
+      StyxMessage::MESSAGE_IDS[Tauth] = 102
+      add_field(:afid, 'V')
+      add_field(:uname, 'Cstr')
+      add_field(:aname, 'Cstr')
     end
 
     ##
-    # Server response to a Tflush message
+    # Class representing an Rauth message sent by a Styx server.
     #
-    class Rflush < StyxMessage
-      ##
-      # Make an Rflush message
-      #
-      def initialize
-        @mtype = RFLUSH
-        @length = 7
-        @messagebody = ""
-        @body = ""
-      end
-
-      ##
-      # Decode an Rflush message
-      #
-      # +message+:: [String] raw message string
-      # return:: [Rflush] Rflush instance represented by string
-      #
-      def Rflush.decode(message)
-        # This does absolutely nothing!  An RFlush is nothing but a
-        # bare StyxMessage.
-        return(Rflush.new)
-      end
+    class Rauth < StyxMessage
+      StyxMessage::MESSAGE_IDS[Rauth] = 103
+      add_field(:aqid, 'Qid')
     end
 
     ##
-    # Message sent to attach to the server as a certain user
+    # Class representing a Tattach message sent by a Styx client.
     #
     class Tattach < StyxMessage
-      attr_accessor :fid, :afid, :uname, :aname
-
-      NOFID = 0xffffffff
-
-      ##
-      # Construct a new Tattach message.
-      #
-      # +fid+:: [Fixnum] fid for the attach message
-      # +uname+:: [String] user name to attach as
-      # +afid+:: [Fixnum] authenticated fid from auth protocol
-      # +aname+:: [String] file tree to access
-      # 
-      def initialize(fid, uname, afid=NOFID, aname="")
-        @fid = fid
-        @afid = afid
-        @uname = uname
-        @aname = aname
-        @length = 19 + @uname.length + @aname.length
-        @mtype = TATTACH
-        @messagebody = [@fid, @afid].pack("VV")
-        @messagebody << Util.strpack(uname)
-        @messagebody << Util.strpack(aname)
-        @body = sprintf("%s, %s, %s, %s", @fid, @afid, @uname, @aname)
-      end
-
-      ##
-      # Decode a Tattach message.
-      #
-      # +message+:: [String] the message to decode
-      # return:: [Tattach] the Tattach object
-      #
-      def Tattach.decode(message)
-        fid, afid = message[7..14].unpack("VV")
-        if fid.nil? || afid.nil?
-          raise RStyx::StyxException.new("invalid Tattach message")
-        end
-        uname, offset = Util.strextract(message, 15)
-        aname, offset = Util.strextract(message, offset)
-        return(Tattach.new(fid, uname, afid, aname))
-      end
-
+      StyxMessage::MESSAGE_IDS[Tattach] = 104
+      add_field(:fid, 'V')
+      add_field(:afid, 'V')
+      add_field(:uname, 'Cstr')
+      add_field(:aname, 'Cstr')
     end
 
     ##
-    # Server response to Tattach message, giving qid of root
+    # Class representing an Rattach message sent by a Styx server.
     #
     class Rattach < StyxMessage
-      attr_accessor :qid
+      StyxMessage::MESSAGE_IDS[Rattach] = 105
+      add_field(:qid, 'Qid')
+    end
 
-      ##
-      # Construct a new Rattach message
-      #
-      # +qid+:: [Qid] the qid of the root
-      #
-      def initialize(qid)
-        @qid = qid
-        @length = 20            # exact length
-        @mtype = RATTACH
-        @messagebody = @qid.to_bytes
-        @body = @qid.to_s
+    ##
+    # Class representing a Terror message.  This is not actually valid
+    # and should never be used.
+    #
+    class Terror < StyxMessage
+      StyxMessage::MESSAGE_IDS[Terror] = 106
+      def initialize
+        raise StyxException.new("Terror class instantiated")
       end
+    end
 
-      ##
-      # Decode an Rattach message.
-      #
-      # +message+:: [String] the message to decode
-      # return:: [Rattach] the Rattach object
-      #
-      def Rattach.decode(message)
-        qid = Qid.decode(message[7..19])
-        return(Rattach.new(qid))
-      end
+    ##
+    # Class representing an Rerror message sent by a Styx server.
+    #
+    class Rerror < StyxMessage
+      StyxMessage::MESSAGE_IDS[Rerror] = 107
+      add_field(:ename, "Cstr")
     end
 
     ##
-    # Message sent to get a handle to a file on the server
+    # Class representing a Tflush message sent by a Styx client.
     #
-    class Twalk < StyxMessage
-      attr_accessor :fid, :newfid, :path, :path_elements
-      MAXWELEM = 16             # maximum of sixteen name elements
-      ##
-      # Construct a new Twalk message given a fid, the newfid to use,
-      # and the path on the server, separated by forward slashes ('/').
-      #
-      # +fid+:: [Fixnum] initial existing fid
-      # +newfid+:: [Fixnum] proposed new fid
-      # +path+:: [String] new path desired
-      #
-      def initialize(fid, newfid, path)
-        @fid = fid
-        @newfid = newfid
-        @mtype = TWALK
-        @path_elements = []
-        @length = 17            # updated by length of path elements
-        path_elem_str = ""
-        # Cycle through the path elements, adding them to a message string
-        path.split("/").each do |elem|
-          if elem.length <= 0
-            next
-          end
-          @length += elem.length + 2
-          path_elem_str << Util.strpack(elem)
-          @path_elements << elem
-        end
-        if @path_elements.length > MAXWELEM
-          raise StyxException.new("path exceeded MAXWELEM (#{MAXWELEM}) elements; break the walk into several messages")
-        end
-        @messagebody = [@fid, @newfid, @path_elements.length].pack("VVv") + path_elem_str
-        @body = sprintf("%s, %s, %s", @fid, @newfid, path)
-      end
+    class Tflush < StyxMessage
+      StyxMessage::MESSAGE_IDS[Tflush] = 108
+      add_field(:oldtag, "v")
+    end
 
-      ##
-      # Decode a Twalk message.
-      #
-      # +message+:: [String] the message to decode
-      # return:: [Twalk] the Twalk object
-      #
-      def Twalk.decode(message)
-        fid, newfid, nwname = message[7..16].unpack("VVv")
-        if fid.nil? || newfid.nil? || nwname.nil?
-          raise RStyx::StyxException.new("invalid Twalk message")
-        end
-        offset = 17
-        path_elements = []
-        1.upto(nwname) do
-          wname, offset = Util.strextract(message, offset)
-          path_elements << wname
-        end
-        return(Twalk.new(fid, newfid, path_elements.join("/")))
-      end
+    ##
+    # Class representing an Rflush message sent by a Styx server.
+    #
+    class Rflush < StyxMessage
+      StyxMessage::MESSAGE_IDS[Rflush] = 109
     end
 
     ##
-    # Server reply to Twalk message
+    # Class representing a Twalk message sent by a Styx client.
     #
-    class Rwalk < StyxMessage
-      attr_accessor :qids
+    class Twalk < StyxMessage
+      StyxMessage::MESSAGE_IDS[Twalk] = 110
+      add_field(:fid, "V")
+      add_field(:newfid, "V")
+      add_field(:wnames, "CstrList")
 
-      ##
-      # Construct a new Rwalk message, given a list of qid's
-      #
-      # +qids+:: [Array of Qid] array of Qid's in Rwalk
-      #
-      def initialize(qids)
-        @qids = qids
-        @mtype = RWALK
-        nwqid = @qids.length
-        @length = 9             # updated by qids that follow
-        @messagebody = [nwqid].pack("v")
-        @body = ""
-        i = 1
-
-        # add each qid into the messagebody
-        qids.each do |qid|
-          qidbytes = qid.to_bytes
-          @messagebody << qidbytes
-          @length += Qid::QID_LENGTH
-          @body << qid.to_s
-          if i < nwqid
-            @body << ", "
-          end
-          i += 1
-        end
-        @body << sprintf("%s, %s", @qids.length, @body)
+      def path=(str)
+        @fieldvals[:wnames] = str.split(File::SEPARATOR)
       end
 
-      ##
-      # Decode an Rwalk message.
-      #
-      # +message+:: [String] the message to decode
-      # return:: [Rwalk] the Rwalk object
-      #
-      def Rwalk.decode(message)
-        nwqid = message[7..8].unpack("v")[0]
-        if nwqid.nil?
-          raise RStyx::StyxException.new("invalid Rwalk message")
-        end
-        offset = 9
-        qids = []
-        1.upto(nwqid) do |i|
-          qids << Qid.decode(message[offset..(offset + Qid::QID_LENGTH-1)])
-          offset += Qid::QID_LENGTH
-        end
-        return(Rwalk.new(qids))
+      def path
+        return(@fieldvals[:wnames].join(File::SEPARATOR))
       end
+    end
 
+    ##
+    # Class representing an Rwalk message sent by a Styx server.
+    #
+    class Rwalk < StyxMessage
+      StyxMessage::MESSAGE_IDS[Rwalk] = 111
+      add_field(:qids, "QidList")
     end
 
     ##
-    # Message sent to prepare an existing file for reading or writing.
+    # Class representing a Topen message sent by a Styx client.
     #
     class Topen < StyxMessage
-      attr_accessor :fid, :mode
-
-      # File access modes in Styx
-      OREAD = 0
-      OWRITE = 1
-      ORDWR = 2
-      OEXEC = 3
-      OTRUNC = 0x10
-      ORCLOSE = 0x40
-
-      ##
-      # Construct a new Topen message, given the fid and the mode
-      #
-      # +fid+:: [Fixnum] the fid to open
-      # +mode+:: [Fixnum] the mode
-      #
-      def initialize(fid, mode)
-        @length = 12
-        @mtype = TOPEN
-        @fid = fid
-        @mode = mode
-        # test the modes
-        if (@mode & 0xf > 3)
-          raise RStyx::StyxException.new("invalid file mode #{sprintf("%02x", @mode)}")
-        end
-
-        if (@mode & ~0x5f != 0)
-          raise RStyx::StyxException.new("invalid file mode #{sprintf("%02x", @mode)}")
-        end
-
-        if ((@mode & OTRUNC) != 0) && !((@mode & 0xf == OWRITE) ||
-                                        (@mode & 0xf == ORDWR))
-          raise RStyx::StyxException.new("Can only truncate file when opening in write mode")
-        end
-
-        @messagebody = [@fid, @mode].pack("VC")
-        @body = sprintf("%s, %s", @fid, @mode)
-      end
-
-      ##
-      # Decode a Topen message.
-      #
-      # +message+:: [String] the message to decode
-      # return:: [Topen] the Topen object
-      #
-      def Topen.decode(message)
-        fid, mode = message[7..11].unpack("VC")
-        if fid.nil? || mode.nil?
-          raise RStyx::StyxException.new("invalid Topen message")
-        end
-        return(Topen.new(fid, mode))
-      end
-
+      StyxMessage::MESSAGE_IDS[Topen] = 112
+      add_field(:fid, "V")
+      add_field(:mode, "C")
     end
 
     ##
-    # Server reply to Topen message
+    # Class representing an Ropen message sent by a Styx server.
     #
     class Ropen < StyxMessage
-      attr_accessor :qid, :iounit
-
-      ##
-      # Construct a new Ropen message
-      #
-      # +qid+:: [Qid] Qid for the opened file
-      # +iounit+:: [Fixnum] the maximum number of bytes guaranteed to be
-      #            read or written to the file without breaking the
-      #            I/O transfer into multiple messages (0=no limit).
-      #
-      def initialize(qid, iounit=0)
-        @length = 24
-        @mtype = ROPEN
-        @qid = qid
-        @iounit = iounit
-        @messagebody = @qid.to_bytes + [@iounit].pack("V")
-        @body = @qid.to_s + ", " + sprintf("%s", @iounit)
-      end
-
-      ##
-      # Decode an Ropen message.
-      #
-      # +message+:: [String] the message to decode
-      # return:: [Ropen] the Ropen object
-      #
-      def Ropen.decode(message)
-        qid = Qid.decode(message[7..19])
-        iounit = message[20..23].unpack("V")[0]
-        if iounit.nil?
-          raise RStyx::StyxException.new("invalid Ropen message")
-        end
-        return(Ropen.new(qid, iounit))
-      end
-
+      StyxMessage::MESSAGE_IDS[Ropen] = 113
+      add_field(:qid, "Qid")
+      add_field(:iounit, "V")
     end
 
     ##
-    # Message sent to create a new file on the server.
+    # Class representing a Tcreate message sent by a Styx client.
     #
-    class Tcreate < Topen
-      attr_accessor :name, :perm
-
-      DMDIR = 0x80000000        # logical-OR with perm to make directory
-      DMAPPEND = 0x40000000     # logical-OR with perm to make appendonly
-      DMEXCL = 0x20000000       # logical-OR with perm to make exclusive use
-
-      ##
-      # Construct a new Tcreate message, given the fid, name, permissions,
-      # and mode
-      #
-      # +fid+:: [Fixnum] the fid to open
-      # +name+:: [String] the name of the file to create
-      # +permissions+:: [Fixnum] the permissions for the new file
-      # +mode+:: [Fixnum] the mode (see Topen)
-      #
-      def initialize(fid, name, mode, perm=nil)
-        super(fid, mode)
-        @mtype = TCREATE
-        @name = name
-        @length = 18 + @name.length
-        # use 0644 as default permissions if no permissions mask specified
-        @perm = (perm.nil?) ? 0644 : perm
-        @messagebody = [@fid].pack("V") + Util.strpack(@name) +
-          [@perm, @mode].pack("VC")
-        @body = sprintf("%s, %s, %s, %s", @fid, @name, @perm, @mode)
-      end
-
-      ##
-      # Decode a Tcreate message.
-      #
-      # +message+:: [String] the message to decode
-      # return:: [Tcreate] the Tcreate object
-      #
-      def Tcreate.decode(message)
-        fid = message[7..10].unpack("V")[0]
-        if (fid.nil?)
-          raise RStyx::StyxException.new("invalid Tcreate message")
-        end
-        name, offset = Util.strextract(message, 11)
-        perm, mode = message[offset..(offset+5)].unpack("VC")
-        if (perm.nil? || mode.nil?)
-          raise RStyx::StyxException.new("invalid Tcreate message")
-        end
-        return(Tcreate.new(fid, name, mode, perm))
-      end
-
+    class Tcreate < StyxMessage
+      StyxMessage::MESSAGE_IDS[Tcreate] = 114
+      add_field(:fid, "V")
+      add_field(:name, "Cstr")
+      add_field(:perm, "V")
+      add_field(:mode, "C")
     end
 
     ##
-    # Server reply to Tcreate message.  Except for the message tag, it
-    # is identical to the Ropen message, and is decoded the same way.
+    # Class representing an Rcreate message sent by a Styx server.
     #
-    class Rcreate < Ropen
-      ##
-      # Construct a new Rcreate message
-      #
-      # +qid+:: [Qid] Qid for the opened file
-      # +iounit+:: [Fixnum] the maximum number of bytes guaranteed to be
-      #            read or written to the file without breaking the
-      #            I/O transfer into multiple messages (0=no limit).
-      #
-      def initialize(qid, iounit=0)
-        super(qid, iounit)
-        @mtype = RCREATE
-      end
-
-      ##
-      # Decode an Rcreate message.
-      #
-      # +message+:: [String] the message to decode
-      # return:: [Ropen] the Rcreate object
-      #
-      # FIXME: this is identical to Ropen.decode with the only difference
-      #        being the Rcreate.new call at return.  How do you obtain
-      #        the defining class for a static method?
-      #
-      def Rcreate.decode(message)
-        qid = Qid.decode(message[7..19])
-        iounit = message[20..23].unpack("V")[0]
-        if iounit.nil?
-          raise RStyx::StyxException.new("invalid Ropen message")
-        end
-        return(Rcreate.new(qid, iounit))
-      end
-
+    class Rcreate < StyxMessage
+      StyxMessage::MESSAGE_IDS[Rcreate] = 115
+      add_field(:qid, "Qid")
+      add_field(:iounit, "V")
     end
 
     ##
-    # Message sent to read data from a file given fid, offset, and length
-    # of data to be read.
+    # Class representing a Tread message sent by a Styx client.
     #
     class Tread < StyxMessage
-      attr_accessor :fid, :offset, :count
-
-      ##
-      # Construct a new Tread message.
-      #
-      # +fid+:: [Fixnum] fid of file to read from
-      # +offset+:: [Fixnum] offset to read from
-      # +count+:: [Fixnum] number of bytes to read
-      #
-      def initialize(fid, offset, count)
-        @length = 23
-        @mtype = TREAD
-        @fid = fid
-        @offset = offset
-        offsetlo = @offset & 0xffffffff
-        offsethi = (@offset >> 32) & 0xffffffff
-        @count = count
-        @messagebody = [@fid, offsetlo, offsethi, @count].pack("VVVV")
-        @body = sprintf("%s, %s, %s", @fid, @offset, @count)
-      end
-
-      ##
-      # Decode a Tread message.
-      #
-      # +message+:: [String] the message to decode
-      # return:: [Tread] the Tread object
-      #
-      def Tread.decode(message)
-        fid, offsetlo, offsethi, count = message[7..22].unpack("VVVV")
-        if fid.nil? || offsetlo.nil? || offsethi.nil? || count.nil?
-          raise StyxException.new("invalid Tread message")
-        end
-        offset = offsetlo | (offsethi << 32)
-        return(Tread.new(fid, offset, count))
-      end
-
+      StyxMessage::MESSAGE_IDS[Tread] = 116
+      add_field(:fid, "V")
+      add_field(:offset, "ULongLong")
+      add_field(:count, "V")
     end
 
     ##
-    # Server response to Tread message giving the data from the read.
+    # Class representing an Rread message sent by a Styx server.
     #
     class Rread < StyxMessage
-      attr_accessor :count, :data
+      StyxMessage::MESSAGE_IDS[Rread] = 117
+      add_field(:data, "Bstr")
 
-      ##
-      # Construct a new Rread message.
-      #
-      # +data+:: [String] the data read from the file
-      #
-      def initialize(data)
-        @count = data.length
-        @data = data
-        @length = 11 + @count
-        @mtype = RREAD
-        @messagebody = [data.length].pack("V") + data
-        # put only the first twenty bytes in the description
-        @body = sprintf("%s, %s", @count, @data[0..19])
-      end
-
-      ##
-      # Decode an Rread message.
-      #
-      # +message+:: [String] the message to decode
-      # return:: [Rread] the Rread object
-      #
-      def Rread.decode(message)
-        count = message[7..10].unpack("V")[0]
-        if (count.nil?)
-          raise StyxException.new("invalid Rread message")
-        end
-        data = message.slice(11, count)
-        if (data.length != count)
-          raise StyxException.new("invalid Rread message, count and data length do not coincide")
-        end
-        return(Rread.new(data))
+      def count
+        return(@fieldvals[:data].length)
       end
-
     end
 
     ##
-    # Message sent to write data to a file given fid, offset, and
-    # the data to be written.
+    # Class representing a Twrite message sent by a Styx client.
     #
     class Twrite < StyxMessage
-      attr_accessor :fid, :offset, :data, :count
-
-      ##
-      # Construct a new Twrite message.
-      #
-      # +fid+:: [Fixnum] fid of file to read from
-      # +offset+:: [Fixnum] offset to read from
-      # +data+:: [String] data to be written
-      #
-      def initialize(fid, offset, data)
-        @count = data.length
-        @data = data
-        @length = @count + 23
-        @mtype = TWRITE
-        @fid = fid
-        @offset = offset
-        offsetlo = @offset & 0xffffffff
-        offsethi = (@offset >> 32) & 0xffffffff
-        @messagebody = [@fid, offsetlo, offsethi, @count].pack("VVVV") +
-          @data
-        @body = sprintf("%s, %s, %s, %s", @fid, @offset, @count, @data[0..19])
-      end
-
-      ##
-      # Decode a Twrite message.
-      #
-      # +message+:: [String] the message to decode
-      # return:: [Rwrite] the Twrite object
-      #
-      def Twrite.decode(message)
-        fid, offsetlo, offsethi, count = message[7..22].unpack("VVVV")
-        if (fid.nil? || offsetlo.nil? || offsethi.nil? || count.nil?)
-          raise StyxException.new("invalid Twrite message")
-        end
-        offset = offsetlo | (offsethi << 32)
-        data = message.slice(23, count)
-        if (data.length != count)
-          raise StyxException.new("invalid Twrite message, count and data length do not coincide")
-        end
-        return(Twrite.new(fid, offset, data))
-      end
-
+      StyxMessage::MESSAGE_IDS[Twrite] = 118
+      add_field(:fid, "V")
+      add_field(:offset, "ULongLong")
+      add_field(:data, "Bstr")
     end
 
     ##
-    # Server response to Twrite message.
+    # Class representing an Rwrite message sent by a Styx server.
     #
     class Rwrite < StyxMessage
-      attr_accessor :count
-
-      ##
-      # Construct a new Rwrite message.
-      #
-      # +count+:: [Fixnum] the number of bytes actually written.
-      #
-      def initialize(count)
-        @count = count
-        @length = 11
-        @mtype = RWRITE
-        @messagebody = [@count].pack("V")
-        @body = sprintf("%s", @count)
-      end
-
-      ##
-      # Decode an Rwrite message.
-      #
-      # +message+:: [String] the message to decode
-      # return:: [Rwrite] the Rwrite object
-      #
-      def Rwrite.decode(message)
-        count = message[7..10].unpack("V")[0]
-        if count.nil?
-          raise StyxException.new("invalid Rwrite message")
-        end
-        return(Rwrite.new(count))
-      end
-
+      StyxMessage::MESSAGE_IDS[Rwrite] = 119
+      add_field(:count, "V")
     end
 
     ##
-    # Message sent to forget about a fid, closing a file.
+    # Class representing a Tclunk message sent by a Styx client.
     #
     class Tclunk < StyxMessage
-      attr_accessor :fid
-
-      ##
-      # Construct a new Tclunk message given the fid to clunk.
-      #
-      # +fid+:: The fid to clunk
-      #
-      def initialize(fid)
-        @length = 11
-        @mtype = TCLUNK
-        @fid = fid
-        @messagebody = [@fid].pack("V")
-        @body = sprintf("%s", fid)
-      end
-
-      ##
-      # Decode a Tclunk message.  Do not use this method directly.
-      # Use only from within StyxMessage.decode.
-      #
-      # +message+:: [String] raw message string
-      # return:: [Tclunk] Tclunk instance represented by string
-      #
-      def Tclunk.decode(message)
-        fid = message[7..10].unpack("V")[0]
-        if (fid.nil?)
-          raise RStyx::StyxException.new("invalid Tclunk message")
-        end
-        return(Tclunk.new(fid))
-      end
-
+      StyxMessage::MESSAGE_IDS[Tclunk] = 120
+      add_field(:fid, "V")
     end
 
     ##
-    # Server response to a Tclunk message
+    # Class representing an Rclunk message sent by a Styx server.
     #
     class Rclunk < StyxMessage
-      ##
-      # Make an Rclunk message
-      #
-      def initialize
-        @mtype = RCLUNK
-        @length = 7
-        @messagebody = ""
-        @body = ""
-      end
-
-      ##
-      # Decode an Rclunk message
-      #
-      # +message+:: [String] raw message string
-      # return:: [Rclunk] Rclunk instance represented by string
-      #
-      def Rclunk.decode(message)
-        # This does absolutely nothing!  An Rclunk is nothing but a
-        # bare StyxMessage.
-        return(Rclunk.new)
-      end
-
+      StyxMessage::MESSAGE_IDS[Rclunk] = 121
     end
 
     ##
-    # Message sent to delete a file, given its fid.
+    # Class representing a Tremove message sent by a Styx client.
     #
     class Tremove < StyxMessage
-      attr_accessor :fid
-
-      ##
-      # Construct a new Tremove message given the fid to clunk.
-      #
-      # +fid+:: The fid to remove
-      #
-      def initialize(fid)
-        @length = 11
-        @mtype = TREMOVE
-        @fid = fid
-        @messagebody = [@fid].pack("V")
-        @body = sprintf("%s", fid)
-      end
-
-      ##
-      # Decode a Tremove message.  Do not use this method directly.
-      # Use only from within StyxMessage.decode.
-      #
-      # +message+:: [String] raw message string
-      # return:: [Tremove] Tremove instance represented by string
-      #
-      def Tremove.decode(message)
-        fid = message[7..10].unpack("V")[0]
-        if (fid.nil?)
-          raise RStyx::StyxException.new("invalid Tremove message")
-        end
-        return(Tremove.new(fid))
-      end
-
+      StyxMessage::MESSAGE_IDS[Tremove] = 122
+      add_field(:fid, "V")
     end
 
     ##
-    # Server response to a Tremove message
+    # Class representing an Rremove message sent by a Styx server.
     #
     class Rremove < StyxMessage
-      ##
-      # Make an Rremove message
-      #
-      def initialize
-        @mtype = RREMOVE
-        @length = 7
-        @messagebody = ""
-        @body = ""
-      end
-
-      ##
-      # Decode an Rremove message
-      #
-      # +message+:: [String] raw message string
-      # return:: [Rremove] Rremove instance represented by string
-      #
-      def Rremove.decode(message)
-        # This does absolutely nothing!  An Rremove is nothing but a
-        # bare StyxMessage.
-        return(Rremove.new)
-      end
-
+      StyxMessage::MESSAGE_IDS[Rremove] = 123
     end
 
     ##
-    # Message sent to obtain information about a file given its fid.
+    # Class representing a Tstat message sent by a Styx client.
     #
     class Tstat < StyxMessage
-      attr_accessor :fid
-
-      ##
-      # Construct a new Tstat message given the fid to stat.
-      #
-      # +fid+:: The fid to stat
-      #
-      def initialize(fid)
-        @length = 11
-        @mtype = TSTAT
-        @fid = fid
-        @messagebody = [@fid].pack("V")
-        @body = sprintf("%s", fid)
-      end
-
-      ##
-      # Decode a Tstat message.  Do not use this method directly.
-      # Use only from within StyxMessage.decode.
-      #
-      # message:: [String] raw message string
-      # return:: [Tstat] Tstat instance represented by string
-      #
-      def Tstat.decode(message)
-        fid = message[7..10].unpack("V")[0]
-        if (fid.nil?)
-          raise RStyx::StyxException.new("invalid Tclunk message")
-        end
-        return(Tstat.new(fid))
-      end
-
+      StyxMessage::MESSAGE_IDS[Tstat] = 124
+      add_field(:fid, "V")
     end
 
     ##
-    # Server response to a Tstat message.
+    # Class representing an Rstat message sent by a Styx server.
     #
     class Rstat < StyxMessage
-      attr_accessor :stat
-
-      ##
-      # Make an Rstat message given a DirEntry.
-      #
-      # +stat+:: [DirEntry] the file status information
-      #
-      def initialize(stat)
-        @stat = stat
-        @mtype = RSTAT
-        @messagebody = @stat.to_bytes
-        @messagebody = [@stat.size + 2].pack("v") + @messagebody
-        @length = 7 + @messagebody.length
-        @body = sprintf("%s", @stat)
-      end
-
-      ##
-      # Decode an Rstat message.  Do not use this method directly.
-      # Use only from within StyxMessage.decode.
-      #
-      # +message+:: [String] raw message string
-      # return:: [Tclunk] Tclunk instance represented by string
-      #
-      def Rstat.decode(message)
-        len = message[0..3].unpack("V")[0]
-        stat = DirEntry.decode(message[9..len])
-        return(Rstat.new(stat))
-      end
-
+      StyxMessage::MESSAGE_IDS[Rstat] = 125
+      add_field(:stat, "Stat")
     end
 
     ##
-    # Message sent to update the status of a file given a fid and a DirEntry
+    # Class representing a Twstat message sent by a Styx client.
     #
     class Twstat < StyxMessage
-      attr_accessor :fid, :stat
-
-      ##
-      # Make a Twstat message given a fid and a DirEntry.
-      #
-      # +fid+:: [Fixnum] the fid of the file to change
-      # +stat+:: [DirEntry] the new file status information
-      #
-      def initialize(fid, stat)
-        @fid = fid
-        @stat = stat
-        @mtype = TWSTAT
-        @messagebody = @stat.to_bytes
-        @messagebody = [@fid].pack("V") +
-          [@stat.size + 2].pack("v") + @messagebody
-        @length = 7 + @messagebody.length
-        @body = sprintf("%s, %s", @fid, @stat)
-      end
-
-      ##
-      # Decode a Twstat message.  Do not use this method directly.
-      # Use only from within StyxMessage.decode.
-      #
-      # +message+:: [String] raw message string
-      # return:: [Twstat] Twstat instance represented by string
-      #
-      def Twstat.decode(message)
-        len = message[0..3].unpack("V")[0]
-        fid = message[7..10].unpack("V")[0]
-        stat = DirEntry.decode(message[13..len])
-        return(Twstat.new(fid, stat))
-      end
-
+      StyxMessage::MESSAGE_IDS[Twstat] = 126
+      add_field(:fid, "V")
+     add_field(:stat, "Stat")
     end
 
     ##
-    # Server response to a Twstat message
+    # Class representing an Rwstat message sent by a Styx server.
     #
     class Rwstat < StyxMessage
-      ##
-      # Make an Rwstat message
-      #
-      def initialize
-        @mtype = RWSTAT
-        @length = 7
-        @messagebody = ""
-        @body = ""
-      end
-
-      ##
-      # Decode an Rwstat message
-      #
-      # +message+:: [String] raw message string
-      # return:: [Rwstat] Rwstat instance represented by string
-      #
-      def Rwstat.decode(message)
-        # This does absolutely nothing!  An Rwstat is nothing but a
-        # bare StyxMessage.
-        return(Rwstat.new)
-      end
-
+      StyxMessage::MESSAGE_IDS[Rwstat] = 127
     end
 
   end                           # module Message
 
 end                             # module RStyx
+
+