httpd

#!/usr/libexec/flua
-- vim: set et:
-- Minimal web server written in Lua
--
-- Use with inetd, no other dependencies:
-- http    stream  tcp     nowait  root    /usr/local/sbin/httpd      httpd

--
-- Copyright (c) 2016 - 2020 Ryan Moeller <ryan@freqlabs.com>
--
-- Permission to use, copy, modify, and distribute this software for any
-- purpose with or without fee is hereby granted, provided that the above
-- copyright notice and this permission notice appear in all copies.
--
-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

local SRC_DIR = "/home/yang/src/lua-httpd/"

package.path = SRC_DIR .. "?.lua;" .. package.path

local httpd = require("httpd")
local template = require("template")

local boot = require("boot")
local db = require("db")
local disk = require("disk")
local filesystem = require("filesystem")
local hardening = require("hardening")
local keymap = require("keymap")
local lang = require("lang")
local network = require("network")
local pkgsets = require("pkgsets")
local partition = require("partition")
local service = require("service")
local shell = require("shell")

local json = require("json")
local misc = require("misc")

--local manifest = "/usr/local/share/freebsd/MANIFESTS/amd64-amd64-13.0-RELEASE"
local manifest = SRC_DIR .. "MANIFEST"

local stylesheet_file = assert(io.open(SRC_DIR .. "style.css", "r"))
local stylesheet = stylesheet_file:read("*all")
stylesheet_file:close()

local main_page_file = assert(io.open(SRC_DIR .. "main_page.html", "r"))
local main_page = main_page_file:read("*all")
main_page_file:close()

local add_user_file= assert(io.open(SRC_DIR .. "add_user.html", "r"))
local add_user_page = add_user_file:read("*all")
add_user_file:close()

local network_file = assert(io.open(SRC_DIR .. "network.html", "r"))
local network_page = network_file:read("*all")
network_file:close()

local keymap_file = assert(io.open(SRC_DIR .. "keymap.html", "r"))
local keymap_page = keymap_file:read("*all")
keymap_file:close()

local zfs_file = assert(io.open(SRC_DIR .. "zfs.html", "r"))
local zfs_page = zfs_file:read("*all")
zfs_file:close()

local language_file = assert(io.open(SRC_DIR .. "lang.html", "r"))
local language_page = language_file:read("*all")
language_file:close()

function pairsByKeys(t, f)
        local a = {}
        for n in pairs(t) do table.insert(a, n) end
        table.sort(a, f)
        local i = 0 -- iterator variable
        local iter = function() -- iterator function
                i = i + 1
                if a[i] == nil then return nil
                else return a[i], t[a[i]]
                end
        end
        return iter
end

function selected(cond)
        return cond and "selected" or ""
end

function checked(cond)
        return cond and "checked" or ""
end

function readonly(cond)
        return cond and "readonly" or ""
end

function wireless(cond)
        return cond and "[Wireless]" or "[Wired]"
end

function disabled(cond)
        return cond and "disabled" or ""
end

function orEmpty(string)
        if (string) then
                return string
        else
                return ""
        end
       -- return string and string or ""
end

function orWheel(string)
        if (string) then
                return string
        else
                return "wheel"
        end
       -- return string and string or ""
end

--TODO: properly credit
function unescape (str)
        str = string.gsub (str, "+", " ")
        str = string.gsub (str, "%%(%x%x)", function(h) return string.char(tonumber(h,16)) end)
        return str
end

function splitString(str, char)
        local split_list = {}

        for match in str:gmatch("[^" .. char .. "]+") do
                table.insert(split_list, match)
        end
        return split_list
end

function parseRequest(body)
        local lines = splitString(body, "&")
        local req = {}

        for i, line in ipairs(lines) do
                local mapping = unescape(line)
                local key, val = mapping:match("^([^=]+)=(.*)")

                --requests could possibly have multiple vals per key.
                --Since I know that these will always be for inputs
                --that will never have space in them (currently: disks)
                --I'll just space-separate them.
                if (type(req[key]) == "string") then
                       req[key] = req[key].." "..val
                else
                        req[key] = val
                end
        end

        return req
end

function getStylesheet()
        return { status=200, reason="ok", body=stylesheet }
end

function prefillDB()
        db.updateIfUnset("installer_language", "en")
        db.updateIfUnset("keymap_layout", keymap.getCurrentLayout())
        db.updateIfUnset("keymap_variant", keymap.getCurrentVariant())
        db.updateIfUnset("hostname", "freebsd")
        db.updateIfUnset("packages", "base kernel") --TODO make this depend on data in package.lua
end

function getSelectedDisks(parsed_db)
        local db_disks = parsed_db.zfs_disks or ""
        local selected_disk_list = misc.splitString(db_disks, " ")

        local selected_disks = {}
        for _, disk in ipairs(selected_disk_list) do
                selected_disks[disk] = true
        end

        return selected_disks
