-- ***********************************************************************
--
-- Copyright 2016 by Sean Conner.
--
-- This program is free software: you can redistribute it and/or modify it
-- under the terms of the GNU General Public License as published by the
-- Free Software Foundation, either version 3 of the License, or (at your
-- option) any later version.
--
-- This program is distributed in the hope that it will be useful, but
-- WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
-- Public License for more details.
--
-- You should have received a copy of the GNU General Public License along
-- with this program.  If not, see <http://www.gnu.org/licenses/>.
--
-- Comments, questions and criticisms can be sent to: sean@conman.org
--
-- =======================================================================
--
-- Code to handle gopher requests.
--
-- ***********************************************************************
-- luacheck: globals INFO FILE DIR ERROR HTML ACL
-- luacheck: globals config blog path_okay init main
-- luacheck: globals display_page display_request display_text_file
-- luacheck: globals display_fs_object display_index_file
-- luacheck: ignore 611

local process = require "org.conman.process"
local syslog  = require "org.conman.syslog"
local fsys    = require "org.conman.fsys"
local char    = require "org.conman.parsers.ascii.char"
              + require "org.conman.parsers.utf8.char"
local lpeg    = require "lpeg"
local bible   = require "bible"
local movie   = require "movie"
local get     = require "get"
local string  = require "string"
local io      = require "io"
local table   = require "table"

local config   = config
local blog     = blog
local tostring = tostring
local ipairs   = ipairs
local pairs    = pairs
local type     = type
local pcall    = pcall
local _VERSION = _VERSION

if _VERSION == "Lua 5.1" then
  module("handler")
else
  _ENV = {}
end

-- ***********************************************************************
-- Access Control List---a list of patterns to be applied to files to
-- prevent them from being accessed.
-- ***********************************************************************

ACL =
{
  { "^%..*"     , false } ,
  { ".*%~$"     , false } ,
  { "/%.%./"    , false } ,
  { "/%."       , false } ,
  { "^build$"   , false } ,
  { "^main$"    , false } ,
  { "%.so$"     , false } ,
  { "%.o$"      , false } ,
  { "%.a$"      , false } ,
  { ".*"        , true  }
}

-- ***********************************************************************
-- Usage:       okay = handler.path_okay(acl,path)
-- Desc:        Check a filename against an ACL list
-- Input:       acl (table, see above)
--              path (string) filepath
-- Return:      okay (boolean)
-- ***********************************************************************

function path_okay(acl,path)
  for i = 1 , #acl do
    if path:match(acl[i][1]) then
      return acl[i][2]
    end
  end
  return false
end

-- ***********************************************************************
-- Usage:       link = handler.INFO(info)
-- Desc:        Return a gopher formatted INFO link (text)
-- Input:       info (table)
--                      * [1] = INFO
--                      * [2] = string, function or table
--                              | if function, it should return text
--                              | if table, an array of strings
--                              | if string, use that
-- Return:      link (string) a formatted INFO link
-- ***********************************************************************

function INFO(info)
  if type(info[2]) == 'function' then
    return INFO { INFO , info[2]() }
    
  elseif type(info[2]) == 'table' then
    local ret = ""
    for i = 1 , #info[2] do
      ret = ret .. INFO { INFO , info[2][i] }
    end
    return ret
    
  else
    return string.format("i%s\t\texample.org\t70\r\n",tostring(info[2]))
  end
end

-- ***********************************************************************
-- Usage:       link = handler.FILE(info)
-- Desc:        Return a gopher formatted FILE link
-- Input:       info (table)
--                      * [1] = FILE
--                      * [2] = label (string or function)
--                      * [3] = selector (string or function)
--                      * [4] = remotehost (string/optional)
--                      * [5] = remoteport (string/optional)
-- Return:      link (string) a formatted FILE link
-- ***********************************************************************

function FILE(info)
  local host = info[4] or config.interface.hostname
  local port = info[5] or config.interface.port
  
  if type(info[2]) == 'function' then
    info[2] = info[2]()
  end
  
  if type(info[3]) == 'function' then
    info[3] = info[3]()
  end
  
  return string.format("0%s\t%s\t%s\t%s\r\n",info[2],info[3],host,port)
end

-- ***********************************************************************
-- Usage:       link = handler.DIR(info)
-- Desc:        Return a gopher formatted DIR link
-- Input:       info (table)
--                      * [1] = DIR
--                      * [2] = label (string)
--                      * [3] = selector (string)
--                      * [4] = remotehost (string/optional)
--                      * [5] = remoteport (string/optional)
-- Return:      link (string) a formatted DIR link
-- ***********************************************************************

