Memfile stuff

attrs.go

@@ -32,7 +32,7 @@ func (fi *fileInfo) Name() string { return fi.name }
 func (fi *fileInfo) Size() int64 { return int64(fi.stat.Size) }
 
 // Mode returns file mode bits.
-func (fi *fileInfo) Mode() os.FileMode { return toFileMode(fi.stat.Mode) }
+func (fi *fileInfo) Mode() os.FileMode { return ToFileMode(fi.stat.Mode) }
 
 // ModTime returns the last modification time of the file.
 func (fi *fileInfo) ModTime() time.Time { return time.Unix(int64(fi.stat.Mtime), 0) }
@@ -92,7 +92,7 @@ func fileStatFromInfo(fi os.FileInfo) (uint32, *FileStat) {
 
 	fileStat := &FileStat{
 		Size:  uint64(fi.Size()),
-		Mode:  fromFileMode(fi.Mode()),
+		Mode:  FromFileMode(fi.Mode()),
 		Mtime: uint32(mtime),
 		Atime: uint32(atime),
 	}

client.go

@@ -275,7 +275,7 @@ func (c *Client) nextID() uint32 {
 func (c *Client) recvVersion() error {
 	typ, data, err := c.recvPacket(0)
 	if err != nil {
-		if err == io.EOF {
+		if errors.Is(err, io.EOF) {
 			return fmt.Errorf("server unexpectedly closed connection: %w", io.ErrUnexpectedEOF)
 		}
 
@@ -368,7 +368,7 @@ func (c *Client) ReadDir(p string) ([]os.FileInfo, error) {
 			return nil, unimplementedPacketErr(typ)
 		}
 	}
-	if err == io.EOF {
+	if errors.Is(err, io.EOF) {
 		err = nil
 	}
 	return attrs, err
@@ -1238,7 +1238,7 @@ func (f *File) writeToSequential(w io.Writer) (written int64, err error) {
 		}
 
 		if err != nil {
-			if err == io.EOF {
+			if errors.Is(err, io.EOF) {
 				return written, nil // return nil explicitly.
 			}
 
@@ -1435,7 +1435,7 @@ func (f *File) WriteTo(w io.Writer) (written int64, err error) {
 		}
 
 		if packet.err != nil {
-			if packet.err == io.EOF {
+			if errors.Is(packet.err, io.EOF) {
 				return written, nil
 			}
 
@@ -1726,7 +1726,7 @@ func (f *File) ReadFromWithConcurrency(r io.Reader, concurrency int) (read int64
 			}
 
 			if err != nil {
-				if err != io.EOF {
+				if !errors.Is(err, io.EOF) {
 					errCh <- rwErr{off, err}
 				}
 				return
@@ -1878,7 +1878,7 @@ func (f *File) ReadFrom(r io.Reader) (int64, error) {
 		}
 
 		if err != nil {
-			if err == io.EOF {
+			if errors.Is(err, io.EOF) {
 				return read, nil // return nil explicitly.
 			}
 
@@ -2009,7 +2009,7 @@ func flags(f int) uint32 {
 
 // toChmodPerm converts Go permission bits to POSIX permission bits.
 //
-// This differs from fromFileMode in that we preserve the POSIX versions of
+// This differs from FromFileMode in that we preserve the POSIX versions of
 // setuid, setgid and sticky in m, because we've historically supported those
 // bits, and we mask off any non-permission bits.
 func toChmodPerm(m os.FileMode) (perm uint32) {

client_integration_test.go

@@ -1240,7 +1240,7 @@ func TestClientReadSimple(t *testing.T) {
 	defer f2.Close()
 	stuff := make([]byte, 32)
 	n, err := f2.Read(stuff)
-	if err != nil && err != io.EOF {
+	if err != nil && !errors.Is(err, io.EOF) {
 		t.Fatalf("err: %v", err)
 	}
 	if n != 5 {
@@ -2152,7 +2152,7 @@ func TestMatch(t *testing.T) {
 		pattern := tt.pattern
 		s := tt.s
 		ok, err := Match(pattern, s)
-		if ok != tt.match || err != tt.err {
+		if ok != tt.match || !errors.Is(err, tt.err) {
 			t.Errorf("Match(%#q, %#q) = %v, %q want %v, %q", pattern, s, ok, errp(err), tt.match, errp(tt.err))
 		}
 	}
@@ -2411,7 +2411,7 @@ func benchmarkRead(b *testing.B, bufsize int, delay time.Duration) {
 		for offset < size {
 			n, err := io.ReadFull(f2, buf)
 			offset += n
-			if err == io.ErrUnexpectedEOF && offset != size {
+			if errors.Is(err, io.ErrUnexpectedEOF) && offset != size {
 				b.Fatalf("read too few bytes! want: %d, got: %d", size, n)
 			}
 

examples/go-sftp-server/main.go

@@ -4,6 +4,7 @@
 package main
 
 import (
+	"errors"
 	"flag"
 	"fmt"
 	"io"
@@ -136,7 +137,7 @@ func main() {
 		if err != nil {
 			log.Fatal(err)
 		}
-		if err := server.Serve(); err == io.EOF {
+		if err := server.Serve(); errors.Is(err, io.EOF) {
 			server.Close()
 			log.Print("sftp client exited session.")
 		} else if err != nil {

examples/request-server/main.go

@@ -4,6 +4,7 @@
 package main
 
 import (
+	"errors"
 	"flag"
 	"fmt"
 	"io"
@@ -120,7 +121,7 @@ func main() {
 
 		root := sftp.InMemHandler()
 		server := sftp.NewRequestServer(channel, root)
-		if err := server.Serve(); err == io.EOF {
+		if err := server.Serve(); errors.Is(err, io.EOF) {
 			server.Close()
 			log.Print("sftp client exited session.")
 		} else if err != nil {

ls_formatting.go

@@ -47,7 +47,7 @@ func runLs(idLookup NameLookupFileLister, dirent os.FileInfo) string {
 	// format:
 	// {directory / char device / etc}{rwxrwxrwx}  {number of links} owner group size month day [time (this year) | year (otherwise)] name
 
-	symPerms := sshfx.FileMode(fromFileMode(dirent.Mode())).String()
+	symPerms := sshfx.FileMode(FromFileMode(dirent.Mode())).String()
 
 	var numLinks uint64 = 1
 	uid, gid := "0", "0"

packet.go

@@ -292,7 +292,7 @@ func recvPacket(r io.Reader, alloc *allocator, orderID uint32) (uint8, []byte, e
 	if _, err := io.ReadFull(r, b[:length]); err != nil {
 		// ReadFull only returns EOF if it has read no bytes.
 		// In this case, that means a partial packet, and thus unexpected.
-		if err == io.EOF {
+		if errors.Is(err, io.EOF) {
 			err = io.ErrUnexpectedEOF
 		}
 		debug("recv packet %d bytes: err %v", length, err)

request-example.go

@@ -37,7 +37,8 @@ func (fs *root) Fileread(r *Request) (io.ReaderAt, error) {
 		return nil, os.ErrInvalid
 	}
 
-	return fs.OpenFile(r)
+	// Needs to be readable by the user.
+	return fs.openFileModeCheck(r, 0o0400)
 }
 
 func (fs *root) Filewrite(r *Request) (io.WriterAt, error) {
@@ -47,10 +48,16 @@ func (fs *root) Filewrite(r *Request) (io.WriterAt, error) {
 		return nil, os.ErrInvalid
 	}
 
-	return fs.OpenFile(r)
+	// Needs to be writable by the user.
+	return fs.openFileModeCheck(r, 0o0200)
 }
 
 func (fs *root) OpenFile(r *Request) (WriterAtReaderAt, error) {
+	// Needs to be readable and writable by the user.
+	return fs.openFileModeCheck(r, 0o0200|0o0400)
+}
+
+func (fs *root) openFileModeCheck(r *Request, mode uint32) (WriterAtReaderAt, error) {
 	if fs.mockErr != nil {
 		return nil, fs.mockErr
 	}
@@ -59,7 +66,16 @@ func (fs *root) OpenFile(r *Request) (WriterAtReaderAt, error) {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
-	return fs.openfile(r.Filepath, r.Flags)
+	f, err := fs.openfile(r.Filepath, r.Flags)
+	if err != nil {
+		return nil, err
+	}
+
+	if f.mode&mode != mode {
+		return nil, os.ErrPermission
+	}
+
+	return f, nil
 }
 
 func (fs *root) putfile(pathname string, file *memFile) error {
@@ -72,7 +88,7 @@ func (fs *root) putfile(pathname string, file *memFile) error {
 		return os.ErrInvalid
 	}
 
-	if _, err := fs.lfetch(pathname); err != os.ErrNotExist {
+	if _, err := fs.lfetch(pathname); !errors.Is(err, os.ErrNotExist) {
 		return os.ErrExist
 	}
 
@@ -86,7 +102,7 @@ func (fs *root) openfile(pathname string, flags uint32) (*memFile, error) {
 	pflags := newFileOpenFlags(flags)
 
 	file, err := fs.fetch(pathname)
-	if err == os.ErrNotExist {
+	if errors.Is(err, os.ErrNotExist) {
 		if !pflags.Creat {
 			return nil, os.ErrNotExist
 		}
@@ -108,8 +124,11 @@ func (fs *root) openfile(pathname string, flags uint32) (*memFile, error) {
 			link, err = fs.lfetch(pathname)
 		}
 
+		// The mode is hard coded because the sftp protocol does not specify a
+		// mode at file open time.
 		file := &memFile{
 			modtime: time.Now(),
+			mode:    0644,
 		}
 
 		if err := fs.putfile(pathname, file); err != nil {
@@ -151,15 +170,38 @@ func (fs *root) Filecmd(r *Request) error {
 
 	switch r.Method {
 	case "Setstat":
+		// We explicitly do not support changing the mode of symlinks.
+		// Nor do we want to change the mode of whatever the symlink is pointed
+		// at.
+		link, err := fs.Readlink(r.Filepath)
+		if link != "" || err == nil || !errors.Is(err, os.ErrInvalid) {
+			return err
+		}
+
+		// Note: fs.openfile does not support opening a directory.
+		// So there is currently no way to set the mode of a directory.
+		// That's a good thing, because it means that we don't have to do
+		// permissions checks on parent directories.
+		flags := r.AttrFlags()
+		attrs := r.Attributes()
 		file, err := fs.openfile(r.Filepath, sshFxfWrite)
 		if err != nil {
 			return err
 		}
 
-		if r.AttrFlags().Size {
-			return file.Truncate(int64(r.Attributes().Size))
+		if flags.Size {
+			if err = file.Truncate(int64(attrs.Size)); err != nil {
+				return err
+			}
+		}
+		if flags.Permissions {
+			const mask = uint32(os.ModePerm | s_ISUID | s_ISGID | s_ISVTX)
+			file.mode = (file.mode &^ mask) | (attrs.Mode & mask)
+		}
+		// We only have mtime, not atime.
+		if flags.Acmodtime {
+			file.modtime = time.Unix(int64(attrs.Mtime), 0)
 		}
-
 		return nil
 
 	case "Rename":
@@ -209,7 +251,7 @@ func (fs *root) rename(oldpath, newpath string) error {
 	}
 
 	target, err := fs.lfetch(newpath)
-	if err != os.ErrNotExist {
+	if !errors.Is(err, os.ErrNotExist) {
 		if target == file {
 			// IEEE 1003.1: if oldpath and newpath are the same directory entry,
 			// then return no error, and perform no further action.
@@ -507,7 +549,7 @@ func (fs *root) exists(path string) bool {
 
 	_, err = fs.lfetch(path)
 
-	return err != os.ErrNotExist
+	return !errors.Is(err, os.ErrNotExist)
 }
 
 func (fs *root) fetch(pathname string) (*memFile, error) {
@@ -544,6 +586,7 @@ type memFile struct {
 	modtime time.Time
 	symlink string
 	isdir   bool
+	mode    uint32
 
 	mu      sync.RWMutex
 	content []byte
@@ -563,13 +606,15 @@ func (f *memFile) Size() int64 {
 	return f.size()
 }
 func (f *memFile) Mode() os.FileMode {
+	// Hardcoded values, because we do not even try to support changing the
+	// mode of directories or symlinks.
 	if f.isdir {
 		return os.FileMode(0755) | os.ModeDir
 	}
 	if f.symlink != "" {
 		return os.FileMode(0777) | os.ModeSymlink
 	}
-	return os.FileMode(0644)
+	return os.FileMode(f.mode)
 }
 func (f *memFile) ModTime() time.Time { return f.modtime }
 func (f *memFile) IsDir() bool        { return f.isdir }

request-server.go

@@ -189,7 +189,7 @@ func (rs *RequestServer) Serve() error {
 	// make sure all open requests are properly closed
 	// (eg. possible on dropped connections, client crashes, etc.)
 	for handle, req := range rs.openRequests {
-		if err == io.EOF {
+		if errors.Is(err, io.EOF) {
 			err = io.ErrUnexpectedEOF
 		}
 		req.transferError(err)

request-server_test.go

@@ -2,6 +2,7 @@ package sftp
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -240,7 +241,7 @@ func TestRequestJustRead(t *testing.T) {
 	defer rf.Close()
 	contents := make([]byte, 5)
 	n, err := rf.Read(contents)
-	if err != nil && err != io.EOF {
+	if err != nil && !errors.Is(err, io.EOF) {
 		t.Fatalf("err: %v", err)
 	}
 	assert.Equal(t, 5, n)