func (c *ClientConn) readfile(fc *plan9.Fcall, ref *fileRef) *plan9.Fcall {
	size, err := c.explorer.Sizeof(ref.Path)
	if err != nil {
		return c.unexpectedErr(fc, err)
	}
	if size > 0 && fc.Offset >= size {
		// trying to reading past the end of file.
		// return count == 0 to signal EOF to client
		fc.Count = 0
		return fc
	}
	fc.Data = allocBuffer(min(int(c.iounit), int(fc.Count), int(size)))
	defer discardBuffer(fc.Data)
	n, err := c.explorer.Read(fc.Data, fc.Offset, ref.Path)
	if err == io.EOF {
		if n == 0 {
			// returned EOF without reading anything, should return fc.Count = 0
			discardBuffer(fc.Data)
			fc.Data = nil
			err = nil
			return fc
		} else {
			// was able to read som data from the file, should return the count
			// but not the error. The next call to read will trigger the EOF
			err = nil
		}
	}
	if err != nil {
		return c.unexpectedErr(fc, err)
	}
	fc.Count = uint32(n)
	fc.Data = fc.Data[:fc.Count]
	return fc
}

func (c *ClientConn) attach(fc *plan9.Fcall) *plan9.Fcall {
	fc.Type = plan9.Rattach
	fc.Iounit = c.iounit
	fref, _ := c.createFileRef(c.explorer.Root(), FTDIR, 0)
	fc.Qid = fref.Qid
	c.bindFid(fc.Fid, fc.Qid.Path)
	return fc
}

func (c *ClientConn) walk(fc *plan9.Fcall) *plan9.Fcall {
	fc.Type = plan9.Rwalk
	fref, has := c.fidRef(fc.Fid)
	if !has {
		return c.invalidFidErr(fc)
	}
	if _, has := c.fidRef(fc.Newfid); has {
		return c.fidUsedErr(fc)
	}
	current := fref.Path
	for idx, name := range fc.Wname {
		var ft FileType
		if current == 0 {
			return c.fileNotFoundErr(fc)
		}
		if ff, ok := c.explorer.(FileFinder); ok {
			f, err := ff.FindInDir(current, name)
			if err != nil {
				return c.unexpectedErr(fc, err)
			}
			current = f.Path
		} else {
			childs, err := c.explorer.ListDir(current)
			if err != nil {
				return c.unexpectedErr(fc, err)
			}
			idx, have := childs.FindExact(name)
			if !have {
				return c.fileNotFoundErr(fc)
			}
			current = childs[idx].Path
		}
		ref, err := c.createFileRef(current, ft, 0)
		if err != nil {
			return c.unexpectedErr(fc, err)
		}
		fc.Wqid = append(fc.Wqid, ref.Qid)

		// if the last match isn't a directory, there is no need to find
		// another part of the path
		//
		// so, just break here
		if ft == FTFILE && idx != len(fc.Wname)-1 {
			return c.fileNotFoundErr(fc)
		}
	}
	if len(fc.Wqid) == 0 {
		// newfid and fid will map to the same file
		if fc.Newfid != fc.Fid {
			c.bindFid(fc.Newfid, fref.Path)
		}
	} else {
		// make a bind between the last qid and the new fid
		c.bindFid(fc.Newfid, fc.Wqid[len(fc.Wqid)-1].Path)
	}
	return fc
}

func (c *ClientConn) write(fc *plan9.Fcall) *plan9.Fcall {
	fc.Type = plan9.Rwrite
	if fref, have := c.fidRef(fc.Fid); have {
		n, err := c.explorer.Write(fref.Path, fc.Data, fc.Offset)
		if err != nil {
			return c.unexpectedErr(fc, err)
		}
		fc.Count = uint32(n)
		return fc
	}
	return c.invalidFidErr(fc)
}

func (c *ClientConn) open(fc *plan9.Fcall) *plan9.Fcall {
	fc.Type = plan9.Ropen
	if fref, has := c.fidRef(fc.Fid); has {
		err := c.explorer.Open(fref.Path, FileMode(fc.Mode))
		if err != nil {
			return c.unexpectedErr(fc, err)
		}
		fc.Iounit = c.iounit
		fc.Qid = fref.Qid
		return fc
	}
	return c.invalidFidErr(fc)
}

func (c *ClientConn) read(fc *plan9.Fcall) *plan9.Fcall {
	fc.Type = plan9.Rread
	if fref, has := c.fidRef(fc.Fid); has {
		if fref.IsDir() {
			return c.readdir(fc, fref)
		}
		return c.readfile(fc, fref)
	}
	return c.invalidFidErr(fc)
}