function DIR(info)
  local host = info[4] or config.interface.hostname
  local port = info[5] or config.interface.port
  return string.format("1%s\t%s\t%s\t%s\r\n",info[2],info[3],host,port)
end

-- ***********************************************************************
-- Usage:       link = handler.ERROR(info)
-- Desc:        Return a gopher formatted ERROR
-- Input:       info (table)
--                      * [1] = ERROR
--                      * [2] = label (string)
--                      * [3] = selector (string)
--                      * [4] = remotehost (string/optional)
--                      * [5] = remoreport (string/optional)
-- Return:      link (string) a formatted ERROR
-- ***********************************************************************

function ERROR(info)
  local host = info[4] or config.interface.hostname
  local port = info[5] or config.interface.port
  return string.format("3%s\t%s\t%s\t%s\r\n",info[2],info[3],host,port)
end

-- ***********************************************************************
-- Usage:       link = handler.HTML(info)
-- Desc:        Return a gopher formatted HTML link
-- Input:       info (table)
--                      * [1] = HTML
--                      * [2] = label (string)
--                      * [3] = selector (string)
--                      * [4] = remotehost (string/optional)
--                      * [5] = remoteport (string/optional)
-- Return:      link (string) a formatted HTML link
-- ***********************************************************************

function HTML(info)
  local host = info[4] or config.interface.hostname
  local port = info[5] or config.interface.port
  return string.format("h%s\t%s\t%s\t%s\r\n",info[2],info[3],host,port)
end

-- ***********************************************************************
-- This array of formats is passed to the blog module.
-- ***********************************************************************

local FORMATS =
{
  ['INFO']  = INFO,
  ['FILE']  = FILE,
  ['DIR']   = DIR,
  ['ERROR'] = ERROR,
  ['HTML']  = HTML,
  
  ['info']  = INFO,
  ['file']  = FILE,
  ['dir']   = DIR,
  ['error'] = ERROR,
  ['html']  = HTML
}

-- ***********************************************************************
-- The main page, an array of gopher links.  This should show more about how
-- the functions above are called.
-- ***********************************************************************

local top_page =
{
  { INFO , "Welcome to Conman Laboratories" },
  
  { INFO , "" },
  { INFO , "NOTE: RFC-1436 says this about selectors:" },
  { INFO , "" },
  { INFO , "    ... an OPAQUE selector string ...  The selector string should MEAN" },
  { INFO , "    NOTHING to the client software; it should never be modified by the" },
  { INFO , "    client." },
  { INFO , "" },
  { INFO , "(emphasis added)" },
  { INFO , "" },
  { INFO , "The selectors on this server *ARE OPAQUE* and *MUST* be sent *AS IS* to" },
  { INFO , "the server. Please note that the selectors here rarely start with a '/'" },
  { INFO , "character. Particularely, phlog entries start with a selector of" },
  { INFO , [["Phlog:"---note the lack of '/' and the ending ':'.]] },
  { INFO , "" },
  { INFO , "Thank you." },
  { INFO , "  -- The Management" },
  
  { INFO , "" },
  { FILE , "About the server"                  , "About:Server" } ,
  { FILE , "About the author"                  , "About:Me"     } ,
  { DIR  , "Gopher Server Source Code"         , "Gopher:Src:"  } ,
  { DIR  , "Boston source code"                , "Boston:Src:"  } ,
  { DIR  , "CGILib source code"                , "CGI:Src:"     } ,
  { DIR  , "The Boston Diaries Phlog Feed"     , "phlog.gopher" } ,
  { DIR  , "The Boston Diaries Phlog Archives" , "Phlog:"       } ,
  { FILE , "Latest Phlog Post"                 , blog.last_link } ,
  { DIR  , "The Electric King James Bible"     , "Bible:"       } ,
  { DIR  , "The Quick and Dirty B-Movie Plot Generator" , "Movie:" } ,
  
  { INFO , "" } ,
  { DIR  , "Other Gopher Servers"       , "/world" , "gopher.floodgap.com" , 70 } ,
  { DIR  , "Phlog aggregator"           , "/bongusta/" , "i-logout.cz"  , 70 } ,
  { DIR  , "Another Phlog aggregator"   , "/moku-pona"    , "gopher.black" , 70 } ,
  { DIR  , "Lobste.rs mirror"           , "/users/julienxx/Lobste.rs"      , "sdf.org" , 70 } ,
  { DIR  , "jstg gopher"                , "/users/jstg/"  , "sdf.org"      , 70 } ,
  { DIR  , "phlogs"                     , "/phlogs/"      , "sdf.org"      , 70 } ,
  { DIR  , "some stuff"                 , ""              , "sdf.org"      , 70 } ,
  { INFO , "" } ,
  { INFO , "Wisdom of the day:" } ,
  { INFO , function()
             local res = {}
             local q   = io.popen(config.quotes,"r")
             if q ~= nil then
               for line in q:lines() do
                 table.insert(res,line)
               end
               q:close()
             else
               table.insert(res,"A witty saying goes here")
               table.insert(res,"               -- Anon")
             end
             return res
           end },
  { FILE , "robots.txt-because we can" , "/robots.txt" } ,
}

