neinp

README

neinp

about

neinp is a toolkit to implement 9p servers.

installation

go get go.rbn.im/neinp

usage

a example of how to use this can be found here: https://git.sr.ht/~rbn/rssfs

furthermore, the documentation of this package should cover most things. additional information about the 9p protocol can be found in the plan9 manual (should be available online at cat-v.org for example).

contact

email regarding this package (comments, questions, patches) can be send to [code ate rbn.im](mailto:code ate rbn.im).

Documentation

Overview

Package neinp is a toolkit to implement 9p servers.

A 9p filesystem is created by implementing the P2000 interface, which is then used as argument for NewServer. Server can then use an io.ReadWriter supplied to the Serve method handle requests using the aforementioned P2000 implementer.

See https://git.sr.ht/~rbn/rssfs for an example.

NB: This isn't really polished yet, things may break.

Index

• type NopP2000
  • func (f *NopP2000) Attach(context.Context, message.TAttach) (message.RAttach, error)
  • func (f *NopP2000) Auth(context.Context, message.TAuth) (message.RAuth, error)
  • func (f *NopP2000) Close() error
  • func (f *NopP2000) Clunk(context.Context, message.TClunk) (message.RClunk, error)
  • func (f *NopP2000) Create(context.Context, message.TCreate) (message.RCreate, error)
  • func (f *NopP2000) Open(context.Context, message.TOpen) (message.ROpen, error)
  • func (f *NopP2000) Read(context.Context, message.TRead) (message.RRead, error)
  • func (f *NopP2000) Remove(context.Context, message.TRemove) (message.RRemove, error)
  • func (f *NopP2000) Stat(context.Context, message.TStat) (message.RStat, error)
  • func (f *NopP2000) Version(context.Context, message.TVersion) (message.RVersion, error)
  • func (f *NopP2000) Walk(context.Context, message.TWalk) (message.RWalk, error)
  • func (f *NopP2000) Write(context.Context, message.TWrite) (message.RWrite, error)
  • func (f *NopP2000) Wstat(context.Context, message.TWstat) (message.RWstat, error)
• type P2000
• type Server
  • func NewServer(fs P2000) *Server
  • func (s *Server) Serve(rw io.ReadWriter) error
  • func (s *Server) Shutdown() error

Examples

• Server

Types

type NopP2000

type NopP2000 struct{}

NopP2000 is a dummy impementation of interface P2000, returning error for every call. It can be embedded into own implementations if some functions aren't required. For a working mount (with p9p 9pfuse or linux kernel module), at least Version, Attach, Stat, Walk, Open, Read, and Clunk need to be implemented.

func (*NopP2000) Attach

func (f *NopP2000) Attach(context.Context, message.TAttach) (message.RAttach, error)

func (*NopP2000) Auth

func (f *NopP2000) Auth(context.Context, message.TAuth) (message.RAuth, error)

func (*NopP2000) Close

func (f *NopP2000) Close() error

func (*NopP2000) Clunk

func (f *NopP2000) Clunk(context.Context, message.TClunk) (message.RClunk, error)

func (*NopP2000) Create

func (f *NopP2000) Create(context.Context, message.TCreate) (message.RCreate, error)

func (*NopP2000) Open

func (f *NopP2000) Open(context.Context, message.TOpen) (message.ROpen, error)

func (*NopP2000) Read

func (f *NopP2000) Read(context.Context, message.TRead) (message.RRead, error)

func (*NopP2000) Remove

func (f *NopP2000) Remove(context.Context, message.TRemove) (message.RRemove, error)

func (*NopP2000) Stat

func (f *NopP2000) Stat(context.Context, message.TStat) (message.RStat, error)

func (*NopP2000) Version

func (f *NopP2000) Version(context.Context, message.TVersion) (message.RVersion, error)

func (*NopP2000) Walk

func (f *NopP2000) Walk(context.Context, message.TWalk) (message.RWalk, error)

func (*NopP2000) Write

func (f *NopP2000) Write(context.Context, message.TWrite) (message.RWrite, error)

func (*NopP2000) Wstat

func (f *NopP2000) Wstat(context.Context, message.TWstat) (message.RWstat, error)

type P2000

type P2000 interface {
	Version(context.Context, message.TVersion) (message.RVersion, error)
	Auth(context.Context, message.TAuth) (message.RAuth, error)
	Attach(context.Context, message.TAttach) (message.RAttach, error)
	Walk(context.Context, message.TWalk) (message.RWalk, error)
	Open(context.Context, message.TOpen) (message.ROpen, error)
	Create(context.Context, message.TCreate) (message.RCreate, error)
	Read(context.Context, message.TRead) (message.RRead, error)
	Write(context.Context, message.TWrite) (message.RWrite, error)
	Clunk(context.Context, message.TClunk) (message.RClunk, error)
	Remove(context.Context, message.TRemove) (message.RRemove, error)
	Stat(context.Context, message.TStat) (message.RStat, error)
	Wstat(context.Context, message.TWstat) (message.RWstat, error)
	Close() error
}

P2000 is the interface which file systems must implement to be used with Server. To ease implementation of new filesystems, NopP2000 can be embedded. See the types defined in message for documentation of what they do.

type Server

type Server struct {
	Debug bool
	// contains filtered or unexported fields
}

Server muxes and demuxes 9p messages from a connection, calling the corresponding handlers of a P2000 interface.

Example

package main

import (
	"fmt"
	"go.rbn.im/neinp"
	"net"
)

func main() {
	fs := &neinp.NopP2000{}

	l, err := net.Listen("tcp", "localhost:9999")
	if err != nil {
		fmt.Println("listen:", err)
		return
	}

	for {
		c, err := l.Accept()
		if err != nil {
			fmt.Println("accept:", err)
			return
		}

		s := neinp.NewServer(fs)
		if err := s.Serve(c); err != nil {
			fmt.Println("serve:", err)
			return
		}
	}
}

func NewServer

func NewServer(fs P2000) *Server

NewServer returns a Server initialized to use fs for message handling.

func (*Server) Serve

func (s *Server) Serve(rw io.ReadWriter) error

Serve the filesystem on the connection given by rw.

func (*Server) Shutdown

func (s *Server) Shutdown() error

Shutdown serving the filesystem.