w-ftp 1.0.0

package/src/jsftp.js

@@ -0,0 +1,856 @@
+//fork from: https://github.com/sergi/jsftp
+
+'use strict'
+
+const createConnection = require('net').createConnection
+const EventEmitter = require('events').EventEmitter
+const inherits = require('util').inherits
+const stream = require('stream')
+const fs = require('fs')
+const combine = require('stream-combiner')
+
+const ResponseParser = require('ftp-response-parser')
+const ListingParser = require('parse-listing')
+const once = require('once')
+const nfc = require('unorm').nfc
+
+const debug = require('debug')('jsftp:general')
+const dbgCommand = require('debug')('jsftp:command')
+const dbgResponse = require('debug')('jsftp:response')
+
+const FTP_HOST = 'localhost'
+const FTP_PORT = 21
+const TIMEOUT = 10 * 60 * 1000
+const IDLE_TIME = 30000
+const NOOP = function() {}
+
+const expectedMarks = {
+    marks: [125, 150],
+    ignore: 226
+}
+
+const RE_PASV = /([-\d]+,[-\d]+,[-\d]+,[-\d]+),([-\d]+),([-\d]+)/
+const FTP_NEWLINE = /\r\n|\n/
+
+function runCmd(name, ...params) {
+    let callback = NOOP
+    let completeCmd = name + ' '
+
+    if (typeof params[params.length - 1] === 'function') {
+        callback = params.pop()
+    }
+
+    completeCmd += params.join(' ')
+    this.execute(completeCmd.trim(), callback)
+}
+
+function Ftp(cfg) {
+    this.host = cfg.host || FTP_HOST
+    this.port = cfg.port || FTP_PORT
+    this.user = cfg.user || 'anonymous'
+    this.pass = cfg.pass || '@anonymous'
+    this.createSocket = cfg.createSocket
+    // True if the server doesn't support the `stat` command. Since listing a
+    // directory or retrieving file properties is quite a common operation, it is
+    // more efficient to avoid the round-trip to the server.
+    this.useList = cfg.useList || false
+
+    this.commandQueue = []
+
+    EventEmitter.call(this)
+
+    this.on('data', dbgResponse)
+    this.on('error', dbgResponse)
+
+    this._createSocket(this.port, this.host)
+}
+
+inherits(Ftp, EventEmitter)
+
+// Generate generic methods from parameter names. they can easily be
+// overriden if we need special behavior. they accept any parameters given,
+// it is the responsibility of the user to validate the parameters.
+Ftp.prototype.raw = function() {
+    runCmd.apply(this, arguments)
+}
+
+Ftp.prototype.reemit = function(event) {
+    return data => {
+        this.emit(event, data)
+        debug(`event:${event}`, data || {})
+    }
+}
+
+Ftp.prototype._createSocket = function(port, host, firstAction = NOOP) {
+    if (this.socket && this.socket.destroy) {
+        this.socket.destroy()
+    }
+
+    if (this.resParser) {
+        this.resParser.end()
+    }
+    this.resParser = new ResponseParser()
+
+    this.authenticated = false
+    this.socket = this.createSocket
+        ? this.createSocket({ port, host }, firstAction)
+        : createConnection(port, host, firstAction)
+    this.socket.on('connect', this.reemit('connect'))
+    this.socket.on('timeout', this.reemit('timeout'))
+
+    this.pipeline = combine(this.socket, this.resParser)
+
+    this.pipeline.on('data', data => {
+        this.emit('data', data)
+        dbgResponse(data.text)
+        this.parseResponse(data)
+    })
+    this.pipeline.on('error', this.reemit('error'))
+}
+
+Ftp.prototype.parseResponse = function(response) {
+    if (this.commandQueue.length === 0) {
+        return
+    }
+    if ([220].indexOf(response.code) > -1) {
+        return
+    }
+
+    const next = this.commandQueue[0].callback
+    if (response.isMark) {
+    // If we receive a Mark and it is not expected, we ignore that command
+        if (
+            !next.expectsMark ||
+      next.expectsMark.marks.indexOf(response.code) === -1
+        ) {
+            return
+        }
+
+        // We might have to ignore the command that comes after the mark.
+        if (next.expectsMark.ignore) {
+            this.ignoreCmdCode = next.expectsMark.ignore
+        }
+    }
+
+    if (this.ignoreCmdCode === response.code) {
+        this.ignoreCmdCode = null
+        return
+    }
+
+    this.parse(response, this.commandQueue.shift())
+}
+
+/**
+ * Sends a new command to the server.
+ *
+ * @param {String} command Command to write in the FTP socket
+ */
+Ftp.prototype.send = function(command) {
+    if (!command) {
+        return
+    }
+
+    dbgCommand(command)
+    this.pipeline.write(command + '\r\n')
+
+    dbgCommand(command)
+}
+
+Ftp.prototype.nextCmd = function() {
+    const cmd = this.commandQueue[0]
+    if (!this.inProgress && cmd) {
+        this.send(cmd.action)
+        this.inProgress = true
+    }
+}
+
+/**
+ * Check whether the ftp user is authenticated at the moment of the
+ * enqueing. ideally this should happen in the `push` method, just
+ * before writing to the socket, but that would be complicated,
+ * since we would have to 'unshift' the auth chain into the queue
+ * or play the raw auth commands (that is, without enqueuing in
+ * order to not mess up the queue order. ideally, that would be
+ * built into the queue object. all this explanation to justify a
+ * slight slopiness in the code flow.
+ *
+ * @param {string} action
+ * @param {function} callback
+ */
+Ftp.prototype.execute = function(action, callback = NOOP) {
+    if (this.socket && this.socket.writable) {
+        return this.runCommand({ action, callback })
+    }
+
+    this.authenticated = false
+    this._createSocket(this.port, this.host, () => {
+        this.runCommand({ action, callback })
+    })
+}
+
+Ftp.prototype.runCommand = function(cmd) {
+    if (this.authenticated || /^(feat|syst|user|pass)/.test(cmd.action)) {
+        this.commandQueue.push(cmd)
+        this.nextCmd()
+        return
+    }
+
+    this.getFeatures(() => {
+        this.auth(this.user, this.pass, () => {
+            this.commandQueue.push(cmd)
+            this.nextCmd()
+        })
+    })
+}
+
+/**
+ * Parse is called each time that a comand and a request are paired
+ * together. That is, each time that there is a round trip of actions
+ * between the client and the server.
+ *
+ * @param {Object} response Response from the server (contains text and code)
+ * @param {Array} command Contains the command executed and a callback (if any)
+ */
+Ftp.prototype.parse = function(response, command) {
+    let err = null
+    if (response.isError) {
+        err = new Error(response.text || 'Unknown FTP error.')
+        err.code = response.code
+    }
+
+    this.inProgress = false
+    command.callback(err, response)
+    this.nextCmd()
+}
+
+Ftp.prototype.getPasvPort = function(text) {
+    const match = RE_PASV.exec(text)
+    if (!match) {
+        return null
+    }
+
+    let host = match[1].replace(/,/g, '.')
+    if (host === '127.0.0.1') {
+        host = this.host
+    }
+
+    return {
+        host,
+        port: (parseInt(match[2], 10) & 255) * 256 + (parseInt(match[3], 10) & 255)
+    }
+}
+
+/**
+ * Returns true if the current server has the requested feature.
+ *
+ * @param {String} feature Feature to look for
+ * @return {Boolean} Whether the current server has the feature
+ */
+Ftp.prototype.hasFeat = function(feature) {
+    return !!feature && this.features.indexOf(feature.toLowerCase()) > -1
+}
+
+/**
+ * Returns an array of features supported by the current FTP server
+ *
+ * @param {String} features Server response for the 'FEAT' command
+ * @return {String[]} Array of feature names
+ */
+Ftp.prototype._parseFeats = function(features) {
+    // Split and ignore header and footer
+    const featureLines = features.split(FTP_NEWLINE).slice(1, -1)
+    return featureLines
+        .map(feat => feat.trim().toLowerCase())
+        .filter(feat => !!feat)
+}
+
+// Below this point all the methods are action helpers for FTP that compose
+// several actions in one command
+Ftp.prototype.getFeatures = function(callback) {
+    if (this.features) {
+        return callback(null, this.features)
+    }
+
+    this.raw('feat', (err, response) => {
+        this.features = err ? [] : this._parseFeats(response.text)
+        this.raw('syst', (err, res) => {
+            if (!err && res.code === 215) {
+                this.system = res.text.toLowerCase()
+            }
+
+            callback(null, this.features)
+        })
+    })
+}
+
+/**
+ * Authenticates the user.
+ *
+ * @param {String} user Username
+ * @param {String} pass Password
+ * @param {Function} callback Follow-up function.
+ */
+Ftp.prototype.auth = function(user, pass, callback) {
+    if (this.authenticating === true) {
+        return callback(new Error('This client is already authenticating'))
+    }
+
+    if (typeof user !== 'string') {
+        user = this.user
+    }
+    if (typeof pass !== 'string') {
+        pass = this.pass
+    }
+
+    this.authenticating = true
+    this.raw('user', user, (err, res) => {
+        if (err || [230, 331, 332].indexOf(res.code) === -1) {
+            this.authenticating = false
+            callback(err)
+            return
+        }
+        this.raw('pass', pass, (err, res) => {
+            this.authenticating = false
+
+            if (err) {
+                callback(err)
+            }
+            else if ([230, 202].indexOf(res.code) > -1) {
+                this.authenticated = true
+                this.user = user
+                this.pass = pass
+                this.raw('type', 'I', () => {
+                    callback(undefined, res)
+                })
+            }
+            else if (res.code === 332) {
+                this.raw('acct', '') // ACCT not really supported
+            }
+        })
+    })
+}
+
+Ftp.prototype.setType = function(type, callback) {
+    type = type.toUpperCase()
+    if (this.type === type) {
+        return callback()
+    }
+
+    this.raw('type', type, (err, data) => {
+        if (!err) {
+            this.type = type
+        }
+
+        callback(err, data)
+    })
+}
+
+/**
+ * Lists a folder's contents using a passive connection.
+ *
+ * @param {String} path Remote path for the file/folder to retrieve
+ * @param {Function} callback Function to call with errors or results
+ */
+Ftp.prototype.list = function(path, callback) {
+    if (arguments.length === 1) {
+        callback = arguments[0]
+        path = ''
+    }
+
+    let listing = ''
+    callback = once(callback)
+
+    this.getPasvSocket((err, socket) => {
+        if (err) {
+            return callback(err)
+        }
+
+        socket.setEncoding('utf8')
+        socket.on('data', data => {
+            listing += data
+        })
+
+        this.pasvTimeout(socket, callback)
+
+        socket.once('close', err => {
+            if (err) {
+                return callback(err)
+            }
+            else if (!listing) {
+                // Some servers return empty string
+                return callback({
+                    code: 451,
+                    text: `Could not retrieve a file listing for ${path}.`,
+                    isMark: false,
+                    isError: true
+                })
+            }
+            callback(null, listing)
+        })
+        socket.once('error', callback)
+
+        function cmdCallback(err, res) {
+            if (err) {
+                return callback(err)
+            }
+
+            const isExpectedMark = expectedMarks.marks.some(
+                mark => mark === res.code
+            )
+
+            if (!isExpectedMark) {
+                callback(
+                    new Error(
+                        `Expected marks ${expectedMarks.toString()} instead of: ${res.text}`
+                    )
+                )
+            }
+        }
+
+        cmdCallback.expectsMark = expectedMarks
+
+        this.execute(`list ${path || ''}`, cmdCallback)
+    })
+}
+
+Ftp.prototype.emitProgress = function(data) {
+    this.emit('progress', {
+        filename: data.filename,
+        action: data.action,
+        total: data.totalSize || 0,
+        transferred:
+      data.socket[data.action === 'get' ? 'bytesRead' : 'bytesWritten']
+    })
+}
+
+/**
+ * Depending on the number of parameters, returns the content of the specified
+ * file or directly saves a file into the specified destination. In the latter
+ * case, an optional callback can be provided, which will receive the error in
+ * case the operation was not successful.
+ *
+ * @param {String} remotePath File to be retrieved from the FTP server
+ * @param {Function|String} localPath Local path where we create the new file
+ * @param {Function} [callback] Gets called on either success or failure
+ */
+Ftp.prototype.get = function(remotePath, localPath, callback = NOOP) {
+    let finalCallback
+    const typeofLocalPath = typeof localPath
+
+    if (typeofLocalPath === 'function') {
+        finalCallback = localPath
+    }
+    else if (typeofLocalPath === 'string') {
+        callback = once(callback)
+        finalCallback = (err, socket) => {
+            if (err) {
+                return callback(err)
+            }
+
+            const writeStream = fs.createWriteStream(localPath)
+            writeStream.on('error', callback)
+
+            socket.on('readable', () => {
+                this.emitProgress({
+                    filename: remotePath,
+                    action: 'get',
+                    socket: socket
+                })
+            })
+
+            // This ensures that any expected outcome is handled. There is no
+            // danger of the callback being executed several times, because it is
+            // wrapped in `once`.
+            socket.on('error', callback)
+            socket.on('end', callback)
+            socket.on('close', callback)
+
+            socket.pipe(writeStream)
+        }
+    }
+
+    this.getGetSocket(remotePath, once(finalCallback))
+}
+
+/**
+ * Returns a socket for a get (RETR) on a path. The socket is ready to be
+ * streamed, but it is returned in a paused state. It is left to the user to
+ * resume it.
+ *
+ * @param {String} path Path to the file to be retrieved
+ * @param {Function} callback Function to call when finalized, with the socket
+ * as a parameter
+ */
+Ftp.prototype.getGetSocket = function(path, callback) {
+    callback = once(callback)
+    this.getPasvSocket((err, socket) => {
+        if (err) {
+            return cmdCallback(err)
+        }
+
+        socket.on('error', err => {
+            if (err.code === 'ECONNREFUSED') {
+                err.msg = 'Probably trying a PASV operation while one is in progress'
+            }
+            cmdCallback(err)
+        })
+
+        this.pasvTimeout(socket, cmdCallback)
+        socket.pause()
+
+        function cmdCallback(err, res) {
+            if (err) {
+                if (socket) {
+                    // close the socket since it won't be used
+                    socket.destroy()
+                }
+                return callback(err)
+            }
+
+            if (!socket) {
+                return callback(new Error('Error when retrieving PASV socket'))
+            }
+
+            if (res.code === 125 || res.code === 150) {
+                return callback(null, socket)
+            }
+
+            // close the socket since it won't be used
+            socket.destroy()
+
+            return callback(new Error('Unexpected command ' + res.text))
+        }
+
+        cmdCallback.expectsMark = expectedMarks
+        this.execute('retr ' + path, cmdCallback)
+    })
+}
+
+/**
+ * Uploads contents on a FTP server. The `from` parameter can be a Buffer or the
+ * path for a local file to be uploaded.
+ *
+ * @param {String|Buffer} from Contents to be uploaded.
+ * @param {String} destination path for the remote destination.
+ * @param {Function} callback Function to execute on error or success.
+ */
+Ftp.prototype.put = function(from, destination, callback) {
+    const putReadable = (from, to, totalSize) => {
+        from.on('readable', () => {
+            this.emitProgress({
+                filename: to,
+                action: 'put',
+                socket: from,
+                totalSize
+            })
+        })
+
+        this.getPutSocket(from, to, callback)
+    }
+
+    if (from instanceof Buffer) {
+        // this.getPutSocket(from, destination, callback)
+        // let self = this
+        this.getPutSocket(from, destination, (err, socket) => {
+            if (err) {
+                return callback(new Error(err))
+            }
+            let pointer = 0
+            let SLICE = 1024 * 1024
+            let done = false
+            let newBuf
+
+            newBuf = from.slice(pointer, pointer + SLICE)
+            pointer += SLICE
+            callback(null, newBuf)
+            socket.write(from.slice(0, SLICE))
+
+            //check
+            if (newBuf.length === from.length) {
+                socket.end()
+                callback(null, [])
+            }
+
+            // socket.on('error', (msg) => {
+            //     console.log('socket err', msg)
+            // })
+            // socket.on('end', (msg) => {
+            //     console.log('socket end', msg)
+            // })
+            // socket.on('close', (msg) => {
+            //     console.log('socket close', msg)
+            // })
+
+            socket.on('drain', () => {
+                console.log('drain')
+                if (from.length > pointer + SLICE) {
+                    newBuf = from.slice(pointer, pointer + SLICE)
+                    pointer += SLICE
+                }
+                else {
+                    newBuf = from.slice(pointer)
+                    done = true
+                    // console.log('done', done)
+                }
+                callback(null, newBuf)
+                socket.write(newBuf)
+
+                // self.emit('progress', {
+                //     filename: 'BUFFER',
+                //     action: 'put',
+                //     transferred: pointer,
+                //     total: from.length
+                // })
+
+                //check
+                if (done) {
+                    socket.end()
+                    callback(null, [])
+                }
+
+            })
+
+        })
+
+    }
+    else if (typeof from === 'string') {
+        fs.stat(from, (err, stats) => {
+            if (err && err.code === 'ENOENT') {
+                return callback(new Error('Local file doesn\'t exist.'))
+            }
+
+            if (stats.isDirectory()) {
+                return callback(new Error('Local path cannot be a directory'))
+            }
+
+            const totalSize = err ? 0 : stats.size
+            putReadable(fs.createReadStream(from), destination, totalSize)
+        })
+    }
+    else if (from instanceof stream.Readable) {
+        putReadable(from, destination, 0)
+    }
+    else {
+        callback(
+            new Error('Expected `from` parameter to be a Buffer, Stream, or a String')
+        )
+    }
+}
+
+Ftp.prototype.getPutSocket = function(from, path, next) {
+    next = once(next || NOOP)
+
+    this.getPasvSocket((err, socket) => {
+        if (err) {
+            if (socket) {
+                // close the socket since it won't be used
+                socket.destroy()
+            }
+            return next(err)
+        }
+
+        socket.on('close', next)
+        socket.on('error', next)
+
+        // socket.on('error', (msg) => {
+        //     console.log('s error', msg)
+        // })
+        // socket.on('end', (msg) => {
+        //     console.log('s end', msg)
+        // })
+        // socket.on('close', (msg) => {
+        //     console.log('s close', msg)
+        // })
+        // socket.on('data', (msg) => {
+        //     console.log('s data', msg)
+        // })
+
+        const callback = once((err, res) => {
+            if (err) {
+                if (socket) {
+                    // close the socket since it won't be used
+                    socket.destroy()
+                }
+                return next(err)
+            }
+
+            // Mark 150 indicates that the 'STOR' socket is ready to receive data.
+            // Anything else is not relevant.
+            if (res.code === 125 || res.code === 150) {
+                this.pasvTimeout(socket, next)
+                if (from instanceof Buffer) {
+                    next(null, socket)
+                    // socket.end(from)
+                }
+                else if (from instanceof stream.Readable) {
+                    next(null, socket)
+                    from.pipe(socket)
+                    // //resume
+                    // socket.resume()
+                }
+            }
+            else {
+                if (socket) {
+                    // close the socket since it won't be used
+                    socket.destroy()
+                }
+                return next(new Error('Unexpected command ' + res.text))
+            }
+        })
+
+        callback.expectsMark = expectedMarks
+
+        this.execute(`stor ${path}`, callback)
+    })
+}
+
+Ftp.prototype.pasvTimeout = function(socket, callback) {
+    socket.once('timeout', () => {
+        debug('PASV socket timeout')
+        this.emit('timeout')
+        socket.end()
+        callback(new Error('Passive socket timeout'))
+    })
+}
+
+Ftp.prototype.getPasvSocket = function(callback = NOOP) {
+    callback = once(callback)
+
+    this.execute('pasv', (err, res) => {
+        if (err) {
+            return callback(err)
+        }
+
+        const options = this.getPasvPort(res.text)
+        if (!options) {
+            return callback(new Error('Bad passive host/port combination'))
+        }
+
+        const socket = (this._pasvSocket = this.createSocket
+            ? this.createSocket(options)
+            : createConnection(options))
+        socket.setTimeout(this.timeout || TIMEOUT)
+        socket.once('close', () => {
+            this._pasvSocket = undefined
+        })
+
+        callback(null, socket)
+    })
+}
+
+/**
+ * Provides information about files. It lists a directory contents or
+ * a single file and yields an array of file objects. The file objects
+ * contain several properties. The main difference between this method and
+ * 'list' or 'stat' is that it returns objects with the file properties
+ * already parsed.
+ *
+ * Example of file object:
+ *
+ *  {
+ *      name: 'README.txt',
+ *      type: 0,
+ *      time: 996052680000,
+ *      size: '2582',
+ *      owner: 'sergi',
+ *      group: 'staff',
+ *      userPermissions: { read: true, write: true, exec: false },
+ *      groupPermissions: { read: true, write: false, exec: false },
+ *      otherPermissions: { read: true, write: false, exec: false }
+ *  }
+ *
+ * The constants used in the object are defined in ftpParser.js
+ *
+ * @param {String} filePath Path to the file or directory to list
+ * @param {Function} callback Function to call with the proper data when
+ * the listing is finished.
+ */
+Ftp.prototype.ls = function(filePath, callback) {
+    function entriesToList(err, entries) {
+        if (err) {
+            return callback(err)
+        }
+
+        ListingParser.parseFtpEntries(entries.text || entries, (err, files) => {
+            if (err) {
+                return callback(err)
+            }
+
+            files.forEach(file => {
+                // Normalize UTF8 doing canonical decomposition, followed by
+                // canonical Composition
+                file.name = nfc(file.name)
+            })
+            callback(null, files)
+        })
+    }
+
+    if (this.useList) {
+        this.list(filePath, entriesToList)
+    }
+    else {
+        this.raw('stat', filePath, (err, data) => {
+            // We might be connected to a server that doesn't support the
+            // 'STAT' command, which is set as default. We use 'LIST' instead,
+            // and we set the variable `useList` to true, to avoid extra round
+            // trips to the server to check.
+            const errored = err && (err.code === 502 || err.code === 500)
+            const isHummingbird =
+        this.system && this.system.indexOf('hummingbird') > -1
+            if (errored || isHummingbird) {
+                // Not sure if the 'hummingbird' system check ^^^ is still
+                // necessary. If they support any standards, the 500 error
+                // should have us covered. Let's leave it for now.
+                this.useList = true
+                this.list(filePath, entriesToList)
+            }
+            else {
+                entriesToList(err, data)
+            }
+        })
+    }
+}
+
+Ftp.prototype.rename = function(from, to, callback) {
+    this.raw('rnfr', from, err => {
+        if (err) {
+            return callback(err)
+        }
+        this.raw('rnto', to, callback)
+    })
+}
+
+Ftp.prototype.keepAlive = function(wait) {
+    if (this._keepAliveInterval) {
+        clearInterval(this._keepAliveInterval)
+    }
+
+    this._keepAliveInterval = setInterval(
+        this.raw.bind(this, 'noop'),
+        wait || IDLE_TIME
+    )
+}
+
+Ftp.prototype.destroy = function() {
+    if (this._keepAliveInterval) {
+        clearInterval(this._keepAliveInterval)
+    }
+
+    if (this.socket && this.socket.writable) {
+        this.socket.end()
+    }
+
+    if (this._pasvSocket && this._pasvSocket.writable) {
+        this._pasvSocket.end()
+    }
+
+    this.resParser.end()
+
+    this.socket = undefined
+    this._pasvSocket = undefined
+
+    this.features = null
+    this.authenticated = false
+}
+
+module.exports = Ftp