-- ***********************************************************************
-- Usage:       handler.display_page(page)
-- Desc:        Construct a gopher page
-- Input:       page (array of links) - see example of top_page
-- ***********************************************************************

function display_page(page)
  local size = 0
  
  for _,line in ipairs(page) do
    local t = line[1](line)
    size = size + #t
    io.stdout:write(line[1](line))
  end

  io.stdout:write(".\r\n")
  return size + 3
end

-- ***********************************************************************
-- Usage:       handler.display_request(selector,request)
-- Desc:        Take a request and handle it
-- Input:       selector (table) (see below for an example)
--              request (string) gopher request
-- ***********************************************************************

function display_request(selector,request)
  for regex,code in pairs(selector) do
    local pattern = request:match(regex)
    if pattern then
      return code(pattern)
    end
  end
  
  syslog('error',"%q not found",request)
  local err = ERROR { ERROR , "Not found" , request }
  io.stdout:write(err,".\r\n")
  return #err + 3
end

-- ***********************************************************************
-- Usage:	handler.display_index_file(fname)
-- Desc:	Display a gopher index file via gopher
-- Input:	fname (string) filename
-- ***********************************************************************

local parsetype = lpeg.P"\t"
                * lpeg.C(char^0) * lpeg.P"\t" -- type
                * lpeg.C(char^0) * lpeg.P"\t" -- display
                * lpeg.C(char^0)              -- selector

function display_index_file(fname)
  local page = {}
  for line in io.lines(fname) do
    if line == "" or line:match("^[^%c]") then
      table.insert(page, { INFO , line })
    else
      local ftype,display,selector = parsetype:match(line)
      table.insert(page , { FORMATS[ftype] , display , selector })
    end
  end
  
  return display_page(page)
end

-- ***********************************************************************
-- Usage:       handler.display_text_file(fname)
-- Desc:        Display a text file via gopher
-- Input:       fname (string) filename
-- ***********************************************************************

function display_text_file(fname)
  local size = 0
  
  for line in io.lines(fname) do
    if line:match("^%.") then
      io.stdout:write(".")
      size = size + 1
    end
    io.stdout:write(line,"\r\n")
    size = size + #line + 2
  end

  return size
end

-- ***********************************************************************
-- Usage:       handler.display_fs_object(acl,selector,req,path)
-- Desc:        Display a directory listing of files (path, then files)
-- Input:       acl (table) ACL list
--              selector (string) base gopher selector
--              req (string) directory from gopher request
--              path (string) absolute directory
-- ***********************************************************************

function display_fs_object(acl,selector,req,path)
  if not path_okay(acl,req) then
    local err = ERROR { ERROR , "Not found" , req }
    io.stdout:write(err, ".\r\n")
    return #err + 3
  end
  
  local info = fsys.stat(path)
  if info == nil then
    local err = ERROR { ERROR , "Not found" , req }
    io.stdout:write(err, ".\r\n")
    return #err + 3
  end
  
  if info.mode.type == 'file' then
    return display_text_file(path)
  elseif info.mode.type ~= 'dir' then
    local err = ERROR { ERROR , "Not found" , req }
    io.stdout:write(err,".\r\n")
    return #err + 3
  end
  
  local directories = {}
  local files       = {}
  
  for file in fsys.dir(path) do
    if path_okay(acl,file) then
      info = fsys.stat(path .. "/" .. file)
      
      if info.mode.type == 'file' then
        table.insert(files,file)
      elseif info.mode.type == 'dir' then
        table.insert(directories,file)
      end
    end
  end
  
  table.sort(directories)
  table.sort(files)
  
  if req ~= "" then
    req = req .. "/"
  end
  
  local size = 0
  
  for i = 1 , #directories do
    local dir = DIR { DIR , directories[i] , selector .. req .. directories[i] }
    io.stdout:write(dir)
    size = size + #dir
  end
  
  for i = 1 , #files do
    local file = FILE { FILE , files[i] , selector .. req .. files[i] }
    io.stdout:write(file)
    size = size + #file
  end
  
  io.stdout:write(".\r\n")
  return size + 3
end

-- ***********************************************************************
-- This table maps request selectors to functions to handle them.  The keys
-- are patterns the request is matched against---first match wins, so order
-- accordingly.
-- ***********************************************************************