end

function mainPage(request)

        prefillDB()

        local parsed_db = db.parse()

        local cur_lang = parsed_db.installer_language
        local keymap_layout = parsed_db.keymap_layout
        local keymap_variant = parsed_db.keymap_variant

        local selected_packages_list = misc.splitString(parsed_db.packages, " ")
        local selected_packages = {}
        for _, package in ipairs(selected_packages_list) do
                selected_packages[package] = true
        end


        local installReady = (parsed_db.network and parsed_db.zfs_disks) --TODO: make this check smarter

        local body = template.process(main_page,
                {
                boothowto = boot.howto(),
                bootmethod = boot.method(),
                cur_lang = cur_lang,
                disks = disk.info(),
                filesystem_formats = filesystem.formats,
                hardening_menu = hardening.menu,
                keymap_string = keymap.prettyPrint(keymap_layout, keymap_variant),
                lang = lang.translations,
                network_string = parsed_db.network,
                packages = pkgsets.pkgsets,
                partition_styles = partition.styles,
                ready = installReady,
                shells = shell.list,
                selected_disks = getSelectedDisks(parsed_db),
                selected_packages = selected_packages,
                service_menu = service.menu,
                users = db.getUsersAsList(parsed_db),
        })
        return { status=200, reason="ok", body=body }
end

function writePackages(request) --TODO make 'packages' 'pkgsets' naming more consistent
        local req = json.decode(request.body)
        db.update("packages", table.concat(req, " "))
        return { status=200, reason="ok", body="TODO"}
end

function languagePage(request)
        local parsed_db = db.parse()
        local cur_lang = parsed_db.installer_language

        local body = template.process(language_page,
        {
                cur_lang = cur_lang,
                lang = lang.translations,
                languages = lang.languages,
        })

        return { status=200, reason="ok", body=body }
end

function zfsPage(request)
        local parsed_db = db.parse()
        local selected_filesystem = parsed_db.zfs_filesystem or "stripe"
        local cur_lang = parsed_db.installer_language

        local body = template.process(zfs_page,
        {
                cur_lang = cur_lang,
                disks = disk.info(),
                filesystem_formats = filesystem.zfs_formats,
                lang = lang.translations,
                selected_disks = getSelectedDisks(parsed_db),
                selected_filesystem = selected_filesystem,
        })

        return { status=200, reason="ok", body = body }
end

function writeZFS(request)
        local req = parseRequest(request.body)

        local disks = req.disk

        db.update("zfs_filesystem", req.filesystem)
        db.update("zfs_disks", disks)

        return { status=303, headers = {["Location"]="/"}, reason="ok", body = "TODO" }
end

function setLanguage(request)
        local req = parseRequest(request.body)

        db.update("installer_language", req.language)

        --TODO: set more defaults based on language selection
        local keymap_layout = lang.languages[req.language].keymap_layout
        local keymap_variant = lang.languages[req.language].keymap_variant

        local parsed_db = db.parse()

        if (not parsed_db.keymap_layout or parsed_db.keymap_layout == "") then
                keymap.setKeymap(keymap_layout, keymap_variant)
                db.update("keymap_layout", keymap_layout)
                db.update("keymap_variant", keymap_variant)
        end

        return { status=303, headers = {["Location"]="/"}, reason="ok", body = "TODO" }
end

function keymapPage(request)
        local parsed_db = db.parse()
        local selected_layout = parsed_db.keymap_layout
        local selected_variant = parsed_db.keymap_variant
        local variants = keymap.XMap[selected_layout] or {}
        local cur_lang = parsed_db.installer_language

        local body = template.process(keymap_page,
        {
                cur_lang = cur_lang,
                lang = lang.translations,
                selected_layout = selected_layout,
                selected_variant = selected_variant,
                x_list = keymap.XList,
                x_variants = variants,
        })

        return { status=200, reason="ok", body = body }
end

function getVariants(request)
        local variants = keymap.XMap[request.matches[1]]
        return { status=200, reason="ok", body=json.encode(variants)}
end

function setKeymap(request)
        local map = json.decode(request.body)

        keymap.setKeymap(map.layout, map.variant)

        return { status=200, reason="ok", body = map.layout}
end

function writeKeymap(request)
        local req = parseRequest(request.body)
        db.update("keymap_layout", req.keymap)
        db.update("keymap_variant", req.variant)
        
        return { status=303, headers = {["Location"]="/"}, reason="ok", body = "TODO" }
end

function addUserPage(request)
        local parsed_db = db.parse()
        local cur_lang = parsed_db.installer_language

        local body = template.process(add_user_page,
        {
                cur_lang = cur_lang,
                lang = lang.translations,
                shells = shell.list,
        })

        return { status=200, reason="ok", body = body }
