Data.NineP

Module providing Binary serialization of 9P messages to and from lazy ByteStrings.

This library does not currently provide any networking support or wrappers for easy to write clients or servers, though that may come with time as we decide the best way to implement these.

9P2000 messages are sent in little endian byte order rather than network byte order (big endian)

Lightly tested against an Inferno operating system share with no authentication successfully.

Bin - a little endian encode/decode class for Binary

class Bin a where

Methods

get :: Get a

put :: a -> Put

Instances

Bin Char

Bin Word8

Bin Word16

Bin Word32

Bin Word64

Bin String

Bin Msg

Bin Tag

Bin Stat

Bin Qid

Qid - Server side data type for path tracking (http://9p.cat-v.org for details)

data Qid

A Plan 9 Qid type. See http:9p.cat-v.org for more information

Constructors

Qid

Fields

qid_typ :: Word8

qid_vers :: Word32

qid_path :: Word64

Instances

Eq Qid

Show Qid

Bin Qid

Stat - Namespace metadata (somewhat like a unix fstat)

data Stat

Provides information on a path entry at a 9P2000 server

Constructors

Stat

Fields

st_typ :: Word16

st_dev :: Word32

st_qid :: Qid

st_mode :: Word32

st_atime :: Word32

st_mtime :: Word32

st_length :: Word64

st_name :: String

st_uid :: String

st_gid :: String

st_muid :: String

Instances

Eq Stat

Show Stat

Bin Stat

Msg - envelope for 9P2000 messages

data Msg

The message envelope type for all 9P2000 messages

Constructors

Msg

Fields

msg_typ :: Tag

msg_tag :: Word16

msg_body :: VarMsg

Instances

Eq Msg

Show Msg

Bin Msg

Tag - A message payload type

data Tag

A type that enumerates all the valid (and one invalid) message types in 9P2000

Constructors

TTversion

TRversion

TTauth

TRauth

TTattach

TRattach

XXX_TTerror

TRerror

TTflush

TRflush

TTwalk

TRwalk

TTopen

TRopen

TTcreate

TRcreate

TTread

TRread

TTwrite

TRwrite

TTclunk

TRclunk

TTremove

TRremove

TTstat

TRstat

TTwstat

TRwstat

Instances

Enum Tag

Eq Tag

Ord Tag

Show Tag

Bin Tag

VarMsg - A data type encapsulating the various 9P messages

data VarMsg

A variable message type that encapsulates the valid kinds of messages in a 9P2000 payload

Constructors

Tversion

Fields

tv_msize :: Word32

tv_version :: String

Rversion

Fields

rv_msize :: Word32

rv_version :: String

Tauth

Fields

tau_afid :: Word32

tau_uname :: String

tau_aname :: String

Rauth

Fields

ra_aqid :: Qid

Rerror

Fields

re_ename :: String

Tflush

Fields

tf_oldtag :: Word16

Rflush

Tattach

Fields

tat_fid :: Word32

tat_afid :: Word32

tat_uname :: String

tat_aname :: String

Rattach

Fields

rat_qid :: Qid

Twalk

Fields

tw_fid :: Word32

tw_newfid :: Word32

tw_wnames :: [String]

Rwalk

Fields

rw_wqid :: [Qid]

Topen

Fields

to_fid :: Word32

to_mode :: Word8

Ropen

Fields

ro_qid :: Qid

ro_iounit :: Word32

Tcreate

Fields

tcr_fid :: Word32

tcr_name :: String

tcr_perm :: Word32

tcr_mode :: Word8

Rcreate

Fields

rcr_qid :: Qid

rcr_iounit :: Word32

Tread

Fields

trd_fid :: Word32

trd_offset :: Word64

trd_count :: Word32

Rread

Fields

rrd_dat :: ByteString

Twrite

Fields

twr_fid :: Word32

twr_offset :: Word64

twr_dat :: ByteString

Rwrite

Fields

rw_count :: Word32

Tclunk

Fields

tcl_fid :: Word32

Rclunk

Tremove

Fields

trm_fid :: Word32

Rremove

Tstat

Fields

ts_fid :: Word32

Rstat

Fields

rs_stat :: [Stat]

Twstat

Fields

tws_fid :: Word32

tws_stat :: [Stat]

Rwstat

Instances

Eq VarMsg

Show VarMsg

putVarMsg - function that can encode all VarMsg types to a lazy ByteString

putVarMsg :: VarMsg -> Put

For every lower level VarMsg type, encodes a full wrapper around that type for use with 9P2000 streams

getVarMsg - function to decode all VarMsg types from a lazy ByteString

getVarMsg :: Tag -> Get VarMsg

For every messages type, runs a Get parser to decode that type of payload from the 9P2000 stream

Example

Exchanging initial version data with any 9P2000 server

 module Main where

 import Data.Maybe
 import Control.Monad
 import qualified Data.ByteString.Lazy.Char8 as C
 import Network.Socket hiding (send, recv)
 import Network.Socket.ByteString.Lazy
 import Data.Int
 import Data.Binary.Get
 import Data.Binary.Put
 import Debug.Trace
 import Data.NineP
 
 connector :: IO Socket 
 connector = withSocketsDo $
             do
               ainfo <- getAddrInfo Nothing (Just "127.0.0.1") (Just "6872")
               let a = head ainfo
               sock <- socket AF_INET Stream defaultProtocol

At this point we've just created our socket to a machine on 127.0.0.1:6872 where we'd expect to see a 9P2000 server.

               putStrLn "Trying to connect"
               connect sock (addrAddress (traceShow a a))
               putStrLn "connected!"

The socket is connected at this point, build up a TVersion message, asking to speak to the server with the 9P2000 protocol.

The 1024 tells the server the maximum message size we'd like to support.

               let version = Msg TTversion (-1) $ Tversion 1024 "9P2000"
               putStrLn $ "About to send: " ++ show version

We now need to pack the message into a bytestring. This is handled by the Bin class instance Msg, and the serialization is handled by runPut. We send this data to the socket.

               send sock $ runPut (put version) 
               putStrLn "Getting response"

Now wait for a response from the server, evaluated runGet over it to de-serialize it, and show it.

               msg <- recv sock 50
               let response = runGet get msg ::Msg
               putStrLn $ show response
               return sock