local selectors =
{
  ['^/robots%.txt$'] = function()
    io.stdout:write("User-agent: *\r\nDisallow:\r\n")
    return 26
  end,
  
  ['^robots%.txt$'] = function()
    io.stdout:write("User-agent: *\r\nDisallow:\r\n")
    return 26
  end,
  
  ['^/phlog.gopher$'] = function()
    return display_text_file(config.files .. "/phlog.gopher")
  end,
  
  ['^phlog.gopher$'] = function()
    return display_text_file(config.files .. "/phlog.gopher")
  end,
  
  ['^caps%.txt$'] = function()
    return display_text_file(config.files .. "/caps.txt")
  end,
  
  ['^/caps%.txt$'] = function()
    return display_text_file(config.files .. "/caps.txt")
  end,
  
  ['^About%:Server$'] = function()
    return display_text_file(config.files .. "/about-server.txt")
  end,
  
  ['^About%:Me$'] = function()
    return display_text_file(config.files .. "/about-me.txt")
  end,
  
  ['^Boston%:Src%:(.*)'] = function(req)
    return display_fs_object(
      ACL,
      "Boston:Src:",
      req,
      "/home/spc/source/boston/" .. req
    )
  end,
  
  ['^CGI%:Src%:(.*)'] = function(req)
    return display_fs_object(
      ACL,
      "CGI:Src:",
      req,
      "/home/spc/source/cgi/" .. req
    )
  end,
  
  ['^Phlog%:?(.*)'] = function(req)
    local size
    local data,text = blog.display(FORMATS,req)
    if not data then
      return 0
    elseif type(data) == 'table' then
      return display_page(blog.display(FORMATS,req))
    elseif type(data) == 'string' then
      io.stdout:write(data)
      return #data
    elseif io.type(data) == 'file' then
      if text then
        size = 0
        for line in data:lines() do
          io.stdout:write(line,"\r\n")
          size = size + #line + 2
        end
      else
        local pic = data:read("*a")
        size      = #pic
        io.stdout:write(pic)
      end
      data:close()
      return size
    else
      local data = tostring(data) -- luacheck: ignore
      io.stdout:write(data)
      return #data
    end
  end,
  
  ['^Gopher%:Src%:(.*)'] = function(req)
    return display_fs_object(ACL,"Gopher:Src:",req,"/home/spc/source/gopher-blog/" .. req)
  end,
  
  ['^Bible%:(.*)'] = function(req)
    if req == "" then
      return display_index_file(config.files .. "/electric-king-james.index")
    else
      return bible.handle(req)
    end
  end,
  
  ['^Movie%:(.*)'] = function(req)
    return movie.handler(req)
  end,
  
  ['^GET%s+.*']      = get.handler,
  ['^HEAD%s+.*']     = get.handler,
  ['^POST%s+.*']     = get.handler,
  ['^PUT%s+.*']      = get.handler,
  ['^DELETE%s+.*']   = get.handler,
  ['^CONNECT%s+.*']  = get.handler,
  ['^OPTIONS%s+.*']  = get.handler,
  ['^TRACE%s+.*']    = get.handler,
  ['^BREW%s+.*']     = get.handler, -- RFC-2324, in case people get cute
  ['^PROPFIND%s+.*'] = get.handler,
  ['^WHEN%s+.*']     = get.handler,
}

-- ***********************************************************************
-- Usage:       handler.main(remote)
-- Desc:        Main gopher request handler
-- Input:       remote (userdata/address) remote address
-- Note:        This does not return, but exits the process
-- ***********************************************************************

function main(remote)
  local request = io.stdin:read("*l")
  if request then
    request = request:gsub("\013","")
  else
    io.stdout:write(ERROR { ERROR , "Bad request" , "" },"\r\n")
    process.exit(0)
  end
  local okay
  local size
  
  if request == "" or request == "/" then
    okay,size = pcall(display_page,top_page)
  else
    okay,size = pcall(display_request,selectors,request)
  end
  
  if not okay then
    syslog('error',"host=%s request=%q err=%q",remote.addr,request,size)
  else
    syslog('info',"host=%s request=%q size=%d",remote.addr,request,size)
  end
  process.exit(0)
end

-- ***********************************************************************
-- Usage:       handler.init()
-- Desc:        Initialize the handler module.
-- ***********************************************************************

function init()
  if config.interface.port == 70 then
    config.url = string.format(
        "gopher://%s/",
        config.interface.hostname
    )
  else
    config.url = string.format(
        "gopher://%s:%d/",
        config.interface.hostname,
        config.interface.port
    )
  end
end

-- ***********************************************************************

if _VERSION >= "Lua 5.2" then
  return _ENV
end
.