--[[ A simple ftp server
This is my implementation of a FTP server using Github user Neronix's
example as inspriration, but as a cleaner Lua implementation that has been
optimised for use in LFS. The coding style adopted here is more similar to
best practice for normal (PC) module implementations, as using LFS enables
me to bias towards clarity of coding over brevity. It includes extra logic
to handle some of the edge case issues more robustly. It also uses a
standard forward reference coding pattern to allow the code to be laid out
in main routine, subroutine order.
The app will only call one FTP.open() or FTP.createServer() at any time,
with any multiple calls requected, so FTP is a singleton static object.
However there is nothing to stop multiple clients connecting to the FTP
listener at the same time, and indeed some FTP clients do use multiple
connections, so this server can accept and create multiple CON objects.
Each CON object can also have a single DATA connection.
Note that FTP also exposes a number of really private properties (which
could be stores in local / upvals) as FTP properties for debug purposes.
]]
local file,net,wifi,node,string,table,tmr,pairs,print,pcall, tostring =
file,net,wifi,node,string,table,tmr,pairs,print,pcall, tostring
local post = node.task.post
local FTP, cnt = {client = {}}, 0
-- Local functions
local processCommand -- function(cxt, sock, data)
local processBareCmds -- function(cxt, cmd)
local processSimpleCmds -- function(cxt, cmd, arg)
local processDataCmds -- function(cxt, cmd, arg)
local dataServer -- function(cxt, n)
local ftpDataOpen -- function(dataSocket)
-- Note these routines all used hoisted locals such as table and debug as
-- upvals for performance (ROTable lookup is slow on NodeMCU Lua), but
-- data upvals (e.g. FTP) are explicitly list is -- "upval:" comments.
-- Note that the space between debug and the arglist is there for a reason
-- so that a simple global edit " debug(" -> "-- debug(" or v.v. to
-- toggle debug compiled into the module.
local function debug (fmt, ...) -- upval: cnt (, print, node, tmr)
if not FTP.debug then return end
if (...) then fmt = fmt:format(...) end
print(node.heap(),fmt)
cnt = cnt + 1
if cnt % 10 then tmr.wdclr() end
end
--------------------------- Set up the FTP object ----------------------------
-- FTP has three static methods: open, createServer and close
------------------------------------------------------------------------------
-- optional wrapper around createServer() which also starts the wifi session
function FTP.open(user, pass, ssid, pwd, dbgFlag) -- upval: FTP (, wifi, tmr, print)
if ssid then
wifi.setmode(wifi.STATION, false)
wifi.sta.config { ssid = ssid, pwd = pwd, save = false }
end
local t = tmr.create()
t:alarm(500, tmr.ALARM_AUTO, function()
if (wifi.sta.status() == wifi.STA_GOTIP) then
t:unregister()
t=nil
print("Welcome to NodeMCU world", node.heap(), wifi.sta.getip())
return FTP.createServer(user, pass, dbgFlag)
else
uart.write(0,".")
end
end)
end
function FTP.createServer(user, pass, dbgFlag) -- upval: FTP (, debug, tostring, pcall, type, processCommand)
FTP.user, FTP.pass, FTP.debug = user, pass, dbgFlag
FTP.server = net.createServer(net.TCP, 180)
_G.FTP = FTP
debug("Server created: (userdata) %s", tostring(FTP.server))
FTP.server:listen(21, function(sock) -- upval: FTP (, debug, pcall, type, processCommand)
-- since a server can have multiple connections, each connection
-- has a CNX table to store connection-wide globals.
local client = FTP.client
local CNX; CNX = {
validUser = false,
cmdSocket = sock,
send = function(rec, cb) -- upval: CNX (,debug)
-- debug("Sending: %s", rec)
return CNX.cmdSocket:send(rec.."\r\n", cb)
end, --- send()
close = function(sock) -- upval: client, CNX (,debug, pcall, type)
-- debug("Closing CNX.socket=%s, sock=%s", tostring(CNX.socket), tostring(sock))
for _,s in ipairs{'cmdSocket', 'dataServer', 'dataSocket'} do
local sck; sck,CNX[s] = CNX[s], nil
-- debug("closing CNX.%s=%s", s, tostring(sck))
if type(sck)=='userdata' then pcall(sck.close, sck) end
end
client[sock] = nil
end -- CNX.close()
}
local function validateUser(sock, data) -- upval: CNX, FTP (, debug, processCommand)
-- validate the logon and if then switch to processing commands
-- debug("Authorising: %s", data)
local cmd, arg = data:match('([A-Za-z]+) *([^\r\n]*)')
local msg = "530 Not logged in, authorization required"
cmd = cmd:upper()
if cmd == 'USER' then
CNX.validUser = (arg == FTP.user)
msg = CNX.validUser and
"331 OK. Password required" or
"530 user not found"
elseif CNX.validUser and cmd == 'PASS' then
if arg == FTP.pass then
CNX.cwd = '/'
sock:on("receive", function(sock,data)
processCommand(CNX,sock,data)
end) -- logged on so switch to command mode
msg = "230 Login successful. Username & password correct; proceed."
else
msg = "530 Try again"
end
elseif cmd == 'AUTH' then
msg = "500 AUTH not understood"
end
return CNX.send(msg)
end
local port,ip = sock:getpeer()
-- debug("Connection accepted: (userdata) %s client %s:%u", tostring(sock), ip, port)
sock:on("receive", validateUser)
sock:on("disconnection", CNX.close)
FTP.client[sock]=CNX
CNX.send("220 FTP server ready");
end) -- FTP.server:listen()
end -- FTP.createServer()
function FTP.close() -- upval: FTP (, debug, post, tostring)
local svr = FTP.server
local function rollupClients(client, server) -- upval: FTP (,debug, post, tostring, rollupClients)
-- this is done recursively so that we only close one client per task
local skt,cxt = next(client)
if skt then
-- debug("Client close: %s", tostring(skt))
cxt.close(skt)
post(function() return rollupClients(client, server) end) -- upval: rollupClients, client, server
else
-- debug("Server close: %s", tostring(server))
server:close()
server:__gc()
FTP,_G.FTP = nil, nil -- the upval FTP can only be zeroed once FTP.client is cleared.
end
end
if svr then rollupClients(FTP.client, svr) end
package.loaded.ftpserver=nil
end -- FTP.close()
----------------------------- Process Command --------------------------------
-- This splits the valid commands into one of three categories:
-- * bare commands (which take no arg)
-- * simple commands (which take) a single arg; and
-- * data commands which initiate data transfer to or from the client and
-- hence need to use CBs.
--
-- Find strings are used do this lookup and minimise long if chains.
------------------------------------------------------------------------------
processCommand = function(cxt, sock, data) -- upvals: (, debug, processBareCmds, processSimpleCmds, processDataCmds)
debug("Command: %s", data)
data = data:gsub('[\r\n]+$', '') -- chomp trailing CRLF
local cmd, arg = data:match('([a-zA-Z]+) *(.*)')
cmd = cmd:upper()
local _cmd_ = '_'..cmd..'_'
if ('_CDUP_NOOP_PASV_PWD_QUIT_SYST_'):find(_cmd_) then
processBareCmds(cxt, cmd)
elseif ('_CWD_DELE_MODE_PORT_RNFR_RNTO_SIZE_TYPE_'):find(_cmd_) then
processSimpleCmds(cxt, cmd, arg)
elseif ('_LIST_NLST_RETR_STOR_'):find(_cmd_) then
processDataCmds(cxt, cmd, arg)
else
cxt.send("500 Unknown error")
end
end -- processCommand(sock, data)
-------------------------- Process Bare Commands -----------------------------
processBareCmds = function(cxt, cmd) -- upval: (dataServer)
local send = cxt.send
if cmd == 'CDUP' then
return send("250 OK. Current directory is "..cxt.cwd)
elseif cmd == 'NOOP' then
return send("200 OK")
elseif cmd == 'PASV' then
-- This FTP implementation ONLY supports PASV mode, and the passive port
-- listener is opened on receipt of the PASV command. If any data xfer
-- commands return an error if the PASV command hasn't been received.
-- Note the listener service is closed on receipt of the next PASV or
-- quit.
local ip, port, pphi, pplo, i1, i2, i3, i4, _
_,ip = cxt.cmdSocket:getaddr()
port = 2121
pplo = port % 256
pphi = (port-pplo)/256
i1,i2,i3,i4 = ip:match("(%d+).(%d+).(%d+).(%d+)")
dataServer(cxt, port)
return send(
('227 Entering Passive Mode(%d,%d,%d,%d,%d,%d)'):format(
i1,i2,i3,i4,pphi,pplo))
elseif cmd == 'PWD' then
return send('257 "/" is the current directory')
elseif cmd == 'QUIT' then
send("221 Goodbye", function() cxt.close(cxt.cmdSocket) end)
return
elseif cmd == 'SYST' then
-- return send("215 UNKNOWN")
return send("215 UNIX Type: L8") -- must be Unix so ls is parsed correctly
else
error('Oops. Missed '..cmd)
end
end -- processBareCmds(cmd, send)
------------------------- Process Simple Commands ----------------------------
local from -- needs to persist between simple commands
processSimpleCmds = function(cxt, cmd, arg) -- upval: from (, file, tostring, dataServer, debug)
local send = cxt.send
if cmd == 'MODE' then
return send(arg == "S" and "200 S OK" or
"504 Only S(tream) is suported")
elseif cmd == 'PORT' then
dataServer(cxt,nil) -- clear down any PASV setting
return send("502 Active mode not supported. PORT not implemented")
elseif cmd == 'TYPE' then
if arg == "A" then
cxt.xferType = 0
return send("200 TYPE is now ASII")
elseif arg == "I" then
cxt.xferType = 1
return send("200 TYPE is now 8-bit binary")
else
return send("504 Unknown TYPE")
end
end
-- The remaining commands take a filename as an arg. Strip off leading / and ./
arg = arg:gsub('^%.?/',''):gsub('^%.?/','')
debug("Filename is %s",arg)
if cmd == 'CWD' then
if arg:match('^[%./]*$') then
return send("250 CWD command successful")
end
return send("550 "..arg..": No such file or directory")
elseif cmd == 'DELE' then
if file.exists(arg) then
file.remove(arg)
if not file.exists(arg) then return send("250 Deleted "..arg) end
end
return send("550 Requested action not taken")
elseif cmd == 'RNFR' then
from = arg
send("350 RNFR accepted")
return
elseif cmd == 'RNTO' then
local status = from and file.rename(from, arg)
-- debug("rename('%s','%s')=%s", tostring(from), tostring(arg), tostring(status))
from = nil
return send(status and "250 File renamed" or
"550 Requested action not taken")
elseif cmd == "SIZE" then
local st = file.stat(arg)
return send(st and ("213 "..st.size) or
"550 Could not get file size.")
else
error('Oops. Missed '..cmd)
end
end -- processSimpleCmds(cmd, arg, send)
-------------------------- Process Data Commands -----------------------------
processDataCmds = function(cxt, cmd, arg) -- upval: FTP (, pairs, file, tostring, debug, post)
local send = cxt.send
-- The data commands are only accepted if a PORT command is in scope
if cxt.dataServer == nil and cxt.dataSocket == nil then
return send("502 Active mode not supported. "..cmd.." not implemented")
end
cxt.getData, cxt.setData = nil, nil
arg = arg:gsub('^%.?/',''):gsub('^%.?/','')
if cmd == "LIST" or cmd == "NLST" then
-- There are
local fileSize, nameList, pattern = file.list(), {}, '.'
arg = arg:gsub('^-[a-z]* *', '') -- ignore any Unix style command parameters
arg = arg:gsub('^/','') -- ignore any leading /
if #arg > 0 and arg ~= '.' then -- replace "*" by [^/%.]* that is any string not including / or .
pattern = arg:gsub('*','[^/%%.]*')
end
for k,v in pairs(fileSize) do
if k:match(pattern) then
nameList[#nameList+1] = k
else
fileSize[k] = nil
end
end
table.sort(nameList)
function cxt.getData() -- upval: cmd, fileSize, nameList (, table)
local list, user, v = {}, FTP.user
for i = 1,10 do
if #nameList == 0 then break end
local f = table.remove(nameList, 1)
list[#list+1] = (cmd == "LIST") and
("-rw-r--r-- 1 %s %s %6u Jan 1 00:00 %s\r\n"):format(user, user, fileSize[f], f) or
(f.."\r\n")
end
return table.concat(list)
end
elseif cmd == "RETR" then
local f = file.open(arg, "r")
if f then -- define a getter to read the file
function cxt.getData() -- upval: f
local buf = f:read(1024)
if not buf then f:close(); f = nil; end
return buf
end -- cxt.getData()
end
elseif cmd == "STOR" then
local f = file.open(arg, "w")
if f then -- define a setter to write the file
function cxt.setData(rec) -- upval f, arg (, debug)
-- debug("writing %u bytes to %s", #rec, arg)
return f:write(rec)
end -- cxt.saveData(rec)
function cxt.fileClose() -- upval cxt, f, arg (,debug)
-- debug("closing %s", arg)
f:close(); cxt.fileClose, f = nil, nil
end -- cxt.close()
end
end
send((cxt.getData or cxt.setData) and "150 Accepted data connection" or
"451 Can't open/create "..arg)
if cxt.getData and cxt.dataSocket then
debug ("poking sender to initiate first xfer")
post(function() cxt.sender(cxt.dataSocket) end)
end
end -- processDataCmds(cmd, arg, send)
----------------------------- Data Port Routines -----------------------------
-- These are used to manage the data transfer over the data port. This is
-- set up lazily either by a PASV or by the first LIST NLST RETR or STOR
-- command that uses it. These also provide a sendData / receiveData cb to
-- handle the actual xfer. Also note that the sending process can be primed in
--
---------------- Open a new data server and port ---------------------------
dataServer = function(cxt, n) -- upval: (pcall, net, ftpDataOpen, debug, tostring)
local dataServer = cxt.dataServer
if dataServer then -- close any existing listener
pcall(dataServer.close, dataServer)
end
if n then
-- Open a new listener if needed. Note that this is only used to establish
-- a single connection, so ftpDataOpen closes the server socket
cxt.dataServer = net.createServer(net.TCP, 300)
cxt.dataServer:listen(n, function(sock) -- upval: cxt, (ftpDataOpen)
ftpDataOpen(cxt,sock)
end)
-- debug("Listening on Data port %u, server %s",n, tostring(cxt.dataServer))
else
cxt.dataServer = nil
-- debug("Stopped listening on Data port",n)
end
end -- dataServer(n)
----------------------- Connection on FTP data port ------------------------
ftpDataOpen = function(cxt, dataSocket) -- upval: (debug, tostring, post, pcall)
local sport,sip = dataSocket:getaddr()
local cport,cip = dataSocket:getpeer()
debug("Opened data socket %s from %s:%u to %s:%u", tostring(dataSocket),sip,sport,cip,cport )
cxt.dataSocket = dataSocket
cxt.dataServer:close()
cxt.dataServer = nil
local function cleardown(skt,type) -- upval: cxt (, debug, tostring, post, pcall)
type = type==1 and "disconnection" or "reconnection"
local which = cxt.setData and "setData" or (cxt.getData and cxt.getData or "neither")
-- debug("Cleardown entered from %s with %s", type, which)
if cxt.setData then
cxt.fileClose()
cxt.setData = nil
cxt.send("226 Transfer complete.")
else
cxt.getData, cxt.sender = nil, nil
end
-- debug("Clearing down data socket %s", tostring(skt))
post(function() -- upval: skt, cxt, (, pcall)
pcall(skt.close, skt); skt=nil
cxt.dataSocket = nil
end)
end
local on_hold = false
dataSocket:on("receive", function(skt, rec) --upval: cxt, on_hold (, debug, tstring, post, node, pcall)
local which = cxt.setData and "setData" or (cxt.getData and cxt.getData or "neither")
-- debug("Received %u data bytes with %s", #rec, which)
if not cxt.setData then return end
if not on_hold then
-- Cludge to stop the client flooding the ESP SPIFFS on an upload of a
-- large file. As soon as a record arrives assert a flow control hold.
-- This can take up to 5 packets to come into effect at which point the
-- low priority unhold task is executed releasing the flow again.
-- debug("Issuing hold on data socket %s", tostring(skt))
skt:hold(); on_hold = true
post(node.task.LOW_PRIORITY,
function() -- upval: skt, on_hold (, debug, tostring))
-- debug("Issuing unhold on data socket %s", tostring(skt))
pcall(skt.unhold, skt); on_hold = false
end)
end
if not cxt.setData(rec) then
-- debug("Error writing to SPIFFS")
cxt.fileClose()
cxt.setData = nil
cxt.send("552 Upload aborted. Exceeded storage allocation")
end
end)
function cxt.sender(skt) -- upval: cxt (, debug)
debug ("entering sender")
if not cxt.getData then return end
local rec, skt = cxt.getData(), cxt.dataSocket
if rec and #rec > 0 then
-- debug("Sending %u data bytes", #rec)
skt:send(rec)
else
-- debug("Send of data completed")
skt:close()
cxt.send("226 Transfer complete.")
cxt.getData, cxt.dataSocket = nil, nil
end
end
dataSocket:on("sent", cxt.sender)
dataSocket:on("disconnection", function(skt) return cleardown(skt,1) end)
dataSocket:on("reconnection", function(skt) return cleardown(skt,2) end)
-- if we are sending to client then kick off the first send
if cxt.getData then cxt.sender(cxt.dataSocket) end
end -- ftpDataOpen(socket)
------------------------------------------------ -----------------------------
return FTP