ftp.lua

local component = require("component")

if not component.isAvailable("internet") then
  io.stderr:write("OpenFTP requires an Internet Card to run!\n")
  return
end

local internet = require("internet")
local computer = require("computer")
local unicode = require("unicode")
local shell = require("shell")
local event = require("event")
local term = require("term")
local text = require("text")
local fs = require("filesystem")
local inetc = component.internet
local gpu = component.gpu

-- Variables -------------------------------------------------------------------

local isColored, isVerbose
local args, options

local sock, host, port, timer
local w = gpu.getResolution()

print("Term width: " .. tostring(w))

local history = {}
local commands = {}

local chsize = 102400
local isRunning = true

-- Functions -------------------------------------------------------------------

local function setFG(fg)
  if isColored then
    gpu.setForeground(fg)
  end
end

local function nop() end

local function help()
  print("Usage: ftp [--colors=<always|never|auto>] <host> [port]")
  print()
  print("Options: ")
  print("  --colors=<always|never|auto>  Specify whether to use color or not.")

  os.exit(0)
end

local function init(...)
  args, options = shell.parse(...)

  local oColors = options["colors"] or "auto"
  oColors = (oColors == "always" or oColors == "never") and oColors or "auto"

  if oColors == "always" then
    isColored = true
  elseif oColors == "never" then
    isColored = false
  elseif oColors == "auto" then
    isColored = gpu.getDepth() > 1
  end

  isVerbose = options["verbose"] == true
  host, port = args[1] or nil, args[2] or 21

  if #args < 1 then help() end
end

local function connect()
  local lSock, reason = internet.open(host .. ":" .. port)
  if not lSock then
    io.stderr:write(("ftp: %s: %s\n"):format(host .. ":" .. port,
                                             reason or "unknown error"))
    os.exit(1)
    return
  end

  sock = lSock
  sock:setTimeout(0.2)
end

local function lost()
  setFG(0xFF0000)
  print("Connection lost.")
  setFG(0xFFFFFF)
  sock:close()
  os.exit(0)
end

local function readLine()
  local ok, line = pcall(sock.read, sock)
  if ok and line == "" then lost() end

  return ok and line or false
end

local function readToEnd(f)
  local was = false
  local lastRet
  repeat
    local line = readLine()
    if line then
      lastRet = f(line)
      was = true
    end
  until not line and was
  return was, lastRet
end

local function parseOutput(str)
  local match = {str:match("^(%d%d%d)([ -])(.*)$")}

  if #match < 1 then return false end

  local code = tonumber(match[1])
  local codeColor do
    if code >= 100 and code < 200 then
      codeColor = 0x0000FF
    elseif code >= 200 and code < 300 then
      codeColor = 0x00FF00
    elseif code >= 300 and code < 400 then
      codeColor = 0xFFFF00
    else
      codeColor = 0xFF0000
    end
  end
  local isLast = match[2] == " "
  local text = match[3]

  return {
    code = code,
    codeColor = codeColor,
    isLast = isLast,
    text = text
  }
end

local function traceLine(data)
  setFG(data.codeColor)
  io.write(data.code)
  setFG(0x666999)
  io.write(data.isLast and " " or "-")
  setFG(0xFFFFFF)
  io.write(data.text .. "\n")
end

local function trace(str)
  local data = parseOutput(str)
  if data then
    traceLine(data)
    return data
  else
    print(str)
  end
end

local function exit()
  event.cancel(timer)

  if sock then
    sock:write("QUIT\r\n")
    sock:flush()
    readToEnd(trace, true)
    sock:close()
  end

  setFG(0xFFFFFF)

  os.exit(0)
end

local function auth()
  timer = event.timer(1, function ()
    if isRunning and sock.stream.socket.finishConnect() then
      exit()
    end
  end, math.huge)

  local got = false
  while true do
    local user repeat
      io.write("Name: ")
      user = term.read()
      if not user then
        print()
      end
    until user and #user > 0
    sock:write("USER " .. user .. "\r\n")
    sock:flush()

    local got = false

    readToEnd(function (str)
      local data = trace(str)
      got = data and data.code == 331 and data.isLast
    end)

    if got then break end
  end

  io.write("Password: ")
  pass = term.read(nil, nil, nil, "*"):sub(1, -2)
  if not pass then
    print()
  end
  sock:write("PASS " .. (pass or "") .. "\r\n")
  sock:flush()

  local logined = false

  while true do
    local was = readToEnd(function (str)
      local data = trace(str)
      logined = data and data.code == 230 and data.isLast
    end)
    if was then break end
  end

  if not logined then
    exit()
  end

  print("Using binary mode to transfer files.")
  sock:write("TYPE I\r\n")
  sock:flush()
  readToEnd(nop)
end

