Vendor github.com/jlaffaye/ftp for ftp backend

vendor/github.com/jlaffaye/ftp/ftp.go

@@ -0,0 +1,557 @@
+// Package ftp implements a FTP client as described in RFC 959.
+//
+// A textproto.Error is returned for errors at the protocol level.
+package ftp
+
+import (
+	"bufio"
+	"errors"
+	"io"
+	"net"
+	"net/textproto"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// EntryType describes the different types of an Entry.
+type EntryType int
+
+// The differents types of an Entry
+const (
+	EntryTypeFile EntryType = iota
+	EntryTypeFolder
+	EntryTypeLink
+)
+
+// ServerConn represents the connection to a remote FTP server.
+// It should be protected from concurrent accesses.
+type ServerConn struct {
+	// Do not use EPSV mode
+	DisableEPSV bool
+
+	conn          *textproto.Conn
+	host          string
+	timeout       time.Duration
+	features      map[string]string
+	mlstSupported bool
+}
+
+// Entry describes a file and is returned by List().
+type Entry struct {
+	Name string
+	Type EntryType
+	Size uint64
+	Time time.Time
+}
+
+// Response represents a data-connection
+type Response struct {
+	conn   net.Conn
+	c      *ServerConn
+	closed bool
+}
+
+// Connect is an alias to Dial, for backward compatibility
+func Connect(addr string) (*ServerConn, error) {
+	return Dial(addr)
+}
+
+// Dial is like DialTimeout with no timeout
+func Dial(addr string) (*ServerConn, error) {
+	return DialTimeout(addr, 0)
+}
+
+// DialTimeout initializes the connection to the specified ftp server address.
+//
+// It is generally followed by a call to Login() as most FTP commands require
+// an authenticated user.
+func DialTimeout(addr string, timeout time.Duration) (*ServerConn, error) {
+	tconn, err := net.DialTimeout("tcp", addr, timeout)
+	if err != nil {
+		return nil, err
+	}
+
+	// Use the resolved IP address in case addr contains a domain name
+	// If we use the domain name, we might not resolve to the same IP.
+	remoteAddr := tconn.RemoteAddr().String()
+	host, _, err := net.SplitHostPort(remoteAddr)
+	if err != nil {
+		return nil, err
+	}
+
+	conn := textproto.NewConn(tconn)
+
+	c := &ServerConn{
+		conn:     conn,
+		host:     host,
+		timeout:  timeout,
+		features: make(map[string]string),
+	}
+
+	_, _, err = c.conn.ReadResponse(StatusReady)
+	if err != nil {
+		c.Quit()
+		return nil, err
+	}
+
+	err = c.feat()
+	if err != nil {
+		c.Quit()
+		return nil, err
+	}
+
+	if _, mlstSupported := c.features["MLST"]; mlstSupported {
+		c.mlstSupported = true
+	}
+
+	return c, nil
+}
+
+// Login authenticates the client with specified user and password.
+//
+// "anonymous"/"anonymous" is a common user/password scheme for FTP servers
+// that allows anonymous read-only accounts.
+func (c *ServerConn) Login(user, password string) error {
+	code, message, err := c.cmd(-1, "USER %s", user)
+	if err != nil {
+		return err
+	}
+
+	switch code {
+	case StatusLoggedIn:
+	case StatusUserOK:
+		_, _, err = c.cmd(StatusLoggedIn, "PASS %s", password)
+		if err != nil {
+			return err
+		}
+	default:
+		return errors.New(message)
+	}
+
+	// Switch to binary mode
+	if _, _, err = c.cmd(StatusCommandOK, "TYPE I"); err != nil {
+		return err
+	}
+
+	// Switch to UTF-8
+	if err := c.setUTF8(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// feat issues a FEAT FTP command to list the additional commands supported by
+// the remote FTP server.
+// FEAT is described in RFC 2389
+func (c *ServerConn) feat() error {
+	code, message, err := c.cmd(-1, "FEAT")
+	if err != nil {
+		return err
+	}
+
+	if code != StatusSystem {
+		// The server does not support the FEAT command. This is not an
+		// error: we consider that there is no additional feature.
+		return nil
+	}
+
+	lines := strings.Split(message, "\n")
+	for _, line := range lines {
+		if !strings.HasPrefix(line, " ") {
+			continue
+		}
+
+		line = strings.TrimSpace(line)
+		featureElements := strings.SplitN(line, " ", 2)
+
+		command := featureElements[0]
+
+		var commandDesc string
+		if len(featureElements) == 2 {
+			commandDesc = featureElements[1]
+		}
+
+		c.features[command] = commandDesc
+	}
+
+	return nil
+}
+
+// setUTF8 issues an "OPTS UTF8 ON" command.
+func (c *ServerConn) setUTF8() error {
+	if _, ok := c.features["UTF8"]; !ok {
+		return nil
+	}
+
+	code, message, err := c.cmd(-1, "OPTS UTF8 ON")
+	if err != nil {
+		return err
+	}
+
+	// The ftpd "filezilla-server" has FEAT support for UTF8, but always returns
+	// "202 UTF8 mode is always enabled. No need to send this command." when
+	// trying to use it. That's OK
+	if code == StatusCommandNotImplemented {
+		return nil
+	}
+
+	if code != StatusCommandOK {
+		return errors.New(message)
+	}
+
+	return nil
+}
+
+// epsv issues an "EPSV" command to get a port number for a data connection.
+func (c *ServerConn) epsv() (port int, err error) {
+	_, line, err := c.cmd(StatusExtendedPassiveMode, "EPSV")
+	if err != nil {
+		return
+	}
+
+	start := strings.Index(line, "|||")
+	end := strings.LastIndex(line, "|")
+	if start == -1 || end == -1 {
+		err = errors.New("Invalid EPSV response format")
+		return
+	}
+	port, err = strconv.Atoi(line[start+3 : end])
+	return
+}
+
+// pasv issues a "PASV" command to get a port number for a data connection.
+func (c *ServerConn) pasv() (port int, err error) {
+	_, line, err := c.cmd(StatusPassiveMode, "PASV")
+	if err != nil {
+		return
+	}
+
+	// PASV response format : 227 Entering Passive Mode (h1,h2,h3,h4,p1,p2).
+	start := strings.Index(line, "(")
+	end := strings.LastIndex(line, ")")
+	if start == -1 || end == -1 {
+		return 0, errors.New("Invalid PASV response format")
+	}
+
+	// We have to split the response string
+	pasvData := strings.Split(line[start+1:end], ",")
+
+	if len(pasvData) < 6 {
+		return 0, errors.New("Invalid PASV response format")
+	}
+
+	// Let's compute the port number
+	portPart1, err1 := strconv.Atoi(pasvData[4])
+	if err1 != nil {
+		err = err1
+		return
+	}
+
+	portPart2, err2 := strconv.Atoi(pasvData[5])
+	if err2 != nil {
+		err = err2
+		return
+	}
+
+	// Recompose port
+	port = portPart1*256 + portPart2
+	return
+}
+
+// getDataConnPort returns a port for a new data connection
+// it uses the best available method to do so
+func (c *ServerConn) getDataConnPort() (int, error) {
+	if !c.DisableEPSV {
+		if port, err := c.epsv(); err == nil {
+			return port, nil
+		}
+
+		// if there is an error, disable EPSV for the next attempts
+		c.DisableEPSV = true
+	}
+
+	return c.pasv()
+}
+
+// openDataConn creates a new FTP data connection.
+func (c *ServerConn) openDataConn() (net.Conn, error) {
+	port, err := c.getDataConnPort()
+	if err != nil {
+		return nil, err
+	}
+
+	return net.DialTimeout("tcp", net.JoinHostPort(c.host, strconv.Itoa(port)), c.timeout)
+}
+
+// cmd is a helper function to execute a command and check for the expected FTP
+// return code
+func (c *ServerConn) cmd(expected int, format string, args ...interface{}) (int, string, error) {
+	_, err := c.conn.Cmd(format, args...)
+	if err != nil {
+		return 0, "", err
+	}
+
+	return c.conn.ReadResponse(expected)
+}
+
+// cmdDataConnFrom executes a command which require a FTP data connection.
+// Issues a REST FTP command to specify the number of bytes to skip for the transfer.
+func (c *ServerConn) cmdDataConnFrom(offset uint64, format string, args ...interface{}) (net.Conn, error) {
+	conn, err := c.openDataConn()
+	if err != nil {
+		return nil, err
+	}
+
+	if offset != 0 {
+		_, _, err := c.cmd(StatusRequestFilePending, "REST %d", offset)
+		if err != nil {
+			conn.Close()
+			return nil, err
+		}
+	}
+
+	_, err = c.conn.Cmd(format, args...)
+	if err != nil {
+		conn.Close()
+		return nil, err
+	}
+
+	code, msg, err := c.conn.ReadResponse(-1)
+	if err != nil {
+		conn.Close()
+		return nil, err
+	}
+	if code != StatusAlreadyOpen && code != StatusAboutToSend {
+		conn.Close()
+		return nil, &textproto.Error{Code: code, Msg: msg}
+	}
+
+	return conn, nil
+}
+
+// NameList issues an NLST FTP command.
+func (c *ServerConn) NameList(path string) (entries []string, err error) {
+	conn, err := c.cmdDataConnFrom(0, "NLST %s", path)
+	if err != nil {
+		return
+	}
+
+	r := &Response{conn: conn, c: c}
+	defer r.Close()
+
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		entries = append(entries, scanner.Text())
+	}
+	if err = scanner.Err(); err != nil {
+		return entries, err
+	}
+	return
+}
+
+// List issues a LIST FTP command.
+func (c *ServerConn) List(path string) (entries []*Entry, err error) {
+	var cmd string
+	var parseFunc func(string) (*Entry, error)
+
+	if c.mlstSupported {
+		cmd = "MLSD"
+		parseFunc = parseRFC3659ListLine
+	} else {
+		cmd = "LIST"
+		parseFunc = parseListLine
+	}
+
+	conn, err := c.cmdDataConnFrom(0, "%s %s", cmd, path)
+	if err != nil {
+		return
+	}
+
+	r := &Response{conn: conn, c: c}
+	defer r.Close()
+
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		entry, err := parseFunc(scanner.Text())
+		if err == nil {
+			entries = append(entries, entry)
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, err
+	}
+	return
+}
+
+// ChangeDir issues a CWD FTP command, which changes the current directory to
+// the specified path.
+func (c *ServerConn) ChangeDir(path string) error {
+	_, _, err := c.cmd(StatusRequestedFileActionOK, "CWD %s", path)
+	return err
+}
+
+// ChangeDirToParent issues a CDUP FTP command, which changes the current
+// directory to the parent directory.  This is similar to a call to ChangeDir
+// with a path set to "..".
+func (c *ServerConn) ChangeDirToParent() error {
+	_, _, err := c.cmd(StatusRequestedFileActionOK, "CDUP")
+	return err
+}
+
+// CurrentDir issues a PWD FTP command, which Returns the path of the current
+// directory.
+func (c *ServerConn) CurrentDir() (string, error) {
+	_, msg, err := c.cmd(StatusPathCreated, "PWD")
+	if err != nil {
+		return "", err
+	}
+
+	start := strings.Index(msg, "\"")
+	end := strings.LastIndex(msg, "\"")
+
+	if start == -1 || end == -1 {
+		return "", errors.New("Unsuported PWD response format")
+	}
+
+	return msg[start+1 : end], nil
+}
+
+// FileSize issues a SIZE FTP command, which Returns the size of the file
+func (c *ServerConn) FileSize(path string) (int64, error) {
+	_, msg, err := c.cmd(StatusFile, "SIZE %s", path)
+	if err != nil {
+		return 0, err
+	}
+
+	return strconv.ParseInt(msg, 10, 64)
+}
+
+// Retr issues a RETR FTP command to fetch the specified file from the remote
+// FTP server.
+//
+// The returned ReadCloser must be closed to cleanup the FTP data connection.
+func (c *ServerConn) Retr(path string) (*Response, error) {
+	return c.RetrFrom(path, 0)
+}
+
+// RetrFrom issues a RETR FTP command to fetch the specified file from the remote
+// FTP server, the server will not send the offset first bytes of the file.
+//
+// The returned ReadCloser must be closed to cleanup the FTP data connection.
+func (c *ServerConn) RetrFrom(path string, offset uint64) (*Response, error) {
+	conn, err := c.cmdDataConnFrom(offset, "RETR %s", path)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Response{conn: conn, c: c}, nil
+}
+
+// Stor issues a STOR FTP command to store a file to the remote FTP server.
+// Stor creates the specified file with the content of the io.Reader.
+//
+// Hint: io.Pipe() can be used if an io.Writer is required.
+func (c *ServerConn) Stor(path string, r io.Reader) error {
+	return c.StorFrom(path, r, 0)
+}
+
+// StorFrom issues a STOR FTP command to store a file to the remote FTP server.
+// Stor creates the specified file with the content of the io.Reader, writing
+// on the server will start at the given file offset.
+//
+// Hint: io.Pipe() can be used if an io.Writer is required.
+func (c *ServerConn) StorFrom(path string, r io.Reader, offset uint64) error {
+	conn, err := c.cmdDataConnFrom(offset, "STOR %s", path)
+	if err != nil {
+		return err
+	}
+
+	_, err = io.Copy(conn, r)
+	conn.Close()
+	if err != nil {
+		return err
+	}
+
+	_, _, err = c.conn.ReadResponse(StatusClosingDataConnection)
+	return err
+}
+
+// Rename renames a file on the remote FTP server.
+func (c *ServerConn) Rename(from, to string) error {
+	_, _, err := c.cmd(StatusRequestFilePending, "RNFR %s", from)
+	if err != nil {
+		return err
+	}
+
+	_, _, err = c.cmd(StatusRequestedFileActionOK, "RNTO %s", to)
+	return err
+}
+
+// Delete issues a DELE FTP command to delete the specified file from the
+// remote FTP server.
+func (c *ServerConn) Delete(path string) error {
+	_, _, err := c.cmd(StatusRequestedFileActionOK, "DELE %s", path)
+	return err
+}
+
+// MakeDir issues a MKD FTP command to create the specified directory on the
+// remote FTP server.
+func (c *ServerConn) MakeDir(path string) error {
+	_, _, err := c.cmd(StatusPathCreated, "MKD %s", path)
+	return err
+}
+
+// RemoveDir issues a RMD FTP command to remove the specified directory from
+// the remote FTP server.
+func (c *ServerConn) RemoveDir(path string) error {
+	_, _, err := c.cmd(StatusRequestedFileActionOK, "RMD %s", path)
+	return err
+}
+
+// NoOp issues a NOOP FTP command.
+// NOOP has no effects and is usually used to prevent the remote FTP server to
+// close the otherwise idle connection.
+func (c *ServerConn) NoOp() error {
+	_, _, err := c.cmd(StatusCommandOK, "NOOP")
+	return err
+}
+
+// Logout issues a REIN FTP command to logout the current user.
+func (c *ServerConn) Logout() error {
+	_, _, err := c.cmd(StatusReady, "REIN")
+	return err
+}
+
+// Quit issues a QUIT FTP command to properly close the connection from the
+// remote FTP server.
+func (c *ServerConn) Quit() error {
+	c.conn.Cmd("QUIT")
+	return c.conn.Close()
+}
+
+// Read implements the io.Reader interface on a FTP data connection.
+func (r *Response) Read(buf []byte) (int, error) {
+	return r.conn.Read(buf)
+}
+
+// Close implements the io.Closer interface on a FTP data connection.
+// After the first call, Close will do nothing and return nil.
+func (r *Response) Close() error {
+	if r.closed {
+		return nil
+	}
+	err := r.conn.Close()
+	_, _, err2 := r.c.conn.ReadResponse(StatusClosingDataConnection)
+	if err2 != nil {
+		err = err2
+	}
+	r.closed = true
+	return err
+}
+
+// SetDeadline sets the deadlines associated with the connection.
+func (r *Response) SetDeadline(t time.Time) error {
+	return r.conn.SetDeadline(t)
+}