Merge remote-tracking branch 'upstream/master'

.github/dependabot.yml

@@ -11,3 +11,7 @@ updates:
       interval: "daily"
     assignees:
       - "jlaffaye"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,69 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "master" ]
+  schedule:
+    - cron: '20 19 * * 2'
+
+permissions:
+  contents: read
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'go' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines. 
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #   echo "Run, Build Application using script"
+    #   ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@b398f525a5587552e573b247ac661067fafa920b

.github/workflows/golangci-lint.yaml

@@ -5,9 +5,12 @@ jobs:
   golangci-lint:
     name: lint
     runs-on: ubuntu-latest
+    permissions:
+      contents: read  # for actions/checkout to fetch code
+      pull-requests: read  # for golangci/golangci-lint-action to fetch pull requests
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@7884fcad6b5d53d10323aee724dc68d8b9096a2e
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v2
+        uses: golangci/golangci-lint-action@08e2f20817b15149a52b5b3ebe7de50aff2ba8c5
         with:
           only-new-issues: true

.github/workflows/unit_tests.yaml

@@ -5,12 +5,12 @@ jobs:
     name: test
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@master
+    - uses: actions/checkout@61b9e3751b92087fd0b06925ba6dd6314e06f089
     - name: Setup go
-      uses: actions/setup-go@v2
+      uses: actions/setup-go@fac708d6674e30b6ba41289acaab6d4b75aa0753
       with:
-        go-version: 1.17
+        go-version: 1.19
-    - uses: actions/cache@v2
+    - uses: actions/cache@88522ab9f39a2ea568f7027eddc7d8d8bc9d59c8
       with:
         path: |
           ~/go/pkg/mod
@@ -21,9 +21,9 @@ jobs:
     - name: Run tests
       run: go test -v -covermode=count -coverprofile=coverage.out
     - name: Convert coverage to lcov
-      uses: jandelgado/gcov2lcov-action@v1.0.8
+      uses: jandelgado/gcov2lcov-action@c680c0f7c7442485f1749eb2a13e54a686e76eb5
     - name: Coveralls
-      uses: coverallsapp/github-action@v1.1.2
+      uses: coverallsapp/github-action@f350da2c033043742f89e8c0b7b5145a1616da6d
       with:
         github-token: ${{ secrets.github_token }}
         path-to-lcov: coverage.lcov

README.md