local function pasv()
  sock:write("PASV\r\n")
  local ip, port

  local was, ret = readToEnd(function (str)
    local data = trace(str)
    if data and data.code == 227 and data.isLast then
      local match = {data.text:match("(%d+),(%d+),(%d+),(%d+),(%d+),(%d+)")}
      if match then
        ip = table.concat({match[1], match[2], match[3], match[4]}, ".")
        port = tonumber(match[5]) * 256 + tonumber(match[6])
      end
    end
  end)

  if not ip or not port then
    return false
  end

  return inetc.connect(ip, port)
end

local function readPasv(pasvSock, f)
  os.sleep(0.2)

  local buf = {}
  local bufLen = 0
  local written = false

  while true do
    local chunk = pasvSock.read(chsize)

    if bufLen >= chsize and written then
      buf = {}
      bufLen = 0
    end

    if chunk then
      table.insert(buf, chunk)
      bufLen = bufLen + #chunk
      written = false
    end

    if not written and (bufLen >= chsize or not chunk) then
      f(table.concat(buf), bufLen)
      written = true
    end

    if not chunk and written then break end
  end

  pasvSock.close()
end

local function writePasv(pasvSock, f)
  repeat
    local chunk, len = f()
    if chunk then
      len = len or 0
      local written = 0
      repeat
        written = written + pasvSock.write(chunk)
      until written >= len
    end
  until not chunk

  pasvSock.write("")
  pasvSock.close()

  os.sleep(0.2)
end

local function handleInput(str)
  str = text.trim(str)

  if str:sub(1, 1) == "!" then
    if str:sub(2, -1)  == "" then
      shell.execute("sh")
    else
      shell.execute(str:sub(2, -1))
    end

    return
  end

  local cmd, args do
    local tokens = text.tokenize(str)
    if #tokens < 1 then return end

    cmd = tokens[1]
    table.remove(tokens, 1)
    args = tokens
  end

  if commands[cmd] then
    commands[cmd](args)
  else
    setFG(0xFF0000)
    print("Invalid command.")
    setFG(0xFFFFFF)
  end
end

local function main()
  connect()
  auth()

  repeat
    setFG(0x999999)
    io.write("ftp> ")
    setFG(0xFFFFFF)
    local input = term.read(history)

    if input and text.trim(input) ~= "" then
      handleInput(input)

      if input:sub(1, 1) ~= " " then
        table.insert(history, input)
      end
    end
  until not input
  print()

  isRunning = false
end