end

function editUserPage(request)
        local parsed_db = db.parse()
        local cur_lang = parsed_db.installer_language

        local username = request.matches[1]

        local user_data = db.parse().users[username]

        local body = template.process(add_user_page,
        {
                cur_lang = cur_lang,
                editing = true,
                full_name = user_data.full_name,
                groups = user_data.groups,
                lang = lang.translations,
                shells = shell.list,
                username = username,
                user_shell = user_data.shell,
        })

        return { status=200, reason="ok", body = body }
end

function addUser(request)
        local req = parseRequest(request.body)

        --TODO verify input

        db.update("user:"..req.username..":full_name", req.full_name)
        db.update("user:"..req.username..":password", req.password)
        db.update("user:"..req.username..":groups", req.groups)
        db.update("user:"..req.username..":shell", req.shell)

        return { status=303, headers = {["Location"]="/#users"}, reason="ok", body = "TODO" }
end

function deleteUser(request)
        local username = request.matches[1]

        --TODO verify input

        db.removeMatches("^user:"..username..":")

        return { status=303, headers = {["Location"]="/#users"}, reason="ok", body = "TODO" }
end

function networkPage(request)
        local parsed_db = db.parse()
        local cur_lang = parsed_db.installer_language

        local body = template.process(network_page,
        {
                cur_lang = cur_lang,
                lang = lang.translations,
                network_interfaces = network.getInterfaces(),
        })

        return { status=200, reason="ok", body = body }
end

function checkIsWireless(request)
        local isWireless = network.isWireless(request.matches[1])
        return {status=200, reason="ok", body=json.encode(isWireless)}
end

function getNetworkStatus(request)
        local status = network.status()
        return { status=200, reason="ok", body=status}
end

function scanWireless(request)
        local networks = network.scanWireless()
        return { status=200, reason="ok", body=json.encode(networks)}
end

function connectToNetwork(request)
        local req = json.decode(request.body)

        network.connectWireless(req.network, req.password)

        return { status=200, reason="ok", body = "okay"}
end

function writeNetwork(request)
        local req = json.decode(request.body)

        db.update("network_interface", req.network_interface)
        db.update("network", req.network)
        db.update("network_password", req.password)

        local resolv_file = io.open("/etc/resolv.conf", "r")
        while (resolv_file == nil) do --TODO: there must be a better way to do this
                os.execute("sleep 1")
                resolv_file = io.open("/etc/resolv.conf", "r")
        end

        for line in resolv_file:lines() do
                local key, val = line:match("^([^ ]+) (.*)")
                if (key == "search") then
                        db.update("resolv_search", val)
                elseif (key == "nameserver") then
                        db.update("resolv_nameserver", val)
                end
        end

        resolv_file:close()

        return { status=303, headers = {["Location"]="/"}, reason="ok", body = "TODO" }
end

function doInstall(request)
        local req = parseRequest(request.body)
        for key, val in pairs(req) do
                print(key, val)
        end

        db.update("hostname", req.hostname)
        db.update("root_password", req.root_password)
        db.update("packages", req.packages)

        db.close()
        --For testing, I don't run the actual install command. Check the 'liveuser' branch

        return { status=501, reason="Not implemented", body="TODO" }
end

local server = httpd.create_server("/var/log/httpd.log")

server:add_route("GET", "^/style$", getStylesheet)

--Fetch API stuff
server:add_route("GET", "^/keymap/variants/(.*)$", getVariants)
server:add_route("GET", "^/network/iswireless/(.*)$", checkIsWireless)
server:add_route("GET", "^/scanwireless$", scanWireless)
server:add_route("GET", "^/networkstatus$", getNetworkStatus)
server:add_route("POST", "^/setkeymap$", setKeymap)
server:add_route("POST", "^/network$", connectToNetwork)
server:add_route("POST", "^/networkconfirm$", writeNetwork)
server:add_route("POST", "^/pkgsets$", writePackages)

--Pages
server:add_route("GET", "^/language$", languagePage)
server:add_route("GET", "^/zfs$", zfsPage)
server:add_route("GET", "^/adduser$", addUserPage)
server:add_route("GET", "^/edituser/(.*)$", editUserPage)
server:add_route("GET", "^/network$", networkPage)
server:add_route("GET", "^/keymap$", keymapPage)
server:add_route("GET", "^/$", mainPage)

server:add_route("POST", "^/zfs$", writeZFS)
server:add_route("POST", "^/setlanguage", setLanguage)
server:add_route("POST", "^/install$", doInstall)
server:add_route("POST", "^/adduser$", addUser)
server:add_route("POST", "^/deleteuser/(.*)$", deleteUser)
server:add_route("POST", "^/writekeymap$", writeKeymap)

server:run(true)