@@ -2,6 +2,8 @@
 
 [![Units tests](https://github.com/jlaffaye/ftp/actions/workflows/unit_tests.yaml/badge.svg)](https://github.com/jlaffaye/ftp/actions/workflows/unit_tests.yaml)
 [![Coverage Status](https://coveralls.io/repos/jlaffaye/ftp/badge.svg?branch=master&service=github)](https://coveralls.io/github/jlaffaye/ftp?branch=master)
+[![golangci-lint](https://github.com/jlaffaye/ftp/actions/workflows/golangci-lint.yaml/badge.svg)](https://github.com/jlaffaye/ftp/actions/workflows/golangci-lint.yaml)
+[![CodeQL](https://github.com/jlaffaye/ftp/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/jlaffaye/ftp/actions/workflows/codeql-analysis.yml)
 [![Go ReportCard](https://goreportcard.com/badge/jlaffaye/ftp)](http://goreportcard.com/report/jlaffaye/ftp)
 [![Go Reference](https://pkg.go.dev/badge/github.com/jlaffaye/ftp.svg)](https://pkg.go.dev/github.com/jlaffaye/ftp)
 

client_test.go

@@ -3,10 +3,8 @@ package ftp
 import (
 	"bytes"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net"
-	"net/textproto"
-	"strings"
 	"syscall"
 	"testing"
 	"time"
@@ -28,174 +26,145 @@ func TestConnEPSV(t *testing.T) {
 }
 
 func testConn(t *testing.T, disableEPSV bool) {
+	assert := assert.New(t)
 	mock, c := openConn(t, "127.0.0.1", DialWithTimeout(5*time.Second), DialWithDisabledEPSV(disableEPSV))
 
 	err := c.Login("anonymous", "anonymous")
-	if err != nil {
+	assert.NoError(err)
-		t.Fatal(err)
-	}
 
 	err = c.NoOp()
-	if err != nil {
+	assert.NoError(err)
-		t.Error(err)
-	}
 
 	err = c.ChangeDir("incoming")
-	if err != nil {
+	assert.NoError(err)
-		t.Error(err)
-	}
 
 	dir, err := c.CurrentDir()
-	if err != nil {
+	if assert.NoError(err) {
-		t.Error(err)
+		assert.Equal("/incoming", dir)
-	} else {
-		if dir != "/incoming" {
-			t.Error("Wrong dir: " + dir)
-		}
 	}
 
 	data := bytes.NewBufferString(testData)
 	err = c.Stor("test", data)
-	if err != nil {
+	assert.NoError(err)
-		t.Error(err)
-	}
 
 	_, err = c.List(".")
-	if err != nil {
+	assert.NoError(err)
-		t.Error(err)
-	}
 
 	err = c.Rename("test", "tset")
-	if err != nil {
+	assert.NoError(err)
-		t.Error(err)
-	}
 
 	// Read without deadline
 	r, err := c.Retr("tset")
-	if err != nil {
+	if assert.NoError(err) {
-		t.Error(err)
+		buf, err := io.ReadAll(r)
-	} else {
+		if assert.NoError(err) {
-		buf, errRead := ioutil.ReadAll(r)
+			assert.Equal(testData, string(buf))
-		if err != nil {
-			t.Error(errRead)
-		}
-		if string(buf) != testData {
-			t.Errorf("'%s'", buf)
 		}
+
 		r.Close()
 		r.Close() // test we can close two times
 	}
 
 	// Read with deadline
 	r, err = c.Retr("tset")
-	if err != nil {
+	if assert.NoError(err) {
-		t.Error(err)
-	} else {
 		if err := r.SetDeadline(time.Now()); err != nil {
 			t.Fatal(err)
 		}
-		_, err = ioutil.ReadAll(r)
+		_, err = io.ReadAll(r)
-		if err == nil {
+		assert.ErrorContains(err, "i/o timeout")
-			t.Error("deadline should have caused error")
-		} else if !strings.HasSuffix(err.Error(), "i/o timeout") {
-			t.Error(err)
-		}
 		r.Close()
 	}
 
 	// Read with offset
 	r, err = c.RetrFrom("tset", 5)
-	if err != nil {
+	if assert.NoError(err) {
-		t.Error(err)
+		buf, err := io.ReadAll(r)
-	} else {
+		if assert.NoError(err) {
-		buf, errRead := ioutil.ReadAll(r)
+			expected := testData[5:]
-		if errRead != nil {
+			assert.Equal(expected, string(buf))
-			t.Error(errRead)
-		}
-		expected := testData[5:]
-		if string(buf) != expected {
-			t.Errorf("read %q, expected %q", buf, expected)
 		}
+
 		r.Close()
 	}
 
 	data2 := bytes.NewBufferString(testData)
 	err = c.Append("tset", data2)
-	if err != nil {
+	assert.NoError(err)
-		t.Error(err)
-	}
 
 	// Read without deadline, after append
 	r, err = c.Retr("tset")
-	if err != nil {
+	if assert.NoError(err) {
-		t.Error(err)
+		buf, err := io.ReadAll(r)
-	} else {
+		if assert.NoError(err) {
-		buf, errRead := ioutil.ReadAll(r)
+			assert.Equal(testData+testData, string(buf))
-		if err != nil {
-			t.Error(errRead)
-		}
-		if string(buf) != testData+testData {
-			t.Errorf("'%s'", buf)
 		}
+
 		r.Close()
 	}
 
 	fileSize, err := c.FileSize("magic-file")
+	assert.NoError(err)
+	assert.Equal(int64(42), fileSize)
+
+	_, err = c.FileSize("not-found")
+	assert.Error(err)
+
+	entry, err := c.GetEntry("magic-file")
 	if err != nil {
 		t.Error(err)
 	}
-	if fileSize != 42 {
+	if entry == nil {
-		t.Errorf("file size %q, expected %q", fileSize, 42)
+		t.Fatal("expected entry, got nil")
+	}
+	if entry.Size != 42 {
+		t.Errorf("entry size %q, expected %q", entry.Size, 42)
+	}
+	if entry.Type != EntryTypeFile {
+		t.Errorf("entry type %q, expected %q", entry.Type, EntryTypeFile)
+	}
+	if entry.Name != "magic-file" {
+		t.Errorf("entry name %q, expected %q", entry.Name, "magic-file")
 	}
 
-	_, err = c.FileSize("not-found")
+	entry, err = c.GetEntry("multiline-dir")
-	if err == nil {
+	if err != nil {
-		t.Fatal("expected error, got nil")
+		t.Error(err)
+	}
+	if entry == nil {
+		t.Fatal("expected entry, got nil")
+	}
+	if entry.Size != 0 {
+		t.Errorf("entry size %q, expected %q", entry.Size, 0)
+	}
+	if entry.Type != EntryTypeFolder {
+		t.Errorf("entry type %q, expected %q", entry.Type, EntryTypeFolder)
+	}
+	if entry.Name != "multiline-dir" {
+		t.Errorf("entry name %q, expected %q", entry.Name, "multiline-dir")
 	}
 
 	err = c.Delete("tset")
-	if err != nil {
+	assert.NoError(err)
-		t.Error(err)
-	}
 
 	err = c.MakeDir(testDir)
-	if err != nil {
+	assert.NoError(err)
-		t.Error(err)
-	}
 
 	err = c.ChangeDir(testDir)
-	if err != nil {
+	assert.NoError(err)
-		t.Error(err)
-	}
 
 	err = c.ChangeDirToParent()
-	if err != nil {
+	assert.NoError(err)
-		t.Error(err)
-	}
 
 	entries, err := c.NameList("/")
-	if err != nil {
+	assert.NoError(err)
-		t.Error(err)
+	assert.Equal([]string{"/incoming"}, entries)
-	}
-	if len(entries) != 1 || entries[0] != "/incoming" {
-		t.Errorf("Unexpected entries: %v", entries)
-	}
 
 	err = c.RemoveDir(testDir)
-	if err != nil {
+	assert.NoError(err)
-		t.Error(err)
-	}
 
 	err = c.Logout()
-	if err != nil {
+	assert.NoError(err)
-		if protoErr := err.(*textproto.Error); protoErr != nil {
-			if protoErr.Code != StatusNotImplemented {
-				t.Error(err)
-			}
-		} else {
-			t.Error(err)
-		}
-	}
 
 	if err = c.Quit(); err != nil {
 		t.Fatal(err)
@@ -205,9 +174,7 @@ func testConn(t *testing.T, disableEPSV bool) {
 	mock.Wait()
 
 	err = c.NoOp()
-	if err == nil {
+	assert.Error(err, "should error on closed conn")
-		t.Error("Expected error")
-	}
 }
 
 // TestConnect tests the legacy Connect function
@@ -312,7 +279,7 @@ func TestMissingFolderDeleteDirRecur(t *testing.T) {
 }
 
 func TestListCurrentDir(t *testing.T) {
-	mock, c := openConn(t, "127.0.0.1")
+	mock, c := openConnExt(t, "127.0.0.1", "no-time", DialWithDisabledMLSD(true))
 
 	_, err := c.List("")
 	assert.NoError(t, err)
@@ -328,6 +295,20 @@ func TestListCurrentDir(t *testing.T) {
 	mock.Wait()
 }
 
+func TestListCurrentDirWithForceListHidden(t *testing.T) {
+	mock, c := openConnExt(t, "127.0.0.1", "no-time", DialWithDisabledMLSD(true), DialWithForceListHidden(true))
+
+	assert.True(t, c.options.forceListHidden)
+	_, err := c.List("")
+	assert.NoError(t, err)
+	assert.Equal(t, "LIST -a", mock.lastFull, "LIST -a must not have a trailing whitespace")
+
+	err = c.Quit()
+	assert.NoError(t, err)
+
+	mock.Wait()
+}
+
 func TestTimeUnsupported(t *testing.T) {
 	mock, c := openConnExt(t, "127.0.0.1", "no-time")
 

conn_test.go

@@ -6,12 +6,14 @@ import (
 	"io"
 	"net"
 	"net/textproto"
-	"reflect"
 	"strconv"
 	"strings"
 	"sync"
 	"testing"
 	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type ftpMock struct {
@@ -88,7 +90,7 @@ func (mock *ftpMock) listen() {
 		// At least one command must have a multiline response
 		switch cmdParts[0] {
 		case "FEAT":
-			features := "211-Features:\r\n FEAT\r\n PASV\r\n EPSV\r\n UTF8\r\n SIZE\r\n"
+			features := "211-Features:\r\n FEAT\r\n PASV\r\n EPSV\r\n UTF8\r\n SIZE\r\n MLST\r\n"
 			switch mock.modtime {
 			case "std-time":
 				features += " MDTM\r\n MFMT\r\n"
@@ -176,6 +178,23 @@ func (mock *ftpMock) listen() {
 			mock.dataConn.write([]byte("-rw-r--r--   1 ftp      wheel           0 Jan 29 10:29 lo\r\ntotal 1"))
 			mock.printfLine("226 Transfer complete")
 			mock.closeDataConn()
+		case "MLSD":
+			if mock.dataConn == nil {
+				mock.printfLine("425 Unable to build data connection: Connection refused")
+				break
+			}
+
+			mock.dataConn.Wait()
+			mock.printfLine("150 Opening data connection for file list")
+			mock.dataConn.write([]byte("Type=file;Size=0;Modify=20201213202400; lo\r\n"))
+			mock.printfLine("226 Transfer complete")
+			mock.closeDataConn()
+		case "MLST":
+			if cmdParts[1] == "multiline-dir" {
+				mock.printfLine("250-File data\r\n Type=dir;Size=0; multiline-dir\r\n Modify=20201213202400; multiline-dir\r\n250 End")
+			} else {
+				mock.printfLine("250-File data\r\n Type=file;Size=42;Modify=20201213202400; magic-file\r\n \r\n250 End")
+			}
 		case "NLST":
 			if mock.dataConn == nil {
 				mock.printfLine("425 Unable to build data connection: Connection refused")
@@ -386,20 +405,14 @@ func openConn(t *testing.T, addr string, options ...DialOption) (*ftpMock, *Serv
 
 func openConnExt(t *testing.T, addr, modtime string, options ...DialOption) (*ftpMock, *ServerConn) {
 	mock, err := newFtpMockExt(t, addr, modtime)
-	if err != nil {
+	require.NoError(t, err)
-		t.Fatal(err)
-	}
 	defer mock.Close()
 
 	c, err := Dial(mock.Addr(), options...)
-	if err != nil {
+	require.NoError(t, err)
-		t.Fatal(err)
-	}
 
 	err = c.Login("anonymous", "anonymous")
-	if err != nil {
+	require.NoError(t, err)
-		t.Fatal(err)
-	}
 
 	return mock, c
 }
@@ -417,9 +430,7 @@ func closeConn(t *testing.T, mock *ftpMock, c *ServerConn, commands []string) {
 	// Wait for the connection to close
 	mock.Wait()
 
-	if !reflect.DeepEqual(mock.commands, expected) {
+	assert.Equal(t, expected, mock.commands, "unexpected sequence of commands")
-		t.Fatal("unexpected sequence of commands:", mock.commands, "expected:", expected)
-	}
 }
 
 func TestConn4(t *testing.T) {

ftp.go

@@ -18,6 +18,12 @@ import (
 	"github.com/hashicorp/go-multierror"
 )
 
+const (
+	// 30 seconds was chosen as it's the
+	// same duration as http.DefaultTransport's timeout.
+	DefaultDialTimeout = 30 * time.Second
+)
+
 // EntryType describes the different types of an Entry.
 type EntryType int
 
@@ -28,13 +34,13 @@ const (
 	EntryTypeLink
 )
 
-// TransferType denotes the formats for transfering Entries.
+// TransferType denotes the formats for transferring Entries.
 type TransferType string
 
 // The different transfer types
 const (
-	TransferTypeBinary = "I"
+	TransferTypeBinary = TransferType("I")
-	TransferTypeASCII  = "A"
+	TransferTypeASCII  = TransferType("A")
 )
 
 // Time format used by the MDTM and MFMT commands
@@ -66,19 +72,19 @@ type DialOption struct {
 
 // dialOptions contains all the options set by DialOption.setup
 type dialOptions struct {
-	context     context.Context
+	context         context.Context
-	dialer      net.Dialer
+	dialer          net.Dialer
-	tlsConfig   *tls.Config
+	tlsConfig       *tls.Config
-	explicitTLS bool
+	explicitTLS     bool
-	conn        net.Conn
+	disableEPSV     bool
-	disableEPSV bool
+	disableUTF8     bool
-	disableUTF8 bool
+	disableMLSD     bool
-	disableMLSD bool
+	writingMDTM     bool
-	writingMDTM bool
+	forceListHidden bool
-	location    *time.Location
+	location        *time.Location
-	debugOutput io.Writer
+	debugOutput     io.Writer
-	dialFunc    func(network, address string) (net.Conn, error)
+	dialFunc        func(network, address string) (net.Conn, error)
-	shutTimeout time.Duration // time to wait for data connection closing status
+	shutTimeout     time.Duration // time to wait for data connection closing status
 }
 
 // Entry describes a file and is returned by List().
@@ -108,27 +114,39 @@ func Dial(addr string, options ...DialOption) (*ServerConn, error) {
 		do.location = time.UTC
 	}
 
-	tconn := do.conn
+	dialFunc := do.dialFunc
-	if tconn == nil {
-		var err error
 
-		if do.dialFunc != nil {
+	if dialFunc == nil {
-			tconn, err = do.dialFunc("tcp", addr)
+		ctx := do.context
-		} else if do.tlsConfig != nil && !do.explicitTLS {
-			tconn, err = tls.DialWithDialer(&do.dialer, "tcp", addr, do.tlsConfig)
-		} else {
-			ctx := do.context
 
-			if ctx == nil {
+		if ctx == nil {
-				ctx = context.Background()
+			ctx = context.Background()
+		}
+		if _, ok := ctx.Deadline(); !ok {
+			var cancel context.CancelFunc
+			ctx, cancel = context.WithTimeout(ctx, DefaultDialTimeout)
+			defer cancel()
+		}
+
+		if do.tlsConfig != nil && !do.explicitTLS {
+			dialFunc = func(network, address string) (net.Conn, error) {
+				tlsDialer := &tls.Dialer{
+					NetDialer: &do.dialer,
+					Config:    do.tlsConfig,
+				}
+				return tlsDialer.DialContext(ctx, network, addr)
 			}
+		} else {
 
-			tconn, err = do.dialer.DialContext(ctx, "tcp", addr)
+			dialFunc = func(network, address string) (net.Conn, error) {
+				return do.dialer.DialContext(ctx, network, addr)
+			}
 		}
+	}
 
-		if err != nil {
+	tconn, err := dialFunc("tcp", addr)
-			return nil, err
+	if err != nil {
-		}
+		return nil, err
 	}
 
 	// Use the resolved IP address in case addr contains a domain name
@@ -143,7 +161,7 @@ func Dial(addr string, options ...DialOption) (*ServerConn, error) {
 		host:     remoteAddr.IP.String(),
 	}
 
-	_, _, err := c.conn.ReadResponse(StatusReady)
+	_, _, err = c.conn.ReadResponse(StatusReady)
 	if err != nil {
 		_ = c.Quit()
 		return nil, err
@@ -185,10 +203,12 @@ func DialWithDialer(dialer net.Dialer) DialOption {
 }
 
 // DialWithNetConn returns a DialOption that configures the ServerConn with the underlying net.Conn
+//
+// Deprecated: Use [DialWithDialFunc] instead
 func DialWithNetConn(conn net.Conn) DialOption {
-	return DialOption{func(do *dialOptions) {
+	return DialWithDialFunc(func(network, address string) (net.Conn, error) {
-		do.conn = conn
+		return conn, nil
-	}}
+	})
 }
 
 // DialWithDisabledEPSV returns a DialOption that configures the ServerConn with EPSV disabled
@@ -228,6 +248,16 @@ func DialWithWritingMDTM(enabled bool) DialOption {
 	}}
 }
 
+// DialWithForceListHidden returns a DialOption making ServerConn use LIST -a to include hidden files and folders in directory listings
+//
+// This is useful for servers that do not do this by default, but it forces the use of the LIST command
+// even if the server supports MLST.
+func DialWithForceListHidden(enabled bool) DialOption {
+	return DialOption{func(do *dialOptions) {
+		do.forceListHidden = enabled
+	}}
+}
+
 // DialWithLocation returns a DialOption that configures the ServerConn with specified time.Location
 // The location is used to parse the dates sent by the server which are in server's timezone
 func DialWithLocation(location *time.Location) DialOption {
@@ -301,14 +331,15 @@ func (o *dialOptions) wrapStream(rd io.ReadCloser) io.ReadCloser {
 }
 
 // Connect is an alias to Dial, for backward compatibility
+//
+// Deprecated: Use [Dial] instead
 func Connect(addr string) (*ServerConn, error) {
 	return Dial(addr)
 }
 
 // DialTimeout initializes the connection to the specified ftp server address.
 //
-// It is generally followed by a call to Login() as most FTP commands require
+// Deprecated: Use [Dial] with [DialWithTimeout] option instead
-// an authenticated user.
 func DialTimeout(addr string, timeout time.Duration) (*ServerConn, error) {
 	return Dial(addr, DialWithTimeout(timeout))
 }
@@ -545,7 +576,24 @@ func (c *ServerConn) openDataConn() (net.Conn, error) {
 	}
 
 	if c.options.tlsConfig != nil {
-		return tls.DialWithDialer(&c.options.dialer, "tcp", addr, c.options.tlsConfig)
+		// We don't use tls.DialWithDialer here (which does Dial, create
+		// the Client and then do the Handshake) because it seems to
+		// hang with some FTP servers, namely proftpd and pureftpd.
+		//
+		// Instead we do Dial, create the Client and wait for the first
+		// Read or Write to trigger the Handshake.
+		//
+		// This means that if we are uploading a zero sized file, we
+		// need to make sure we do the Handshake explicitly as Write
+		// won't have been called. This is done in StorFrom().
+		//
+		// See: https://github.com/jlaffaye/ftp/issues/282
+		conn, err := c.options.dialer.Dial("tcp", addr)
+		if err != nil {
+			return nil, err
+		}
+		tlsConn := tls.Client(conn, c.options.tlsConfig)
+		return tlsConn, nil
 	}
 
 	return c.options.dialer.Dial("tcp", addr)
@@ -647,11 +695,14 @@ func (c *ServerConn) List(path string) (entries []*Entry, err error) {
 	var cmd string
 	var parser parseFunc
 
-	if c.mlstSupported {
+	if c.mlstSupported && !c.options.forceListHidden {
 		cmd = "MLSD"
 		parser = parseRFC3659ListLine
 	} else {
 		cmd = "LIST"
+		if c.options.forceListHidden {
+			cmd += " -a"
+		}
 		parser = parseListLine
 	}
 
@@ -687,6 +738,62 @@ func (c *ServerConn) List(path string) (entries []*Entry, err error) {
 	return entries, errs.ErrorOrNil()
 }
 
+// GetEntry issues a MLST FTP command which retrieves one single Entry using the
+// control connection. The returnedEntry will describe the current directory
+// when no path is given.
+func (c *ServerConn) GetEntry(path string) (entry *Entry, err error) {
+	if !c.mlstSupported {
+		return nil, &textproto.Error{Code: StatusNotImplemented, Msg: StatusText(StatusNotImplemented)}
+	}
+	space := " "
+	if path == "" {
+		space = ""
+	}
+	_, msg, err := c.cmd(StatusRequestedFileActionOK, "%s%s%s", "MLST", space, path)
+	if err != nil {
+		return nil, err
+	}
+
+	// The expected reply will look something like:
+	//
+	//    250-File details
+	//     Type=file;Size=1024;Modify=20220813133357; path
+	//    250 End
+	//
+	// Multiple lines are allowed though, so it can also be in the form:
+	//
+	//    250-File details
+	//     Type=file;Size=1024; path
+	//     Modify=20220813133357; path
+	//    250 End
+	lines := strings.Split(msg, "\n")
+	lc := len(lines)
+
+	// lines must be a multi-line message with a length of 3 or more, and we
+	// don't care about the first and last line
+	if lc < 3 {
+		return nil, errors.New("invalid response")
+	}
+
+	e := &Entry{}
+	for _, l := range lines[1 : lc-1] {
+		// According to RFC 3659, the entry lines must start with a space when passed over the
+		// control connection. Some servers don't seem to add that space though. Both forms are
+		// accepted here.
+		if len(l) > 0 && l[0] == ' ' {
+			l = l[1:]
+		}
+		// Some severs seem to send a blank line at the end which we ignore
+		if l == "" {
+			continue
+		}
+		if e, err = parseNextRFC3659ListLine(l, c.options.location, e); err != nil {
+			return nil, err
+		}
+	}
+	return e, nil
+}
+
 // IsTimePreciseInList returns true if client and server support the MLSD
 // command so List can return time with 1-second precision for all files.
 func (c *ServerConn) IsTimePreciseInList() bool {
@@ -843,8 +950,21 @@ func (c *ServerConn) StorFrom(path string, r io.Reader, offset uint64) error {
 	// response otherwise if the failure is not due to a connection problem,
 	// for example the server denied the upload for quota limits, we miss
 	// the response and we cannot use the connection to send other commands.
-	if _, err := io.Copy(conn, r); err != nil {
+	if n, err := io.Copy(conn, r); err != nil {
 		errs = multierror.Append(errs, err)
+	} else if n == 0 {
+		// If we wrote no bytes and got no error, make sure we call
+		// tls.Handshake on the connection as it won't get called
+		// unless Write() is called. (See comment in openDataConn()).
+		//
+		// ProFTP doesn't like this and returns "Unable to build data
+		// connection: Operation not permitted" when trying to upload
+		// an empty file without this.
+		if do, ok := conn.(interface{ Handshake() error }); ok {
+			if err := do.Handshake(); err != nil {
+				errs = multierror.Append(errs, err)
+			}
+		}
 	}
 
 	if err := conn.Close(); err != nil {
@@ -958,7 +1078,7 @@ func (c *ServerConn) RemoveDir(path string) error {
 	return err
 }
 
-//Walk prepares the internal walk function so that the caller can begin traversing the directory
+// Walk prepares the internal walk function so that the caller can begin traversing the directory
 func (c *ServerConn) Walk(root string) *Walker {
 	w := new(Walker)
 	w.serverConn = c

go.mod

@@ -4,7 +4,7 @@ go 1.17
 
 require (
 	github.com/hashicorp/go-multierror v1.1.1
-	github.com/stretchr/testify v1.8.0
+	github.com/stretchr/testify v1.8.3
 )
 
 require (

go.sum

@@ -9,9 +9,11 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
+github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

parse.go

@@ -27,7 +27,11 @@ var dirTimeFormats = []string{
 }
 
 // parseRFC3659ListLine parses the style of directory line defined in RFC 3659.
-func parseRFC3659ListLine(line string, now time.Time, loc *time.Location) (*Entry, error) {
+func parseRFC3659ListLine(line string, _ time.Time, loc *time.Location) (*Entry, error) {
+	return parseNextRFC3659ListLine(line, loc, &Entry{})
+}
+
+func parseNextRFC3659ListLine(line string, loc *time.Location, e *Entry) (*Entry, error) {
 	iSemicolon := strings.Index(line, ";")
 	iWhitespace := strings.Index(line, " ")
 
@@ -35,8 +39,12 @@ func parseRFC3659ListLine(line string, now time.Time, loc *time.Location) (*Entr
 		return nil, errUnsupportedListLine
 	}
 
-	e := &Entry{
+	name := line[iWhitespace+1:]
-		Name: line[iWhitespace+1:],
+	if e.Name == "" {
+		e.Name = name
+	} else if e.Name != name {
+		// All lines must have the same name
+		return nil, errUnsupportedListLine
 	}
 
 	for _, field := range strings.Split(line[:iWhitespace-1], ";") {

walker.go

@@ -4,7 +4,7 @@ import (
 	"path"
 )
 
-//Walker traverses the directory tree of a remote FTP server
+// Walker traverses the directory tree of a remote FTP server
 type Walker struct {
 	serverConn *ServerConn
 	root       string