local progress do
  local units = {"B", "k", "M", "G", "T"}
  local chars = {[0] = ""}
  for i = 0x258f, 0x2588, -1 do
    table.insert(chars, unicode.char(i))
  end

  print(require("serialization").serialize(chars))

  local function formatFSize(fsize)
    local result = ""
    if fsize < 10e3 then
      result = ("%.4f"):format(fsize):sub(1,5)
      result = result .. (" "):rep(6 - #result) .. units[1]
    elseif fsize < 10e13 then
      local digits = #("%d"):format(fsize)
      local unit = units[math.floor((digits - 1) / 3) + 1]
      result = ("%.13f"):format(fsize / (10 ^ (math.floor((digits - 1) / 3) * 3))):sub(1, 5)
      result = result .. (" "):rep(6 - #result) .. unit
    else
      result = ("%.1e"):format(fsize)
    end
    return result
  end

  function progress(fgot, ftotal, tstart, width)
    local perc = 0
    if tonumber(tostring(fgot / ftotal)) then
      perc = fgot / ftotal * 100
      if perc > 100 then
        perc = 100
      end
    else
      error("The programmer has derped! fgot = 0, ftotal = 0, perc = -nan, undefined behaviour!")
    end
    local pstr = ("%.2f"):format(perc)

    local delta = computer.uptime() - tstart
    local perperc = delta / perc
    local t = (100 - perc) * perperc
    local time = "n/a"
    local cspeed = ""
    if tonumber(tostring(t)) then
      cspeed = tonumber(tostring(fgot / delta))
      cspeed = cspeed and (formatFSize(cspeed) .. "/s") or "n/a"
      local days = math.floor(t / 86400)
      t = t - days * 86400
      local hours = math.floor(t / 3600)
      t = t - hours * 3600
      local minutes = math.floor(t / 60)
      local seconds = t - minutes * 60
      time = ("%02d"):format(seconds)
      time = ("%02d"):format(minutes) .. ":" .. time
      if hours ~= 0 or days ~= 0 then
        time = ("%02d"):format(hours) .. ":" .. time
      end
      if days ~= 0 then
        time = tostring(days) .. "d, " .. time
      end
    end

    local lpart = formatFSize(fgot) .. " / " .. formatFSize(ftotal) .. "▕"
    local rpart = chars[1] .. (" "):rep(6 - #pstr) .. pstr .. "% " .. cspeed .. " -- " .. time
    local pwidth = width - unicode.len(lpart) - unicode.len(rpart)

    local cwidth = pwidth / 100
    local fr = tonumber(select(2, math.modf(perc * cwidth)))
    local lastblockindex = math.floor(fr * 8)
    if lastblockindex == 8 then
      lastblockindex = 7
    end
    local lastblock = chars[lastblockindex]
    local blocks = math.floor(perc * cwidth)

    local result = lpart .. chars[8]:rep(blocks) .. lastblock
    result = result .. (" "):rep(width - unicode.len(result) - unicode.len(rpart)) .. rpart
    return result
  end
end

-- Сommands --------------------------------------------------------------------

function commands.quit()
  exit()
end

function commands.pwd()
  sock:write("PWD\r\n")
  sock:flush()
  readToEnd(trace)
end

function commands.system()
  sock:write("SYST\r\n")
  sock:flush()
  readToEnd(trace)
end

function commands.nop()
  sock:write("NOOP\r\n")
  sock:flush()
  readToEnd(trace)
end

commands[".."] = function ()
  sock:write("CDUP\r\n")
  sock:flush()
  readToEnd(trace)
end

function commands.size(args)
  if #args < 1 then
    print("Usage: size <file>")
    return
  end

  sock:write("SIZE " .. args[1] .. "\r\n")
  sock:flush()
  readToEnd(trace)
end

function commands.help(args)
  sock:write("HELP\r\n")
  sock:flush()
  readToEnd(trace)
end

function commands.stat()
  sock:write("STAT\r\n")
  sock:flush()
  readToEnd(trace)
end

function commands.binary()
  sock:write("TYPE I\r\n")
  sock:flush()
  readToEnd(trace)
end

function commands.ascii()
  sock:write("TYPE A\r\n")
  sock:flush()
  readToEnd(trace)
end

function commands.cd(args)
  if #args < 1 then
    print("Usage: cd <dir>")
    return
  end

  sock:write("CWD " .. args[1] .. "\r\n")
  sock:flush()
  readToEnd(trace)
end

function commands.ls(args)
  local pasvSock = pasv()
  if not pasvSock then
    return
  end

  full = false
  for _, arg in ipairs(args) do
    if arg:sub(1, 1) == "-" then
      full = not not arg:match("l")
    end
  end

  sock:write(full and "LIST\r\n" or "NLST\r\n")
  sock:flush()
  readToEnd(function (str)
    local data = trace(str)
    if data and data.code == 150 and data.isLast then
      readPasv(pasvSock, function (str) print(str) end)
    end
  end)
end

function commands.raw(args)
  sock:write(table.concat(args, " ") .. "\r\n")
  sock:flush()
  os.sleep(0.5)
  readToEnd(trace, true)
end

function commands.get(args)
  if #args < 1 then
    print("Usage: get <file> [local-path]")
    return
  end

  local file, reason = io.open(args[2] or args[1], "w")

  if not file then
    setFG(0xFF0000)
    print("Error opening file for writing: "
          .. tostring(reason or "unknown error"))
    setFG(0x000000)
    return
  end

  local pasvSock = pasv()
  if not pasvSock then
    return
  end

  sock:write("RETR " .. args[1] .. "\r\n")
  sock:flush()
  readToEnd(function (str)
    local data = trace(str)
    if data and data.code == 150 and data.isLast then
      local start = computer.uptime()
      local size = data.text:match("(%d+)%s+bytes")
      size = tonumber(size)
      local show = size and size > 0
      local now = 0

      readPasv(pasvSock, function (chunk, len)
        file:write(chunk)
        if show then
          now = now + len
          term.clearLine()
          io.write(progress(now, size, start, w))
        end
      end)

      if show then
        print()
      end

      file:flush()
      file:close()
    end
  end)
end

function commands.put(args)
  if #args < 1 then
    print("Usage: put <local-path> [file]")
    return
  end

  local file, reason = io.open(args[1], "rb")

  if not file then
    setFG(0xFF0000)
    print("Error opening file for reading: "
          .. tostring(reason or "unknown error"))
    setFG(0x000000)
    return
  end

  local pasvSock = pasv()
  if not pasvSock then
    return
  end

  sock:write("STOR " .. (args[2] or args[1]) .. "\r\n")
  sock:flush()
  readToEnd(function (str)
    local data = trace(str)
    if data and data.code == 150 and data.isLast then
      os.sleep(0.3)

      local start = computer.uptime()
      local size = fs.size(os.getenv("PWD") .. "/" .. args[1])
      local now = 0

      writePasv(pasvSock, function ()
        local chunk = file:read(chsize)
        if not chunk then
          return
        end

        local len = #chunk

        now = now + len
        term.clearLine()
        io.write(progress(now, size, start, w))

        return chunk, len
      end)

      print()

      file:close()
    end
  end)
end


-- Main ------------------------------------------------------------------------

init(...)
main()
exit()