func (c *ClientConn) readdir(fc *plan9.Fcall, ref *fileRef) *plan9.Fcall {
	// if the call have an offset, return 0
	// since all readdir call's will return the full directory
	if fc.Offset > 0 {
		fc.Count = 0
		return fc
	}
	childs, err := c.explorer.ListDir(ref.Path)
	if err != nil {
		return c.unexpectedErr(fc, err)
	}
	tmpBuf := allocBuffer(int(c.iounit))
	out := bytes.NewBuffer(tmpBuf[:0])
	defer discardBuffer(tmpBuf)
	for _, id := range childs {
		stat, err := c.explorer.Stat(id.Path)
		if err != nil {
			return c.unexpectedErr(fc, err)
		}
		dir := plan9.Dir{
			Qid:    plan9.Qid{Type: uint8(stat.Type), Vers: stat.Version, Path: id.Path},
			Mode:   plan9.Perm(stat.Mode),
			Atime:  stat.Atime,
			Mtime:  stat.Mtime,
			Length: stat.Size,
			Uid:    stat.Uname,
			Gid:    stat.Gname,
			Name:   stat.Name,
		}
		buf, err := dir.Bytes()
		if err != nil {
			return c.unexpectedErr(fc, err)
		}
		_, err = out.Write(buf)
		if err != nil {
			return c.unexpectedErr(fc, err)
		}
	}
	fc.Count = uint32(len(fc.Data))
	fc.Data = out.Bytes()
	return fc
}

func (c *ClientConn) clunk(fc *plan9.Fcall) *plan9.Fcall {
	fc.Type = plan9.Rclunk
	oldpath, had := c.unbindFid(fc.Fid)
	if had {
		err := c.explorer.Close(oldpath)
		if err != nil {
			return c.unexpectedErr(fc, err)
		}
	}
	return fc
}

func (c *ClientConn) create(fc *plan9.Fcall) *plan9.Fcall {
	fc.Type = plan9.Rcreate
	if fref, have := c.fidRef(fc.Fid); have {
		file := File{Name: fc.Name}
		file.Type = FileType(fc.Mode)
		path, err := c.explorer.Create(fref.Path, file, uint32(fc.Perm))
		if err != nil {
			return c.unexpectedErr(fc, err)
		}
		cref, err := c.createFileRef(path, file.Type, 0)
		if err != nil {
			return c.unexpectedErr(fc, err)
		}
		fc.Iounit = c.iounit
		fc.Qid = cref.Qid
		c.unbindFid(fc.Fid)
		c.bindFid(fc.Fid, cref.Path)
		return fc
	}
	return c.invalidFidErr(fc)
}

func (c *ClientConn) process(fc *plan9.Fcall, out chan *plan9.Fcall) {
	println(">>>\t", fc.String())
	switch fc.Type {
	case plan9.Tversion:
		fc = c.version(fc)
	case plan9.Tattach:
		fc = c.attach(fc)
	case plan9.Twalk:
		fc = c.walk(fc)
	case plan9.Topen:
		fc = c.open(fc)
	case plan9.Tread:
		fc = c.read(fc)
	case plan9.Tclunk:
		fc = c.clunk(fc)
	case plan9.Tcreate:
		fc = c.create(fc)
	case plan9.Twrite:
		fc = c.write(fc)
	case plan9.Tauth:
		fc = noauth(fc)
	default:
		println("!!!\t", fc.String())
		fc = nil
	}
	if fc != nil {
		println("<<<\t", fc.String())
	}
	out <- fc
}

func (c *ClientConn) unexpectedErr(fc *plan9.Fcall, err error) *plan9.Fcall {
	fc.Type = plan9.Rerror
	fc.Ename = err.Error()
	return fc
}

func (c *ClientConn) fidUsedErr(fc *plan9.Fcall) *plan9.Fcall {
	fc.Type = plan9.Rerror
	fc.Ename = "fid in use"
	return fc
}

func (c *ClientConn) fileNotFoundErr(fc *plan9.Fcall) *plan9.Fcall {
	fc.Type = plan9.Rerror
	fc.Ename = "file not found"
	return fc
}

func (c *ClientConn) invalidFidErr(fc *plan9.Fcall) *plan9.Fcall {
	fc.Type = plan9.Rerror
	fc.Ename = "fid not found"
	return fc
}

func (c *ClientConn) version(fc *plan9.Fcall) *plan9.Fcall {
	fc.Type = plan9.Rversion
	fc.Version = "9P2000"
	return fc
}

func noauth(fc *plan9.Fcall) *plan9.Fcall {
	fc.Type = plan9.Rerror
	fc.Ename = "no auth requried"
	return fc
}