lib9p

server.go (30110B)

---

 package lib9p
 
 import (
 	"context"
 	"fmt"
 	"io"
 	"io/fs"
 	"log"
 	"os"
 	"path"
 	"strings"
 	"sync"
 )
 
 var (
 	ErrBotch      = fmt.Errorf("botch")
 	ErrPerm       = fmt.Errorf("permission denied")
 	ErrOperation  = fmt.Errorf("operation not supported")
 	ErrDupTag     = fmt.Errorf("duplicate tag")
 	ErrUnknownFid = fmt.Errorf("unknown fid")
 	ErrDupFid     = fmt.Errorf("duplicate fid")
 	ErrNotFound   = fmt.Errorf("not found")
 )
 
 func setError(r *request, err error) {
 	r.ofcall = &RError{
 		Ename: err,
 	}
 }
 
 // A Server is a 9P server.
 type Server struct {
 	// If true, the server prints the transcript of the 9P session
 	// to os.Stderr
 	chatty9P bool
 
 	// The file system to export via 9P.
 	fsmap map[string]FS
 
 	// Auth function is passed an auth request when a TAuth message arrives
 	// If authentication is desired, Auth should
 	// set request.Afid.file to an *AuthFile and request.ofcall.Qid, and prepare to
 	// authenticate via the Read()/Write() calls to request.Afid.file.
 	// Auth should clean up everything it creates when ctx is canceled.
 	// If this is nil, no authentication is performed.
 	Auth func(ctx context.Context, r *request)
 }
 
 // NewServer creates a Server.
 // It serves fsys with the aname "".
 func NewServer(fsys FS) *Server {
 	s := &Server{
 		fsmap: map[string]FS{"": fsys},
 	}
 	return s
 }
 
 // NewServerMap creates a Server.
 // Fsmap is the map of aname-FS pair.
 func NewServerMap(fsmap map[string]FS) *Server {
 	s := &Server{
 		fsmap: fsmap,
 	}
 	return s
 }
 
 // Chatty enables the server's log messages of 9P messages.
 func (s *Server) Chatty() { s.chatty9P = true }
 
 type conn struct {
 	s *Server
 	// Maximum length in byte of 9P messages.
 	msize uint32
 	// Mutex to change msize.
 	mSizeLock *sync.Mutex
 
 	// FidPool of the connection.
 	fPool *fidPool
 
 	// The channel from which incoming requests are delivered by the
 	// listener goroutine.
 	listenChan <-chan *request
 	// r is the io.Reader which the listener goroutine reads from.
 	// It should be accessed only by the listener goroutine.
 	r io.Reader
 
 	// The channel to which outgoing replies are sent to the responder
 	// goroutine.
 	respChan chan *request
 
 	// w is the io.Writer which the responder goroutine writes to.
 	// It should be accessed only by the responder goroutine.
 	w io.Writer
 }
 
 func (s *Server) newConn(r io.Reader, w io.Writer) *conn {
 	return &conn{
 		s:         s,
 		msize:     8 * 1024,
 		mSizeLock: new(sync.Mutex),
 		fPool:     newFidPool(),
 		r:         r,
 		w:         w,
 	}
 }
 
 // mSize reads the maximum message size of the server.
 func (c *conn) mSize() uint32 {
 	c.mSizeLock.Lock()
 	defer c.mSizeLock.Unlock()
 	return c.msize
 }
 
 // setMSize changes the server's maximum message size.
 func (c *conn) setMSize(mSize uint32) {
 	c.mSizeLock.Lock()
 	defer c.mSizeLock.Unlock()
 	c.msize = mSize
 }
 
 // runListener runs the listener goroutine.
 // Listener goroutine reads 9P messages from s.r by calling getReq
 // and sends them to c.listenChan.
 func (c *conn) runListener(ctx context.Context, rp *reqPool) {
 	rc := make(chan *request)
 	c.listenChan = rc
 	go func() {
 		defer close(rc)
 		for {
 			select {
 			case rc <- getReq(c.r, rp, c.s.chatty9P):
 			case <-ctx.Done():
 				return
 			}
 		}
 	}()
 }
 
 // runResponder runs the responder goroutine.
 // Responder goroutine wait for reply Requests from c.respChan,
 // and marshalls each of them into 9P messages and writes it to c.w.
 func (c *conn) runResponder(ctx context.Context, rp *reqPool) {
 	rc := make(chan *request)
 	c.respChan = rc
 	go func() {
 		for {
 			select {
 			case r, ok := <-rc:
 				if !ok {
 					return
 				}
 				r.ofcall.SetTag(r.tag)
 				rp.delete(r.tag)
 				_, err := c.w.Write(r.ofcall.marshal())
 				if err != nil {
 					// TODO: handle error.
 					log.Printf("respond: %v", err)
 					continue
 				}
 				if c.s.chatty9P {
 					fmt.Fprintf(os.Stderr, "--> %s\n", r.ofcall)
 				}
 			case <-ctx.Done():
 				return
 			}
 		}
 	}()
 }
 
 // GetReq reads 9P message from r, allocates request, adds it to rp,
 // and returns it.
 // Any error it encountered is embedded into the request struct.
 // This function is called only by the server's listener goroutine,
 // and does not need to lock r.
 func getReq(r io.Reader, rp *reqPool, chatty bool) *request {
 	ifcall, err := RecvMsg(r)
 	if err != nil {
 		if err == io.EOF {
 			return &request{listenErr: err}
 		}
 		return &request{listenErr: fmt.Errorf("readMsg: %v", err)}
 	}
 	req, err := rp.add(ifcall.GetTag())
 	if err != nil {
 		// duplicate tag: cons up a fake request
 		req := new(request)
 		req.ifcall = ifcall
 		req.listenErr = ErrDupTag
 		if chatty {
 			fmt.Fprintf(os.Stderr, "<-- %v\n", req.ifcall)
 		}
 		return req
 	}
 	req.tag = ifcall.GetTag()
 	req.ifcall = ifcall
 	if ifcall, ok := req.ifcall.(*TFlush); ok {
 		req.oldreq, _ = rp.lookup(ifcall.Oldtag)
 	}
 	if chatty {
 		fmt.Fprintf(os.Stderr, "<-- %v\n", req.ifcall)
 	}
 	return req
 }
 
 // sVersion processes Tversion messages.
 // It checks if the version string is "9P2000", and if the version differs from
 // that, it replies with version string "unknown".
 // It also checks the msize of the message and if it is bigger than that of the
 // server, it replies with msize being the server's mSize, otherwise it sets the
 // server's mSize to the message's one.
 func sVersion(ctx context.Context, c *conn, rc <-chan *request) {
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case r, ok := <-rc:
 			if !ok {
 				return
 			}
 			ifcall := r.ifcall.(*TVersion)
 			version := ifcall.Version
 			if strings.HasPrefix(version, "9P2000") {
 				version = "9P2000"
 			} else {
 				version = "unknown"
 			}
 			msize := ifcall.Msize
 			if msize > c.mSize() {
 				msize = c.mSize()
 			}
 			r.ofcall = &RVersion{
 				Msize:   msize,
 				Version: version,
 			}
 			c.setMSize(r.ofcall.(*RVersion).Msize)
 			select {
 			case c.respChan <- r:
 			case <-ctx.Done():
 				return
 			}
 		}
 	}
 }
 
 // sAuth serves Tauth message.
 func sAuth(ctx context.Context, c *conn, rc <-chan *request) {
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case r, ok := <-rc:
 			if !ok {
 				return
 			}
 			var (
 				err    error
 				ifcall *TAuth
 			)
 			if c.s.Auth == nil {
 				r.err = fmt.Errorf("authentication not required")
 				goto resp
 			}
 			ifcall = r.ifcall.(*TAuth)
 			if _, ok := c.s.fsmap[ifcall.Aname]; !ok {
 				r.err = fmt.Errorf("no such file system")
 				goto resp
 			}
 			if ifcall.Afid == NOFID {
 				r.err = fmt.Errorf("NOFID can't be used for afid")
 				goto resp
 			}
 			r.afid, err = c.fPool.add(ifcall.Afid)
 			if err != nil {
 				r.err = ErrDupFid
 				goto resp
 			}
 		resp:
 			if r.err != nil {
 				setError(r, r.err)
 			} else {
 				c.s.Auth(ctx, r)
 				// TODO: should move this code to c.s.Auth?
 				if rauth, ok := r.ofcall.(*RAuth); ok {
 					r.afid.qidpath = rauth.Aqid.Path
 				}
 			}
 			select {
 			case c.respChan <- r:
 			case <-ctx.Done():
 				return
 			}
 		}
 	}
 }
 
 func sAttach(ctx context.Context, c *conn, rc <-chan *request) {
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case r, ok := <-rc:
 			if !ok {
 				return
 			}
 			var (
 				fsys FS
 				fi   fs.FileInfo
 				err  error
 			)
 			ifcall := r.ifcall.(*TAttach)
 			switch {
 			case c.s.Auth == nil && ifcall.Afid == NOFID:
 			case c.s.Auth == nil && ifcall.Afid != NOFID:
 				r.err = ErrBotch
 				goto resp
 			case c.s.Auth != nil && ifcall.Afid == NOFID:
 				r.err = fmt.Errorf("authentication required")
 				goto resp
 			case c.s.Auth != nil && ifcall.Afid != NOFID:
 				afid, ok := c.fPool.lookup(ifcall.Afid)
 				if !ok {
 					r.err = ErrUnknownFid
 					goto resp
 				}
 				af, ok := afid.file.(*AuthFile)
 				if !ok {
 					r.err = fmt.Errorf("not auth file")
 					goto resp
 				}
 				if af.Uname != ifcall.Uname || af.Aname != ifcall.Aname || !af.AuthOK {
 					r.err = fmt.Errorf("not authenticated")
 					goto resp
 				}
 			}
 			r.fid, err = c.fPool.add(ifcall.Fid)
 			if err != nil {
 				r.err = ErrDupFid
 				goto resp
 			}
 			r.fid.path = "."
 			r.fid.uid = ifcall.Uname
 			fsys, ok = c.s.fsmap[ifcall.Aname]
 			if !ok {
 				r.err = fmt.Errorf("no such file system")
 				goto resp
 			}
 			r.fid.fs = fsys
 			fi, err = fs.Stat(ExportFS{c.s.fsmap[ifcall.Aname]}, ".")
 			if err != nil {
 				r.err = fmt.Errorf("stat root: %v", err)
 				goto resp
 			}
 			r.fid.qidpath = fi.Sys().(*Stat).Qid.Path
 			r.ofcall = &RAttach{
 				Qid: fi.Sys().(*Stat).Qid,
 			}
 		resp:
 			if r.err != nil {
 				if r.fid != nil {
 					c.fPool.delete(r.fid.fid)
 				}
 				setError(r, r.err)
 			}
 			select {
 			case c.respChan <- r:
 			case <-ctx.Done():
 				return
 			}
 		}
 	}
 }
 
 func sFlush(ctx context.Context, c *conn, rc <-chan *request) {
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case r, ok := <-rc:
 			if !ok {
 				return
 			}
 			if r.oldreq != nil {
 				r.oldreq.flush()
 			}
 			r.ofcall = &RFlush{}
 			select {
 			case c.respChan <- r:
 			case <-ctx.Done():
 				return
 			}
 		}
 	}
 }
 
 // TODO: implement MAXWELEM.
 func sWalk(ctx context.Context, c *conn, rc <-chan *request) {
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case r, ok := <-rc:
 			if !ok {
 				return
 			}
 			var (
 				err    error
 				oldfi  fs.FileInfo
 				newFid *fid
 				wqids  []Qid
 				cwdp   string
 			)
 			ifcall := r.ifcall.(*TWalk)
 			oldFid, ok := c.fPool.lookup(ifcall.Fid)
 			if !ok {
 				r.err = ErrUnknownFid
 				goto resp
 			}
 			if oldFid.omode != -1 {
 				r.err = fmt.Errorf("cannot clone open fid")
 				goto resp
 			}
 			oldfi, err = fs.Stat(ExportFS{oldFid.fs}, oldFid.path)
 			if err != nil {
 				r.err = fmt.Errorf("stat: %v", err)
 				goto resp
 			}
 			if len(ifcall.Wnames) > 0 && oldfi.Sys().(*Stat).Qid.Type&QTDIR == 0 {
 				r.err = fmt.Errorf("walk on non-dir")
 				goto resp
 			}
 			if ifcall.Fid == ifcall.Newfid {
 				newFid = oldFid
 			} else {
 				newFid, err = c.fPool.add(ifcall.Newfid)
 				if err != nil {
 					r.err = fmt.Errorf("alloc: %v", err)
 					goto resp
 				}
 			}
 			wqids = make([]Qid, 0, len(ifcall.Wnames))
 			cwdp = oldFid.path
 			for _, name := range ifcall.Wnames {
 				cwdp = path.Clean(path.Join(cwdp, name))
 				if cwdp == ".." {
 					cwdp = "." // parent of the root is itself.
 				}
 				stat, err := fs.Stat(ExportFS{oldFid.fs}, cwdp)
 				if err != nil {
 					break
 				}
 				wqids = append(wqids, stat.Sys().(*Stat).Qid)
 			}
 			if len(wqids) == 0 {
 				newFid.qidpath = oldFid.qidpath
 			} else {
 				newFid.qidpath = wqids[len(wqids)-1].Path
 			}
 			newFid.path = cwdp
 			newFid.uid = oldFid.uid
 			newFid.fs = oldFid.fs
 			r.ofcall = &RWalk{
 				Qids: wqids,
 			}
 		resp:
 			if r.ofcall == nil {
 				setError(r, r.err)
 				select {
 				case c.respChan <- r:
 					continue
 				case <-ctx.Done():
 					return
 				}
 			}
 			ofcall := r.ofcall.(*RWalk)
 			if r.err != nil || len(ofcall.Qids) < len(ifcall.Wnames) {
 				if ifcall.Fid != ifcall.Newfid {
 					c.fPool.delete(ifcall.Newfid)
 				}
 				if len(ofcall.Qids) == 0 {
 					if r.err == nil && len(ifcall.Wnames) != 0 {
 						setError(r, ErrNotFound)
 					}
 				}
 			}
 			select {
 			case c.respChan <- r:
 			case <-ctx.Done():
 				return
 			}
 		}
 	}
 }
 
 func sOpen(ctx context.Context, c *conn, rc <-chan *request) {
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case r, ok := <-rc:
 			if !ok {
 				return
 			}
 			var (
 				p   fs.FileMode
 				err error
 				qid Qid
 				fi  fs.FileInfo
 			)
 			ifcall := r.ifcall.(*TOpen)
 			r.fid, ok = c.fPool.lookup(ifcall.Fid)
 			if !ok {
 				r.err = ErrUnknownFid
 				goto resp
 			}
 			if r.fid.omode != -1 {
 				r.err = ErrBotch
 				goto resp
 			}
 			if afile, ok := r.fid.file.(*AuthFile); ok {
 				// c.s.Auth should set r.fid.file to a valid *AuthFile,
 				// so r.fid.file should not be nil.
 				fi, err = r.fid.file.Stat()
 				if err != nil {
 					r.err = fmt.Errorf("stat: %v", err)
 					goto resp
 				}
 				qid = afile.Qid
 			} else {
 				fi, err = fs.Stat(ExportFS{r.fid.fs}, r.fid.path)
 				if err != nil {
 					r.err = fmt.Errorf("stat: %v", err)
 					goto resp
 				}
 				qid = fi.Sys().(*Stat).Qid
 			}
 			// Write attempt to a directory is prohibitted by the protocol.
 			// In plan9 implementation, ifcall.Mode is ANDed with ^ORCLOSE,
 			// but ORCLOSE is also prohibitted by the protocol...
 			if qid.Type == QTDIR && ifcall.Mode != OREAD {
 				r.err = fmt.Errorf("is a directory")
 				goto resp
 			}
 			switch ifcall.Mode & 3 {
 			case OREAD:
 				p = AREAD
 			case OWRITE:
 				p = AWRITE
 			case ORDWR:
 				p = AREAD | AWRITE
 			case OEXEC:
 				p = AEXEC
 			}
 			if ifcall.Mode&OTRUNC != 0 {
 				p |= AWRITE
 			}
 			if qid.Type&QTDIR != 0 && p != AREAD {
 				r.err = ErrPerm
 				goto resp
 			}
 			if !hasPerm(r.fid.fs, fi, r.fid.uid, p) {
 				r.err = ErrPerm
 				goto resp
 			}
 			if ifcall.Mode&ORCLOSE != 0 {
 				parentPath := path.Dir(r.fid.path)
 				fi, err := fs.Stat(ExportFS{r.fid.fs}, parentPath)
 				if err != nil {
 					r.err = fmt.Errorf("stat parent: %v", err)
 					goto resp
 				}
 				if !hasPerm(r.fid.fs, fi, r.fid.uid, AWRITE) {
 					r.err = ErrPerm
 					goto resp
 				}
 			}
 			r.ofcall = &ROpen{
 				Qid:    qid,
 				Iounit: c.mSize() - IOHDRSZ,
 			}
 		resp:
 			if r.err != nil {
 				setError(r, r.err)
 				goto send
 			}
 			if _, ok := r.fid.file.(*AuthFile); ok {
 				r.fid.omode = ifcall.Mode
 				goto send
 			}
 			r.fid.file, err = r.fid.fs.OpenFile(r.fid.path, ModeToFlag(ifcall.Mode))
 			if err != nil {
 				setError(r, err)
 				goto send
 			}
 			fi, err = r.fid.file.Stat()
 			if err != nil {
 				r.fid.file.Close()
 				setError(r, err)
 				goto send
 			}
 			if fi.Sys().(*Stat).Qid.Path != r.fid.qidpath {
 				log.Println("open:", fi.Sys().(*Stat).Qid.Path, r.fid.qidpath)
 				r.fid.file.Close()
 				setError(r, fmt.Errorf("qid path mismatch"))
 				goto send
 			}
 			// omode should be set after successfully opening it.
 			r.fid.omode = ifcall.Mode
 		send:
 			select {
 			case c.respChan <- r:
 			case <-ctx.Done():
 				return
 			}
 		}
 	}
 }
 
 func sCreate(ctx context.Context, c *conn, rc <-chan *request) {
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case r, ok := <-rc:
 			if !ok {
 				return
 			}
 			var (
 				fi      fs.FileInfo
 				dirfi   fs.FileInfo
 				err     error
 				cfs     CreatorFS
 				cpath   string
 				perm    FileMode
 				dirperm FileMode
 			)
 			ifcall := r.ifcall.(*TCreate)
 			r.fid, ok = c.fPool.lookup(ifcall.Fid)
 			if !ok {
 				r.err = ErrUnknownFid
 				goto resp
 			}
 			if r.fid.omode != -1 {
 				r.err = ErrBotch
 				goto resp
 			}
 			dirfi, err = fs.Stat(ExportFS{r.fid.fs}, r.fid.path)
 			if err != nil {
 				r.err = fmt.Errorf("stat: %v", err)
 				goto resp
 			}
 			if !dirfi.IsDir() {
 				r.err = fmt.Errorf("create in non-dir")
 				goto resp
 			}
 			if !hasPerm(r.fid.fs, dirfi, r.fid.uid, AWRITE) {
 				r.err = ErrPerm
 				goto resp
 			}
 			cfs, ok = r.fid.fs.(CreatorFS)
 			if !ok {
 				r.err = ErrOperation
 				goto resp
 			}
 			perm = ifcall.Perm
 			dirperm = dirfi.Mode()
 			if perm&fs.ModeDir == 0 {
 				perm &= ^FileMode(0666) | (dirperm & FileMode(0666))
 			} else {
 				perm &= ^FileMode(0777) | (dirperm & FileMode(0777))
 			}
 			cpath = path.Join(r.fid.path, ifcall.Name)
 			r.fid.file, err = cfs.Create(cpath, r.fid.uid, ifcall.Mode, perm)
 			if err != nil {
 				r.err = fmt.Errorf("create: %v", err)
 				goto resp
 			}
 			r.fid.path = cpath
 			r.fid.omode = ifcall.Mode
 			fi, err = r.fid.file.Stat()
 			if err != nil {
 				r.err = fmt.Errorf("stat: %v", err)
 				goto resp
 			}
 			r.fid.qidpath = fi.Sys().(*Stat).Qid.Path
 			r.ofcall = &RCreate{
 				Qid:    fi.Sys().(*Stat).Qid,
 				Iounit: c.mSize() - IOHDRSZ,
 			}
 		resp:
 			if r.err != nil {
 				setError(r, r.err)
 			}
 			select {
 			case c.respChan <- r:
 			case <-ctx.Done():
 				return
 			}
 		}
 	}
 }
 
 // TODO: I think the file should be locked while reading.
 // or should the undeterminism left for the client side?
 func sRead(ctx context.Context, c *conn, rc <-chan *request) {
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case r, ok := <-rc:
 			if !ok {
 				return
 			}
 			var (
 				fi   fs.FileInfo
 				err  error
 				data []byte
 				done chan struct{}
 				n    int
 			)
 			ifcall := r.ifcall.(*TRead)
 			r.fid, ok = c.fPool.lookup(ifcall.Fid)
 			if !ok {
 				r.err = ErrUnknownFid
 				goto resp
 			}
 			if r.fid.omode == -1 {
 				r.err = fmt.Errorf("not open")
 				goto resp
 			}
 			if r.fid.omode != OREAD && r.fid.omode != ORDWR && r.fid.omode != OEXEC {
 				r.err = ErrPerm
 				goto resp
 			}
 			fi, err = r.fid.file.Stat()
 			if err != nil {
 				r.err = fmt.Errorf("stat: %v", err)
 				goto resp
 			}
 			if c.mSize()-IOHDRSZ < ifcall.Count {
 				ifcall.Count = c.mSize() - IOHDRSZ
 			}
 			data = make([]byte, ifcall.Count)
 			done = make(chan struct{})
 			go func() {
 				defer close(done)
 				if fi.IsDir() {
 					if ifcall.Offset != 0 && ifcall.Offset != r.fid.dirOffset {
 						err = fmt.Errorf("invalid dir offset")
 						return
 					}
 					if ifcall.Offset == 0 && r.fid.dirIndex != 0 {
 						r.fid.dirIndex = 0
 						r.fid.dirOffset = 0
 						r.fid.dirEnts = nil
 						if err = r.fid.file.Close(); err != nil {
 							return
 						}
 						r.fid.file, err = r.fid.fs.OpenFile(r.fid.path, ModeToFlag(r.fid.omode))
 						if err != nil {
 							return
 						}
 					}
 					if r.fid.dirIndex == 0 {
 						r.fid.dirEnts, err = r.fid.file.(ReadDirFile).ReadDir(-1)
 						if err != nil {
 							return
 						}
 					}
 					k := r.fid.dirIndex
 					for ; k < len(r.fid.dirEnts); k++ {
 						fi, err := r.fid.dirEnts[k].Info()
 						if err != nil {
 							log.Println(err)
 							continue
 						}
 						st := fi.Sys().(*Stat)
 						buf := st.marshal()
 						if n+len(buf) > len(data) {
 							break
 						}
 						for i := 0; i < len(buf); i++ {
 							data[n+i] = buf[i]
 						}
 						n += len(buf)
 					}
 					r.fid.dirOffset += uint64(n)
 					r.fid.dirIndex += k
 				} else {
 					if reader, ok := r.fid.file.(io.ReaderAt); ok {
 						n, err = reader.ReadAt(data, int64(ifcall.Offset))
 					} else {
 						n, err = r.fid.file.Read(data)
 					}
 					if err == io.EOF {
 						err = nil
 					}
 				}
 			}()
 			select {
 			case <-done:
 				if err != nil {
 					r.err = err
 					goto resp
 				}
 			case <-r.done:
 				continue
 			case <-ctx.Done():
 				return
 			}
 			r.ofcall = &RRead{
 				Count: uint32(n),
 				Data:  data[:n],
 			}
 		resp:
 			if r.err != nil {
 				setError(r, r.err)
 			}
 			select {
 			case c.respChan <- r:
 			case <-ctx.Done():
 				return
 			}
 		}
 	}
 }
 
 // TODO: I think the file should be locked while writing.
 func sWrite(ctx context.Context, c *conn, rc <-chan *request) {
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case r, ok := <-rc:
 			if !ok {
 				return
 			}
 			var (
 				ofcall *RWrite
 				done   chan struct{}
 				omode  OpenMode
 				err    error
 			)
 			ifcall := r.ifcall.(*TWrite)
 			r.fid, ok = c.fPool.lookup(ifcall.Fid)
 			if !ok {
 				r.err = ErrUnknownFid
 				goto resp
 			}
 			if c.mSize()-IOHDRSZ < ifcall.Count {
 				ifcall.Count = c.mSize() - IOHDRSZ
 			}
 			omode = r.fid.omode & 3
 			if omode != OWRITE && omode != ORDWR {
 				r.err = fmt.Errorf("write on fid with open mode 0x%x", r.fid.omode)
 				goto resp
 			}
 			ofcall = new(RWrite)
 			done = make(chan struct{})
 			go func() {
 				defer close(done)
 				var n int
 				switch file := r.fid.file.(type) {
 				case io.WriterAt:
 					n, err = file.WriteAt(ifcall.Data, int64(ifcall.Offset))
 					if err != nil {
 						return
 					}
 					ofcall.Count = uint32(n)
 				case io.Writer:
 					n, err = file.Write(ifcall.Data)
 					if err != nil {
 						return
 					}
 					ofcall.Count = uint32(n)
 				default:
 					err = ErrOperation
 					return
 				}
 			}()
 			select {
 			case <-done:
 				if err != nil {
 					r.err = err
 					goto resp
 				}
 			case <-r.done:
 				continue
 			case <-ctx.Done():
 				return
 			}
 			r.ofcall = ofcall
 		resp:
 			if r.err != nil {
 				setError(r, r.err)
 			}
 			select {
 			case c.respChan <- r:
 			case <-ctx.Done():
 				return
 			}
 		}
 	}
 }
 
 func sClunk(ctx context.Context, c *conn, rc <-chan *request) {
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case r, ok := <-rc:
 			if !ok {
 				return
 			}
 			ifcall := r.ifcall.(*TClunk)
 			r.fid, ok = c.fPool.lookup(ifcall.Fid)
 			if !ok {
 				r.err = ErrUnknownFid
 				goto resp
 			}
 			c.fPool.delete(ifcall.Fid)
 			if r.fid.omode != -1 {
 				if err := r.fid.file.Close(); err != nil {
 					r.err = fmt.Errorf("close: %v", err)
 					goto resp
 				}
 				if r.fid.omode&ORCLOSE != 0 {
 					rfs, ok := r.fid.fs.(RemoverFS)
 					if !ok {
 						r.err = ErrOperation
 						goto resp
 					}
 					if err := rfs.Remove(r.fid.path); err != nil {
 						r.err = err
 						goto resp
 					}
 				}
 			}
 			r.ofcall = &RClunk{}
 		resp:
 			if r.err != nil {
 				setError(r, r.err)
 			}
 			select {
 			case c.respChan <- r:
 			case <-ctx.Done():
 				return
 			}
 		}
 	}
 }
 
 // sRemove serves Tremove messages.
 // TODO: RemoverFS.Remove function takes as argument the file path to be
 // removed. But in the protocol, files are identified by Qid.Path, not by
 // path name from the root of the file system.
 // But os package also uses the file path to remove an file.
 // And the library should not care the inconsistency of Qid.Path?
 func sRemove(ctx context.Context, c *conn, rc <-chan *request) {
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case r, ok := <-rc:
 			if !ok {
 				return
 			}
 			var (
 				parentPath string
 				pfi        fs.FileInfo
 				fi         fs.FileInfo
 				err        error
 				rfs        RemoverFS
 			)
 			ifcall := r.ifcall.(*TRemove)
 			r.fid, ok = c.fPool.lookup(ifcall.Fid)
 			if !ok {
 				r.err = ErrUnknownFid
 				goto resp
 			}
 			c.fPool.delete(ifcall.Fid)
 			if r.fid.omode != -1 {
 				r.fid.file.Close()
 			}
 			parentPath = path.Dir(r.fid.path)
 			pfi, err = fs.Stat(ExportFS{r.fid.fs}, parentPath)
 			if err != nil {
 				r.err = fmt.Errorf("stat parent: %v", err)
 				goto resp
 			}
 			if !hasPerm(r.fid.fs, pfi, r.fid.uid, AWRITE) {
 				r.err = ErrPerm
 				goto resp
 			}
 			// BUG: race. Remove call below uses r.fid.path, so I need to
 			// check whether the underlying qid is the same.
 			// But other requests can move the same file and then create
 			// new one with the same name.
 			fi, err = fs.Stat(ExportFS{FS: r.fid.fs}, r.fid.path)
 			if err != nil {
 				r.err = err
 				goto resp
 			}
 			if r.fid.qidpath != fi.Sys().(*Stat).Qid.Path {
 				r.err = fmt.Errorf("qid path mismatch")
 				goto resp
 			}
 			rfs, ok = r.fid.fs.(RemoverFS)
 			if !ok {
 				r.err = ErrOperation
 				goto resp
 			}
 			// I think the argument of RemoverFS.Remove should be Qid.Path.
 			if err = rfs.Remove(r.fid.path); err != nil {
 				r.err = fmt.Errorf("remove: %v", err)
 				goto resp
 			}
 			r.ofcall = &RRemove{}
 		resp:
 			if r.err != nil {
 				setError(r, r.err)
 			}
 			select {
 			case c.respChan <- r:
 			case <-ctx.Done():
 				return
 			}
 		}
 	}
 }
 
 func sStat(ctx context.Context, c *conn, rc <-chan *request) {
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case r, ok := <-rc:
 			if !ok {
 				return
 			}
 			var (
 				fi  fs.FileInfo
 				err error
 			)
 			ifcall := r.ifcall.(*TStat)
 			r.fid, ok = c.fPool.lookup(ifcall.Fid)
 			if !ok {
 				r.err = ErrUnknownFid
 				goto resp
 			}
 			fi, err = fs.Stat(ExportFS{r.fid.fs}, r.fid.path)
 			if err != nil {
 				r.err = fmt.Errorf("stat: %v", err)
 				goto resp
 			}
 			r.ofcall = &RStat{
 				Stat: fi.Sys().(*Stat),
 			}
 		resp:
 			if r.err != nil {
 				setError(r, r.err)
 			}
 			select {
 			case c.respChan <- r:
 			case <-ctx.Done():
 				return
 			}
 		}
 	}
 }
 
 func sWStat(ctx context.Context, c *conn, rc <-chan *request) {
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case r, ok := <-rc:
 			if !ok {
 				return
 			}
 			var (
 				wsfile  WriterStatFile
 				wstat   *Stat
 				newStat *Stat
 				fi      fs.FileInfo
 				err     error
 			)
 			ifcall := r.ifcall.(*TWstat)
 			r.fid, ok = c.fPool.lookup(ifcall.Fid)
 			if !ok {
 				r.err = ErrUnknownFid
 				goto resp
 			}
 			if r.fid.omode == -1 {
 				var err error
 				r.fid.file, err = r.fid.fs.OpenFile(r.fid.path, O_RDONLY)
 				if err != nil {
 					r.err = fmt.Errorf("open: %v", err)
 					goto resp
 				}
 			}
 			wsfile, ok = r.fid.file.(WriterStatFile)
 			if !ok {
 				r.err = ErrOperation
 				goto resp
 			}
 			wstat = ifcall.Stat
 			fi, err = r.fid.file.Stat()
 			if err != nil {
 				r.err = fmt.Errorf("stat: %v", err)
 				goto resp
 			}
 			newStat = fi.Sys().(*Stat)
 			if r.fid.qidpath != newStat.Qid.Path {
 				r.err = fmt.Errorf("qid mismatch")
 				goto resp
 			}
 			if wstat.Type != ^uint16(0) && wstat.Type != newStat.Type ||
 				wstat.Dev != ^uint32(0) && wstat.Dev != newStat.Dev ||
 				wstat.Qid.Type != QidType(^uint8(0)) && wstat.Qid.Type != newStat.Qid.Type ||
 				wstat.Qid.Vers != ^uint32(0) && wstat.Qid.Vers != newStat.Qid.Vers ||
 				wstat.Qid.Path != ^uint64(0) && wstat.Qid.Path != newStat.Qid.Path ||
 				wstat.Atime != ^uint32(0) && wstat.Atime != newStat.Atime ||
 				wstat.Uid != "" && wstat.Uid != newStat.Uid ||
 				wstat.Muid != "" && wstat.Muid != newStat.Muid {
 				r.err = fmt.Errorf("operation not permitted")
 				goto resp
 			}
 			if wstat.Name != "" && newStat.Name != wstat.Name {
 				parentPath := path.Dir(r.fid.path)
 				pstat, err := fs.Stat(ExportFS{r.fid.fs}, parentPath)
 				if err != nil {
 					r.err = fmt.Errorf("stat parent: %v", err)
 					goto resp
 				}
 				if !hasPerm(r.fid.fs, pstat, r.fid.uid, AWRITE) {
 					r.err = ErrPerm
 					goto resp
 				}
 				// TODO: I think 9P protocol prohibits renaming to existent file.
 				// Wstat(9P) in p9p says:
 				// 	it is an error to change the name to that of
 				//	an existing file.
 				// but 9pfs, 9pfuse does the rename when used with `git init`.
 				/*
 					de, err := fs.ReadDir(ExportFS{FS: r.fid.fs}, parentPath)
 					if err != nil {
 						r.err = fmt.Errorf("readdir: %v", err)
 						goto resp
 					}
 					for _, e := range de {
 						fi, err := e.Info()
 						if err != nil {
 							r.err = fmt.Errorf("stat: %v", err)
 						}
 						if fi.Name() == wstat.Name {
 							r.err = fmt.Errorf("file already exists")
 							goto resp
 						}
 					}
 				*/
 				newStat.Name = wstat.Name
 			}
 			if wstat.Length != ^int64(0) && wstat.Length != newStat.Length {
 				// TODO: deal with wstat which changes directory length to 0
 				if fi.IsDir() || !hasPerm(r.fid.fs, fi, r.fid.uid, AWRITE) {
 					r.err = ErrPerm
 					goto resp
 				}
 				newStat.Length = wstat.Length
 			}
 			if wstat.Mode != FileMode(^uint32(0)) && wstat.Mode != newStat.Mode {
 				// the owner of the file or the group leader of the file'c group.
 				if r.fid.uid != newStat.Uid && !isGroupLeader(r.fid.fs, newStat.Gid, r.fid.uid) {
 					r.err = ErrPerm
 					goto resp
 				}
 				if wstat.Mode&fs.ModeDir != newStat.Mode&fs.ModeDir {
 					r.err = ErrPerm
 					goto resp
 				}
 				newStat.Mode = wstat.Mode
 			}
 			if wstat.Mtime != ^uint32(0) && wstat.Mtime != newStat.Mtime {
 				// the owner of the file or the group leader of the file'c group.
 				if r.fid.uid != newStat.Uid && !isGroupLeader(r.fid.fs, newStat.Gid, r.fid.uid) {
 					r.err = ErrPerm
 					goto resp
 				}
 				newStat.Mtime = wstat.Mtime
 			}
 			if wstat.Gid != "" && wstat.Gid != newStat.Gid {
 				// by the owner if also a member of the new group;
 				// or by the group leader of the file'c current group if
 				// also the leader of the new group.
 				if r.fid.uid == newStat.Uid && isGroupMember(r.fid.fs, wstat.Gid, r.fid.uid) ||
 					isGroupLeader(r.fid.fs, newStat.Gid, r.fid.uid) &&
 						isGroupLeader(r.fid.fs, wstat.Gid, r.fid.uid) {
 					newStat.Gid = wstat.Gid
 				} else {
 					r.err = ErrPerm
 					goto resp
 				}
 			}
 			err = wsfile.WStat(newStat)
 			if err != nil {
 				r.err = fmt.Errorf("wstat: %v", err)
 				goto resp
 			}
 			if path.Base(r.fid.path) != newStat.Name {
 				r.fid.path = path.Join(path.Dir(r.fid.path), newStat.Name)
 			}
 			r.ofcall = &RWstat{}
 		resp:
 			if r.fid.omode == -1 && r.fid.file != nil {
 				r.fid.file.Close()
 			}
 			if r.err != nil {
 				setError(r, r.err)
 			}
 			select {
 			case c.respChan <- r:
 			case <-ctx.Done():
 				return
 			}
 		}
 	}
 }
 
 // Serve serves 9P conversation.
 func (s *Server) Serve(ctx context.Context, r io.Reader, w io.Writer) {
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 	rp := newReqPool()
 	c := s.newConn(r, w)
 	c.runListener(ctx, rp)
 	c.runResponder(ctx, rp)
 	var (
 		versionChan = make(chan *request)
 		authChan    = make(chan *request)
 		attachChan  = make(chan *request)
 		flushChan   = make(chan *request)
 		walkChan    = make(chan *request)
 		openChan    = make(chan *request)
 		createChan  = make(chan *request)
 		readChan    = make(chan *request)
 		writeChan   = make(chan *request)
 		clunkChan   = make(chan *request)
 		removeChan  = make(chan *request)
 		statChan    = make(chan *request)
 		wstatChan   = make(chan *request)
 	)
 	defer func() { // TODO: unnecessary?
 		close(versionChan)
 		close(authChan)
 		close(attachChan)
 		close(flushChan)
 		close(walkChan)
 		close(openChan)
 		close(createChan)
 		close(readChan)
 		close(writeChan)
 		close(clunkChan)
 		close(removeChan)
 		close(statChan)
 		close(wstatChan)
 	}()
 	go sVersion(ctx, c, versionChan)
 	go sAuth(ctx, c, authChan)
 	go sAttach(ctx, c, attachChan)
 	go sFlush(ctx, c, flushChan)
 	go sWalk(ctx, c, walkChan)
 	go sOpen(ctx, c, openChan)
 	go sCreate(ctx, c, createChan)
 	go sRead(ctx, c, readChan)
 	go sWrite(ctx, c, writeChan)
 	go sClunk(ctx, c, clunkChan)
 	go sRemove(ctx, c, removeChan)
 	go sStat(ctx, c, statChan)
 	go sWStat(ctx, c, wstatChan)
 L:
 	for {
 		select {
 		case <-ctx.Done():
 			break L
 		case r, ok := <-c.listenChan:
 			if !ok {
 				break L
 			}
 			if r.listenErr != nil {
 				if r.listenErr == io.EOF {
 					break L
 				}
 				log.Printf("listen: %v", r.listenErr)
 				continue L
 			}
 			switch r.ifcall.(type) {
 			default:
 				setError(r, fmt.Errorf("unknown message type: %d", r.ifcall.Type()))
 				select {
 				case c.respChan <- r:
 				case <-ctx.Done():
 					return
 				}
 			case *TVersion:
 				versionChan <- r
 			case *TAuth:
 				authChan <- r
 			case *TAttach:
 				attachChan <- r
 			case *TFlush:
 				flushChan <- r
 			case *TWalk:
 				walkChan <- r
 			case *TOpen:
 				openChan <- r
 			case *TCreate:
 				createChan <- r
 			case *TRead:
 				readChan <- r
 			case *TWrite:
 				writeChan <- r
 			case *TClunk:
 				clunkChan <- r
 			case *TRemove:
 				removeChan <- r
 			case *TStat:
 				statChan <- r
 			case *TWstat:
 				wstatChan <- r
 			}
 		}
 	}
 }