rstyx 0.1.0

data/lib/rstyx/messages.rb

@@ -0,0 +1,1429 @@
+#!/usr/bin/ruby
+#
+# Copyright (C) 2005 Rafael Sevilla
+# This file is part of RStyx
+#
+# RStyx is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1
+# of the License, or (at your option) any later version.
+#
+# RStyx is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# 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.
+#
+# Styx Message classes and utility functions
+#
+# Author:: Rafael R. Sevilla (mailto:dido@imperium.ph)
+# Copyright:: Copyright (c) 2005 Rafael R. Sevilla
+# License:: GNU Lesser General Public License
+#
+# $Id: messages.rb,v 1.24 2005/09/30 05:35:42 dido Exp $
+#
+
+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.
+    #
+    class Qid
+      attr_accessor :qtype, :version, :path
+
+      QID_LENGTH = 13           # size of a Qid
+
+      ##
+      # Create a new Qid object.
+      #
+      # +type+:: [Fixnum] the type of file (directory, append only file, etc.)
+      # +version+:: [Fixnum] the version number of the file
+      # +path+:: [Fixnum] a 64-bit integer that should be unique among all
+      #          files being served
+      #
+      def initialize(type, version, path)
+        @qtype = type
+        @version = version
+        @path = path
+      end
+
+      ##
+      # Get the byte string representation of the Qid
+      #
+      # return value:: [String] the byte string representation of the Qid
+      #
+      def to_bytes
+        pathlo = @path & 0xffffffff
+        pathhi = (@path >> 32) & 0xffffffff
+        return([@qtype, @version, pathlo, pathhi].pack("CVVV"))
+      end
+
+      ##
+      # Decode a serialized Qid from its byte string representation
+      #
+      # +msgbytes+:: [String] the byte string representation of the qid
+      # 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)
+        qtype, version, pathlo, pathhi = msgbytes.unpack("CVVV")
+        if qtype.nil? || version.nil? || pathlo.nil? || pathhi.nil?
+          raise StyxException.new("QID failed decode")
+        end
+        # recombine in little-endian mode
+        path = pathlo | (pathhi << 32)
+        return(Qid.new(qtype, version, path))
+      end
+
+      ##
+      # Dump a Qid
+      #
+      # return value:: [String] a textual representation of the Qid
+      #
+      def to_s
+        return(sprintf("qid(%s, %s, %s)", @qtype, @version, @path))
+      end
+    end
+
+    ##
+    # Class representing an entry in a directory (e.g. the result of a
+    # stat message)
+    #
+    class DirEntry
+      attr_accessor :size, :dtype, :dev, :qid, :mode, :atime, :mtime
+      attr_accessor :length, :name, :uid, :gid, :muid
+
+      ##
+      # Serialize a DirEntry.  This also calculates the size of the
+      # DirEntry in bytes.
+      #
+      # return value:: [String] the serialized version of the DirEntry
+      #
+      def to_bytes
+        str = [@dtype, @dev].pack("vV")
+        str << @qid.to_bytes
+        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)
+        @size = str.length
+        return([size].pack("v") + str)
+      end
+
+      ##
+      # Unserialize a DirEntry
+      #
+      # +bytes+:: [String] serialized string representation of a DirEntry
+      # return value:: [DirEntry] the DirEntry corresponding to the
+      #                passed string
+      # raises:: StyxException if +bytes+ cannot be properly decoded as
+      #          a DirEntry
+      #
+      def DirEntry.decode(bytes)
+        # From Inferno stat(5)
+        #
+        # 0-1 = size
+        # 2-3 = type
+        # 4-7 = dev
+        # 8 = Qid.type
+        # 9-12 = Qid.vers
+        # 13-20 = Qid.path
+        # 21-24 = mode
+        # 25-28 = atime
+        # 29-32 = mtime
+        # 33-40 = length
+        # 41-42 = name length
+        # 43 to 42 + namelen = name
+        # 43 + namelen to 44 + namelen = uid length
+        # 45 + namelen to 44 + namelen + uidlen = uid
+        # 45 + namelen + uidlen
+        de = DirEntry.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")
+        end
+        de.qid = Qid.decode(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")
+        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)
+        return(de)
+      end
+
+      ##
+      # convert a DirEntry to a human-readable string
+      #
+      # return value:: a string representation of the DirEntry
+      #
+      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)
+        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.
+    #
+    class StyxMessage
+      attr_accessor :length, :mtype, :tag, :messagebody, :body
+
+      ##
+      # Convert the message to a string of bytes for transmission.
+      #
+      # +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
+      #
+      def to_bytes(tag=nil)
+        unless tag.nil?
+          @tag = tag
+        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.
+      #
+      # 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))
+      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)
+      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
+      #
+      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)
+      end
+
+      ##
+      # Decode a Tversion message.  Do not call this method directly.
+      #
+      # +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))
+      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)
+      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.
+      #
+      def Rversion.decode(message)
+        msize = message[7..10].unpack("V")[0]
+        if msize.nil?
+          raise StyxException.new("Invalid Rversion message")
+        end
+        version, offset = Util.strextract(message, 11)
+        return(Rversion.new(msize, version))
+      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.
+      #
+      # +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)
+      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")
+        end
+        uname, offset = Util.strextract(message, 11)
+        aname, offset = Util.strextract(message, offset)
+        return(Tauth.new(uname, afid, aname))
+      end
+
+    end
+
+    ##
+    # Server response to Rauth message, giving qid of authenticator qid.
+    #
+    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
+    end
+
+    ##
+    # Message returned to indicate an error condition
+    #
+    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
+
+    end
+
+    ##
+    # Message sent to abort a previous message.
+    #
+    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
+
+    end
+
+    ##
+    # Server response to a Tflush message
+    #
+    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
+    end
+
+    ##
+    # Message sent to attach to the server as a certain user
+    #
+    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
+
+    end
+
+    ##
+    # Server response to Tattach message, giving qid of root
+    #
+    class Rattach < StyxMessage
+      attr_accessor :qid
+
+      ##
+      # 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
+      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
+    end
+
+    ##
+    # Message sent to get a handle to a file on the server
+    #
+    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
+
+      ##
+      # 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
+    end
+
+    ##
+    # Server reply to Twalk message
+    #
+    class Rwalk < StyxMessage
+      attr_accessor :qids
+
+      ##
+      # 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)
+      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))
+      end
+
+    end
+
+    ##
+    # Message sent to prepare an existing file for reading or writing.
+    #
+    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
+
+    end
+
+    ##
+    # Server reply to Topen message
+    #
+    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
+
+    end
+
+    ##
+    # Message sent to create a new file on the server.
+    #
+    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
+
+    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 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
+
+    end
+
+    ##
+    # Message sent to read data from a file given fid, offset, and length
+    # of data to be read.
+    #
+    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
+
+    end
+
+    ##
+    # Server response to Tread message giving the data from the read.
+    #
+    class Rread < StyxMessage
+      attr_accessor :count, :data
+
+      ##
+      # 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))
+      end
+
+    end
+
+    ##
+    # Message sent to write data to a file given fid, offset, and
+    # the data to be written.
+    #
+    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
+
+    end
+
+    ##
+    # Server response to Twrite message.
+    #
+    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
+
+    end
+
+    ##
+    # Message sent to forget about a fid, closing a file.
+    #
+    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
+
+    end
+
+    ##
+    # Server response to a Tclunk message
+    #
+    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
+
+    end
+
+    ##
+    # Message sent to delete a file, given its fid.
+    #
+    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
+
+    end
+
+    ##
+    # Server response to a Tremove message
+    #
+    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
+
+    end
+
+    ##
+    # Message sent to obtain information about a file given its fid.
+    #
+    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
+
+    end
+
+    ##
+    # Server response to a Tstat message.
+    #
+    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
+        @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[7..len])
+        return(Rstat.new(stat))
+      end
+
+    end
+
+    ##
+    # Message sent to update the status of a file given a fid and a DirEntry
+    #
+    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 = [@fid].pack("V") + @stat.to_bytes
+        @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[11..len])
+        return(Twstat.new(fid, stat))
+      end
+
+    end
+
+    ##
+    # Server response to a Twstat message
+    #
+    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
+
+    end
+
+  end                           # module Message
+
+end                             # module RStyx