add an option to disable concurrent reads

client.go

@@ -966,15 +966,44 @@ func (f *File) readChunkAt(ch chan result, b []byte, off int64) (n int, err erro
 	return
 }
 
+func (f *File) readAtSequential(b []byte, off int64) (int, error) {
+	readed := 0
+
+	for {
+		endRead := int64(math.Min(float64(readed+f.c.maxPacket), float64(len(b))))
+		n, err := f.readChunkAt(nil, b[readed:endRead], off+int64(readed))
+		if n < 0 {
+			panic("sftp.File: returned negative count from readChunkAt")
+		}
+		if n > 0 {
+			readed += n
+		}
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				return readed, nil // return nil explicitly.
+			}
+			return readed, err
+		}
+		if readed == len(b) {
+			return readed, nil
+		}
+	}
+}
+
 // ReadAt reads up to len(b) byte from the File at a given offset `off`. It returns
 // the number of bytes read and an error, if any. ReadAt follows io.ReaderAt semantics,
 // so the file offset is not altered during the read.
 func (f *File) ReadAt(b []byte, off int64) (int, error) {
-	if len(b) <= f.c.maxPacket || f.c.disableConcurrentReads {
-		// This should be able to be serviced with 1/2 requests or concurrent reads are disabled.
+	if len(b) <= f.c.maxPacket {
+		// This should be able to be serviced with 1/2 requests.
+		// So, just do it directly.
 		return f.readChunkAt(nil, b, off)
 	}
 
+	if f.c.disableConcurrentReads {
+		return f.readAtSequential(b, off)
+	}
+
 	// Split the read into multiple maxPacket-sized concurrent reads bounded by maxConcurrentRequests.
 	// This allows writes with a suitably large buffer to transfer data at a much faster rate
 	// by overlapping round trip times.

client_integration_test.go

@@ -1115,6 +1115,67 @@ func TestClientReadSimple(t *testing.T) {
 	}
 }
 
+func TestClientReadSequential(t *testing.T) {
+	sftp, cmd := testClient(t, READONLY, NODELAY)
+	defer cmd.Wait()
+	defer sftp.Close()
+
+	sftp.disableConcurrentReads = true
+	d, err := ioutil.TempDir("", "sftptest-readsequential")
+	require.NoError(t, err)
+
+	defer os.RemoveAll(d)
+
+	f, err := ioutil.TempFile(d, "read-sequential-test")
+	require.NoError(t, err)
+	fname := f.Name()
+	content := []byte("hello world")
+	f.Write(content)
+	f.Close()
+
+	for _, maxPktSize := range []int{1, 2, 3, 4} {
+		sftp.maxPacket = maxPktSize
+
+		sftpFile, err := sftp.Open(fname)
+		require.NoError(t, err)
+
+		stuff := make([]byte, 32)
+		n, err := sftpFile.Read(stuff)
+		require.NoError(t, err)
+		require.Equal(t, len(content), n)
+		require.Equal(t, content, stuff[0:len(content)])
+
+		err = sftpFile.Close()
+		require.NoError(t, err)
+
+		sftpFile, err = sftp.Open(fname)
+		require.NoError(t, err)
+
+		stuff = make([]byte, 5)
+		n, err = sftpFile.Read(stuff)
+		require.NoError(t, err)
+		require.Equal(t, len(stuff), n)
+		require.Equal(t, content[:len(stuff)], stuff)
+
+		err = sftpFile.Close()
+		require.NoError(t, err)
+
+		// now read from a offset
+		off := int64(3)
+		sftpFile, err = sftp.Open(fname)
+		require.NoError(t, err)
+
+		stuff = make([]byte, 5)
+		n, err = sftpFile.ReadAt(stuff, off)
+		require.NoError(t, err)
+		require.Equal(t, len(stuff), n)
+		require.Equal(t, content[off:off+int64(len(stuff))], stuff)
+
+		err = sftpFile.Close()
+		require.NoError(t, err)
+	}
+}
+
 func TestClientReadDir(t *testing.T) {
 	sftp1, cmd1 := testClient(t, READONLY, NODELAY)
 	sftp2, cmd2 := testClientGoSvr(t, READONLY, NODELAY)