Merge pull request #3 from mailsvb/handlers

add downloadHandler

Author: mailsvb

lib/jsftpd.js

@@ -35,7 +35,8 @@ const FTPdefaults = {
     allowAnonymousFolderCreate: false,
     allowAnonymousLogin: false,
     minDataPort: 1024,
-    uploadHandler: null
+    uploadHandler: null,
+    downloadHandler: null
 }
 
 const UserDefaults = {
@@ -572,37 +573,47 @@ class ftpd {
                 file = path.join(basefolder, relativePath, relativeFile)
             }
             if (fs.existsSync(file) === true && fs.statSync(file).isFile() === true && main._beginsWith(basefolder, file) === true) {
-                dataObj.method = function (obj) {
+                dataObj.method = async function (obj) {
                     if (obj.dataSocket && obj.cmdSocket && obj.file && obj.relativeFile) {
-                        const streamOpts = {
-                            flags: 'r',
-                            start: retrOffset,
-                            encoding: asciiOn ? 'ascii' : null,
-                            autoClose: true,
-                            emitClose: true
-                        }
-                        retrOffset = 0
                         asciiOn && obj.dataSocket.setEncoding('ascii')
-                        const stream = fs.createReadStream(obj.file, streamOpts)
-                        stream.on('error', main.ErrorHandler)
-                        stream.on('open', () => {
-                            obj.dataSocket.on('close', () => {
-                                if (!obj.dataSocket.destroyed) {
-                                    stream.destroy()
-                                    main._writeToSocket(obj.cmdSocket, '426', ' ', `Connection closed. Aborted transfer of "${obj.relativeFile}"`, connectionInfo, SocketStateAfterWrite.Open)
-                                }
-                            })
-                            stream.pipe(obj.dataSocket)
-                        })
-                        stream.on('end', () => {
+                        if (obj.handler) {
+                            const data = await obj.handler(username, relativePath, obj.fileName, retrOffset)
+                            retrOffset = 0
+                            obj.dataSocket.write(data)
                             obj.dataSocket.end()
                             main._writeToSocket(obj.cmdSocket, '226', ' ', `Successfully transferred "${obj.relativeFile}"`, connectionInfo, SocketStateAfterWrite.Open)
-                        })
+                        } else {
+                            const streamOpts = {
+                                flags: 'r',
+                                start: retrOffset,
+                                encoding: asciiOn ? 'ascii' : null,
+                                autoClose: true,
+                                emitClose: true
+                            }
+                            retrOffset = 0
+                            const stream = fs.createReadStream(obj.file, streamOpts)
+                            stream.on('error', main.ErrorHandler)
+                            stream.on('open', () => {
+                                obj.dataSocket.on('close', () => {
+                                    if (!obj.dataSocket.destroyed) {
+                                        stream.destroy()
+                                        main._writeToSocket(obj.cmdSocket, '426', ' ', `Connection closed. Aborted transfer of "${obj.relativeFile}"`, connectionInfo, SocketStateAfterWrite.Open)
+                                    }
+                                })
+                                stream.pipe(obj.dataSocket)
+                            })
+                            stream.on('end', () => {
+                                obj.dataSocket.end()
+                                main._writeToSocket(obj.cmdSocket, '226', ' ', `Successfully transferred "${obj.relativeFile}"`, connectionInfo, SocketStateAfterWrite.Open)
+                            })
+                        }
                     }
                 }
                 dataObj.cmdSocket = socket
                 dataObj.file = file
+                dataObj.fileName = path.basename(file)
                 dataObj.relativeFile = relativeFile
+                dataObj.handler = main._opt.cnf.downloadHandler
                 openDataChannel(dataObj)
             } else {
                 main._writeToSocket(socket, '550', ' ', 'File not found', connectionInfo, SocketStateAfterWrite.Open)
@@ -654,8 +665,8 @@ class ftpd {
                         if (obj.handler) {
                             const data = []
                             obj.dataSocket.on('data', (d) => data.push(d))
-                            obj.dataSocket.on('close', () => {
-                                obj.handler(relativePath, obj.fileName, Buffer.concat(data))
+                            obj.dataSocket.on('close', async () => {
+                                await obj.handler(username, relativePath, obj.fileName, Buffer.concat(data), obj.retrOffset)
                                 main._writeToSocket(obj.cmdSocket, '226', ' ', `Successfully transferred "${obj.relativeFile}"`, connectionInfo, SocketStateAfterWrite.Open)
                             })
                         } else if (obj.stream) {
@@ -668,6 +679,8 @@ class ftpd {
                     }
                 }
                 if (dataObj.handler) {
+                    dataObj.retrOffset = retrOffset
+                    retrOffset = 0
                     openDataChannel(dataObj)
                 } else {
                     const streamOpts = {

test/jsftpd.test.js

@@ -13,9 +13,11 @@ const formatPort = (addr, port) => {
 }
 
 afterEach(() => {
-    server.stop()
-    server.cleanup()
-    server = null
+    if (server) {
+        server.stop()
+        server.cleanup()
+        server = null
+    }
 });
 
 test('create ftpd instance without options created with default values', () => {
@@ -46,6 +48,32 @@ test('ftp server can be started on non default ports', () => {
     expect(server._tls.address().port).toBe(50990)
 });
 
+test('ftp server fails when basefolder does not exist', () => {
+    try {
+        server = new ftpd({cnf: {basefolder: '/NOTEXISTING'}})
+    } catch(err) {
+        expect(err.message).toMatch('Basefolder must exist')
+    }
+});
+
+test('error message when not logged in', async () => {
+    server = new ftpd({cnf: {port: 50021}})
+    expect(server).toBeInstanceOf(ftpd);
+    server.start()
+
+    const promiseSocket = new PromiseSocket(new net.Socket())
+    const socket = promiseSocket.stream
+    let content
+    await socket.connect(50021, 'localhost')
+    content = await promiseSocket.read();
+    expect(content.toString().trim()).toBe('220 Welcome')
+    await promiseSocket.write('REST 0')
+    content = await promiseSocket.read();
+    expect(content.toString().trim()).toBe('530 Not logged in')
+
+    await promiseSocket.end()
+});
+
 test('login as anonymous not allowed by default', async () => {
     server = new ftpd({cnf: {port: 50021}})
     expect(server).toBeInstanceOf(ftpd);
@@ -1051,10 +1079,12 @@ test('test STOR message with handler', async () => {
             allowLoginWithoutPassword: true,
         }
     ]
-    const handler = (path, filename, data) => {
+    const handler = async (username, path, filename, data, offset) => {
+        expect(username).toMatch('john')
         expect(filename).toMatch('mytestfile')
         expect(path).toMatch('/')
         expect(data.toString()).toMatch('SOMETESTCONTENT')
+        expect(offset).toBe(0)
     }
     server = new ftpd({cnf: {uploadHandler: handler, port: 50021, user: users}})
     expect(server).toBeInstanceOf(ftpd);
@@ -1162,6 +1192,78 @@ test('test RETR message', async () => {
     await promiseSocket.end()
 });
 
+test('test RETR message with handler', async () => {
+    const users = [
+        {
+            username: 'john',
+            allowLoginWithoutPassword: true,
+        }
+    ]
+    const handler = async (username, path, filename, offset) => {
+        expect(username).toMatch('john')
+        expect(filename).toMatch('mytestfile')
+        expect(path).toMatch('/')
+        expect(offset).toBe(0)
+        return 'SOMETESTCONTENT'
+    }
+    server = new ftpd({cnf: {downloadHandler: handler, port: 50021, user: users}})
+    expect(server).toBeInstanceOf(ftpd);
+    server.start()
+
+    let content
+
+    let promiseSocket = new PromiseSocket(new net.Socket())
+    let socket = promiseSocket.stream
+    await socket.connect(50021, 'localhost')
+    content = await promiseSocket.read();
+    expect(content.toString().trim()).toBe('220 Welcome')
+
+    await promiseSocket.write('USER john')
+    content = await promiseSocket.read();
+    expect(content.toString().trim()).toBe('232 User logged in')
+
+    await promiseSocket.write('EPSV')
+    content = await promiseSocket.read();
+    expect(content.toString().trim()).toBe('229 Entering extended passive mode (|||1024|)')
+
+    let promiseDataSocket = new PromiseSocket(new net.Socket())
+    let dataSocket = promiseDataSocket.stream
+    await dataSocket.connect(1024, 'localhost')
+
+    await promiseSocket.write('STOR mytestfile')
+    content = await promiseSocket.read();
+    expect(content.toString().trim()).toBe('150 Opening data channel')
+
+    await promiseDataSocket.write('SOMETESTCONTENT');
+    dataSocket.end()
+    await promiseDataSocket.end()
+
+    content = await promiseSocket.read();
+    expect(content.toString().trim()).toBe('226 Successfully transferred "mytestfile"')
+
+    await promiseSocket.write('EPSV')
+    content = await promiseSocket.read();
+    expect(content.toString().trim()).toBe('229 Entering extended passive mode (|||1024|)')
+
+    promiseDataSocket = new PromiseSocket(new net.Socket())
+    dataSocket = promiseDataSocket.stream
+    await dataSocket.connect(1024, 'localhost')
+
+    await promiseSocket.write('RETR /someotherfile')
+    content = await promiseSocket.read();
+    expect(content.toString().trim()).toBe('550 File not found')
+
+    await promiseSocket.write('RETR mytestfile')
+    // content = await promiseSocket.read();
+    // expect(content.toString().trim()).toBe('150 Opening data channel')
+
+    content = await promiseDataSocket.read();
+    expect(content.toString().trim()).toMatch('SOMETESTCONTENT')
+    await promiseDataSocket.end()
+
+    await promiseSocket.end()
+});
+
 test('test MFMT message', async () => {
     const users = [
         {