lib9p

main.go (4043B)

---

 package main
 
 import (
 	"bytes"
 	"context"
 	"flag"
 	"fmt"
 	"io"
 	"io/fs"
 	"log"
 	"net"
 	"os"
 	"strings"
 
 	"git.mtkn.jp/lib9p"
 )
 
 type numFS struct {
 	root *numFile
 }
 
 func (fsys *numFS) String() string {
 	if fsys.root == nil {
 		return "<empty>"
 	}
 	return fsysString(fsys.root)
 }
 
 func fsysString(f *numFile) string {
 	s := fmt.Sprintf("%d\n", f.id)
 	for _, c := range f.children {
 		cs := fsysString(c)
 		ln := strings.Split(cs, "\n")
 		for _, l := range ln {
 			s += "\t" + l + "\n"
 		}
 	}
 	return s
 }
 
 func (fsys *numFS) OpenFile(name string, _ int) (lib9p.File, error) {
 	if name == "." || name == "" {
 		return fsys.root, nil
 	}
 	wname := strings.Split(name, "/")
 	cwd := fsys.root
 L:
 	for _, wn := range wname {
 		for _, c := range cwd.children {
 			if fmt.Sprintf("%d", c.id) == wn {
 				cwd = c
 				continue L
 			}
 		}
 		return nil, fmt.Errorf("not found")
 	}
 	return cwd, nil
 }
 
 // This function assumes that group and uid both exist and
 // the leader of group has the same name as group itself.
 func (fsys *numFS) IsGroupLeader(group, uid string) bool {
 	return group == uid
 }
 
 // This function assumes that group and uid both exists and
 // only the member of group has the same name as group itself.
 func (fsys *numFS) IsGroupMember(group, uid string) bool {
 	return group == uid
 }
 
 type numFile struct {
 	fs       *numFS
 	id       int
 	reader   *bytes.Reader
 	children []*numFile
 }
 
 func (f *numFile) Fsys() lib9p.FS { return f.fs }
 
 func (f *numFile) Stat() (*lib9p.FileInfo, error) {
 	var stat lib9p.Stat
 	stat.Type = 0
 	stat.Dev = 0
 	if f.id == -1 {
 		stat.Qid = lib9p.Qid{
 			Type: lib9p.QTDIR,
 			Vers: 0,
 			Path: ^uint64(0),
 		}
 	} else {
 		stat.Qid = lib9p.Qid{
 			Type: lib9p.QTFILE,
 			Vers: 0,
 			Path: uint64(f.id),
 		}
 	}
 	var mode lib9p.FileMode
 	if f.id == -1 {
 		mode |= fs.ModeDir
 	}
 	mode |= 0444
 	stat.Mode = mode
 	stat.Atime = 0
 	stat.Mtime = 0
 	var length int64
 	if f.id == -1 {
 		length = 0
 	} else {
 		length = f.reader.Size()
 	}
 	stat.Length = length
 	stat.Name = fmt.Sprintf("%d", f.id)
 	stat.Uid = "kenji"
 	stat.Gid = "kenji"
 	stat.Muid = "kenji"
 	return &lib9p.FileInfo{Stat: stat}, nil
 }
 
 func (f *numFile) Qid() lib9p.Qid {
 	var qid lib9p.Qid
 	if f.id == -1 {
 		qid = lib9p.Qid{
 			Type: lib9p.QTDIR,
 			Vers: 0,
 			Path: ^uint64(0),
 		}
 	} else {
 		qid = lib9p.Qid{
 			Type: lib9p.QTFILE,
 			Vers: 0,
 			Path: uint64(f.id),
 		}
 	}
 	return qid
 }
 
 func (f *numFile) Read(p []byte) (int, error) {
 	if f.id == -1 {
 		return 0, fmt.Errorf("is a directory")
 	}
 	return f.reader.Read(p)
 }
 
 func (f *numFile) ReadAt(p []byte, off int64) (n int, err error) {
 	if f.id == -1 {
 		return 0, fmt.Errorf("is a directory")
 	}
 	return f.reader.ReadAt(p, off)
 }
 
 func (f *numFile) ReadDir(n int) ([]fs.DirEntry, error) {
 	if f.id != -1 {
 		return nil, fmt.Errorf("not a directory")
 	}
 	de := make([]fs.DirEntry, len(f.children))
 	for i, c := range f.children {
 		s, err := c.Stat()
 		if err != nil {
 			return nil, fmt.Errorf("stat: %v", err)
 		}
 		de[i] = s
 	}
 	return de, nil
 }
 
 func (f *numFile) Close() error {
 	if f.reader != nil {
 		f.reader.Seek(0, io.SeekStart)
 	}
 	return nil
 }
 
 var dFlag = flag.Bool("D", false, "Prints chatty message to the stderr.")
 
 func main() {
 	flag.Parse()
 
 	if flag.NArg() != 0 {
 		fmt.Fprintf(os.Stderr, "usage: %s [-D]\n", os.Args[0])
 		os.Exit(1)
 	}
 
 	fsys := new(numFS)
 	fsys.root = &numFile{
 		fs:     fsys,
 		id:     -1,
 		reader: nil,
 		children: []*numFile{
 			&numFile{fsys, 0, bytes.NewReader([]byte("0\n")), nil},
 			&numFile{fsys, 1, bytes.NewReader([]byte("1\n")), nil},
 			&numFile{fsys, 2, bytes.NewReader([]byte("2\n")), nil},
 			&numFile{fsys, 3, bytes.NewReader([]byte("3\n")), nil},
 		},
 	}
 
 	listener, err := net.Listen("tcp", "127.0.0.1:5640")
 	if err != nil {
 		log.Fatalf("listen tcp: %v", err)
 	}
 	s := lib9p.NewServer(fsys)
 	if *dFlag {
 		s.Chatty()
 	}
 	for {
 		conn, err := listener.Accept()
 		if err != nil {
 			log.Printf("accept connection: %v", err)
 			continue
 		}
 		go func() {
 			defer conn.Close()
 			s.Serve(context.TODO(), conn, conn)
 		}()
 	}
 }