summaryrefslogtreecommitdiffhomepage
path: root/libs/lucid/luasrc
diff options
context:
space:
mode:
authorJo-Philipp Wich <jow@openwrt.org>2014-06-11 12:37:19 +0000
committerJo-Philipp Wich <jow@openwrt.org>2014-06-11 12:37:19 +0000
commit91b97bc9f625d09431dc1c753209a037d7c42fbc (patch)
tree428230e6d8f0d7ac47dcccebabccd09667d58ea5 /libs/lucid/luasrc
parent2d05a6135a0d29a82148f9bfc215b2de5b609dd5 (diff)
Remove unmaintained components: lucid, fastindex, niu
Diffstat (limited to 'libs/lucid/luasrc')
-rw-r--r--libs/lucid/luasrc/lucid.lua348
-rw-r--r--libs/lucid/luasrc/lucid/tcpserver.lua254
2 files changed, 0 insertions, 602 deletions
diff --git a/libs/lucid/luasrc/lucid.lua b/libs/lucid/luasrc/lucid.lua
deleted file mode 100644
index 38b34fde9..000000000
--- a/libs/lucid/luasrc/lucid.lua
+++ /dev/null
@@ -1,348 +0,0 @@
---[[
-LuCI - Lua Development Framework
-
-Copyright 2009 Steven Barth <steven@midlink.org>
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-$Id$
-]]
-
-local nixio = require "nixio"
-local table = require "table"
-local uci = require "luci.model.uci"
-local os = require "os"
-local io = require "io"
-
-local pairs, require, pcall, assert, type = pairs, require, pcall, assert, type
-local ipairs, tonumber, collectgarbage = ipairs, tonumber, collectgarbage
-
-
-module "luci.lucid"
-
-local slaves = {}
-local pollt = {}
-local tickt = {}
-local tpids = {}
-local tcount = 0
-local ifaddrs = nixio.getifaddrs()
-
-cursor = uci.cursor()
-state = uci.cursor_state()
-UCINAME = "lucid"
-
-local cursor = cursor
-local state = state
-local UCINAME = UCINAME
-local SSTATE = "/tmp/.lucid_store"
-
-
---- Starts a new LuCId superprocess.
-function start()
- state:revert(UCINAME, "main")
-
- prepare()
-
- local detach = cursor:get(UCINAME, "main", "daemonize")
- if detach == "1" then
- local stat, code, msg = daemonize()
- if not stat then
- nixio.syslog("crit", "Unable to detach process: " .. msg .. "\n")
- ox.exit(2)
- end
- end
-
- state:set(UCINAME, "main", "pid", nixio.getpid())
- state:save(UCINAME)
-
- run()
-end
-
---- Returns the PID of the currently active LuCId process.
-function running()
- local pid = tonumber(state:get(UCINAME, "main", "pid"))
- return pid and nixio.kill(pid, 0) and pid
-end
-
---- Stops any running LuCId superprocess.
-function stop()
- local pid = tonumber(state:get(UCINAME, "main", "pid"))
- if pid then
- return nixio.kill(pid, nixio.const.SIGTERM)
- end
- return false
-end
-
---- Prepares the slaves, daemons and publishers, allocate resources.
-function prepare()
- local debug = tonumber((cursor:get(UCINAME, "main", "debug")))
-
- nixio.openlog("lucid", "pid", "perror")
- if debug ~= 1 then
- nixio.setlogmask("warning")
- end
-
- cursor:foreach(UCINAME, "daemon", function(config)
- if config.enabled ~= "1" then
- return
- end
-
- local key = config[".name"]
- if not config.slave then
- nixio.syslog("crit", "Daemon "..key.." is missing a slave\n")
- os.exit(1)
- else
- nixio.syslog("info", "Initializing daemon " .. key)
- end
-
- state:revert(UCINAME, key)
-
- local daemon, code, err = prepare_daemon(config)
- if daemon then
- state:set(UCINAME, key, "status", "started")
- nixio.syslog("info", "Prepared daemon " .. key)
- else
- state:set(UCINAME, key, "status", "error")
- state:set(UCINAME, key, "error", err)
- nixio.syslog("err", "Failed to initialize daemon "..key..": "..
- err .. "\n")
- end
- end)
-end
-
---- Run the superprocess if prepared before.
--- This main function of LuCId will wait for events on given file descriptors.
-function run()
- local pollint = tonumber((cursor:get(UCINAME, "main", "pollinterval")))
- local threadlimit = tonumber((cursor:get(UCINAME, "main", "threadlimit")))
-
- while true do
- local stat, code = nixio.poll(pollt, pollint)
-
- if stat and stat > 0 then
- local ok = false
- for _, polle in ipairs(pollt) do
- if polle.revents ~= 0 and polle.handler then
- ok = ok or polle.handler(polle)
- end
- end
- if not ok then
- -- Avoid high CPU usage if thread limit is reached
- nixio.nanosleep(0, 100000000)
- end
- elseif stat == 0 then
- ifaddrs = nixio.getifaddrs()
- end
-
- for _, cb in ipairs(tickt) do
- cb()
- end
-
- local pid, stat, code = nixio.wait(-1, "nohang")
- while pid and pid > 0 do
- nixio.syslog("info", "Buried thread: " .. pid)
- if tpids[pid] then
- tcount = tcount - 1
- if tpids[pid] ~= true then
- tpids[pid](pid, stat, code)
- end
- tpids[pid] = nil
- end
- pid, stat, code = nixio.wait(-1, "nohang")
- end
- end
-end
-
---- Add a file descriptor for the main loop and associate handler functions.
--- @param polle Table containing: {fd = FILE DESCRIPTOR, events = POLL EVENTS,
--- handler = EVENT HANDLER CALLBACK}
--- @see unregister_pollfd
--- @return boolean status
-function register_pollfd(polle)
- pollt[#pollt+1] = polle
- return true
-end
-
---- Unregister a file desciptor and associate handler from the main loop.
--- @param polle Poll descriptor
--- @see register_pollfd
--- @return boolean status
-function unregister_pollfd(polle)
- for k, v in ipairs(pollt) do
- if v == polle then
- table.remove(pollt, k)
- return true
- end
- end
- return false
-end
-
---- Close all registered file descriptors from main loop.
--- This is useful for forked child processes.
-function close_pollfds()
- for k, v in ipairs(pollt) do
- if v.fd and v.fd.close then
- v.fd:close()
- end
- end
-end
-
---- Register a tick function that will be called at each cycle of the main loop.
--- @param cb Callback
--- @see unregister_tick
--- @return boolean status
-function register_tick(cb)
- tickt[#tickt+1] = cb
- return true
-end
-
---- Unregister a tick function from the main loop.
--- @param cb Callback
--- @see register_tick
--- @return boolean status
-function unregister_tick(cb)
- for k, v in ipairs(tickt) do
- if v == cb then
- table.remove(tickt, k)
- return true
- end
- end
- return false
-end
-
---- Tests whether a given number of processes can be created.
--- @oaram num Processes to be created
--- @return boolean status
-function try_process(num)
- local threadlimit = tonumber((cursor:get(UCINAME, "main", "threadlimit")))
- return not threadlimit or (threadlimit - tcount) >= (num or 1)
-end
-
---- Create a new child process from a Lua function and assign a destructor.
--- @param threadcb main function of the new process
--- @param waitcb destructor callback
--- @return process identifier or nil, error code, error message
-function create_process(threadcb, waitcb)
- local threadlimit = tonumber(cursor:get(UCINAME, "main", "threadlimit"))
- if threadlimit and tcount >= threadlimit then
- nixio.syslog("warning", "Cannot create thread: process limit reached")
- return nil
- else
- collectgarbage("collect")
- end
- local pid, code, err = nixio.fork()
- if pid and pid ~= 0 then
- nixio.syslog("info", "Created thread: " .. pid)
- tpids[pid] = waitcb or true
- tcount = tcount + 1
- elseif pid == 0 then
- local code = threadcb()
- os.exit(code)
- else
- nixio.syslog("err", "Unable to fork(): " .. err)
- end
- return pid, code, err
-end
-
---- Prepare a daemon from a given configuration table.
--- @param config Configuration data.
--- @return boolean status or nil, error code, error message
-function prepare_daemon(config)
- nixio.syslog("info", "Preparing daemon " .. config[".name"])
- local modname = cursor:get(UCINAME, config.slave)
- if not modname then
- return nil, -1, "invalid slave"
- end
-
- local stat, module = pcall(require, _NAME .. "." .. modname)
- if not stat or not module.prepare_daemon then
- return nil, -2, "slave type not supported"
- end
-
- config.slave = prepare_slave(config.slave)
-
- return module.prepare_daemon(config, _M)
-end
-
---- Prepare a slave.
--- @param name slave name
--- @return table containing slave module and configuration or nil, error message
-function prepare_slave(name)
- local slave = slaves[name]
- if not slave then
- local config = cursor:get_all(UCINAME, name)
-
- local stat, module = pcall(require, config and config.entrypoint)
- if stat then
- slave = {module = module, config = config}
- end
- end
-
- if slave then
- return slave
- else
- return nil, module
- end
-end
-
---- Return a list of available network interfaces on the host.
--- @return table returned by nixio.getifaddrs()
-function get_interfaces()
- return ifaddrs
-end
-
---- Revoke process privileges.
--- @param user new user name or uid
--- @param group new group name or gid
--- @return boolean status or nil, error code, error message
-function revoke_privileges(user, group)
- if nixio.getuid() == 0 then
- return nixio.setgid(group) and nixio.setuid(user)
- end
-end
-
---- Return a secure UCI cursor.
--- @return UCI cursor
-function securestate()
- local stat = nixio.fs.stat(SSTATE) or {}
- local uid = nixio.getuid()
- if stat.type ~= "dir" or (stat.modedec % 100) ~= 0 or stat.uid ~= uid then
- nixio.fs.remover(SSTATE)
- if not nixio.fs.mkdir(SSTATE, 700) then
- local errno = nixio.errno()
- nixio.syslog("err", "Integrity check on secure state failed!")
- return nil, errno, nixio.perror(errno)
- end
- end
-
- return uci.cursor(nil, SSTATE)
-end
-
---- Daemonize the process.
--- @return boolean status or nil, error code, error message
-function daemonize()
- if nixio.getppid() == 1 then
- return
- end
-
- local pid, code, msg = nixio.fork()
- if not pid then
- return nil, code, msg
- elseif pid > 0 then
- os.exit(0)
- end
-
- nixio.setsid()
- nixio.chdir("/")
-
- local devnull = nixio.open("/dev/null", nixio.open_flags("rdwr"))
- nixio.dup(devnull, nixio.stdin)
- nixio.dup(devnull, nixio.stdout)
- nixio.dup(devnull, nixio.stderr)
-
- return true
-end
diff --git a/libs/lucid/luasrc/lucid/tcpserver.lua b/libs/lucid/luasrc/lucid/tcpserver.lua
deleted file mode 100644
index 266ea29e4..000000000
--- a/libs/lucid/luasrc/lucid/tcpserver.lua
+++ /dev/null
@@ -1,254 +0,0 @@
---[[
-LuCI - Lua Development Framework
-
-Copyright 2009 Steven Barth <steven@midlink.org>
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-$Id$
-]]
-
-local os = require "os"
-local fs = require "nixio.fs"
-local nixio = require "nixio"
-local lucid = require "luci.lucid"
-
-local ipairs, type, require, setmetatable = ipairs, type, require, setmetatable
-local pairs, print, tostring, unpack = pairs, print, tostring, unpack
-local pcall = pcall
-
-module "luci.lucid.tcpserver"
-
-local cursor = lucid.cursor
-local UCINAME = lucid.UCINAME
-
-local tcpsockets = {}
-
---- Prepare a daemon and allocate its resources. (superserver callback)
--- @param config configuration table
--- @param server LuCId basemodule
--- @return binary data
-function prepare_daemon(config, server)
- nixio.syslog("info", "Preparing TCP-Daemon " .. config[".name"])
- if type(config.address) ~= "table" then
- config.address = {config.address}
- end
-
- local sockets, socket, code, err = {}
- local sopts = {reuseaddr = 1}
- for _, addr in ipairs(config.address) do
- local host, port = addr:match("(.-):?([^:]*)")
- if not host then
- nixio.syslog("err", "Invalid address: " .. addr)
- return nil, -5, "invalid address format"
- elseif #host == 0 then
- host = nil
- end
- socket, code, err = prepare_socket(config.family, host, port, sopts)
- if socket then
- sockets[#sockets+1] = socket
- end
- end
-
- nixio.syslog("info", "Sockets bound for " .. config[".name"])
-
- if #sockets < 1 then
- return nil, -6, "no sockets bound"
- end
-
- nixio.syslog("info", "Preparing publishers for " .. config[".name"])
-
- local publisher = {}
- for k, pname in ipairs(config.publisher) do
- local pdata = cursor:get_all(UCINAME, pname)
- if pdata then
- publisher[#publisher+1] = pdata
- else
- nixio.syslog("err", "Publisher " .. pname .. " not found")
- end
- end
-
- nixio.syslog("info", "Preparing TLS for " .. config[".name"])
-
- local tls = prepare_tls(config.tls)
- if not tls and config.encryption == "enable" then
- for _, s in ipairs(sockets) do
- s:close()
- end
- return nil, -4, "Encryption requested, but no TLS context given"
- end
-
- nixio.syslog("info", "Invoking daemon factory for " .. config[".name"])
- local handler, err = config.slave.module.factory(publisher, config)
- if not handler then
- for _, s in ipairs(sockets) do
- s:close()
- end
- return nil, -3, err
- else
- local pollin = nixio.poll_flags("in")
- for _, s in ipairs(sockets) do
- server.register_pollfd({
- fd = s,
- events = pollin,
- revents = 0,
- handler = accept,
- accept = handler,
- config = config,
- publisher = publisher,
- tls = tls
- })
- end
- return true
- end
-end
-
---- Accept a new TCP connection. (server callback)
--- @param polle Poll descriptor
--- @return handler process id or nil, error code, error message
-function accept(polle)
- if not lucid.try_process() then
- return false
- end
- local socket, host, port = polle.fd:accept()
- if not socket then
- return nixio.syslog("warning", "accept() failed: " .. port)
- end
-
- socket:setblocking(true)
-
- local function thread()
- lucid.close_pollfds()
- local inst = setmetatable({
- host = host, port = port, interfaces = lucid.get_interfaces()
- }, {__index = polle})
- if polle.config.encryption then
- socket = polle.tls:create(socket)
- if not socket:accept() then
- socket:close()
- return nixio.syslog("warning", "TLS handshake failed: " .. host)
- end
- end
-
- return polle.accept(socket, inst)
- end
-
- local stat = {lucid.create_process(thread)}
- socket:close()
- return unpack(stat)
-end
-
---- Prepare a TCP server socket.
--- @param family protocol family ["inetany", "inet6", "inet"]
--- @param host host
--- @param port port
--- @param opts table of socket options
--- @param backlog socket backlog
--- @return socket, final socket family
-function prepare_socket(family, host, port, opts, backlog)
- nixio.syslog("info", "Preparing socket for port " .. port)
- backlog = backlog or 1024
- family = family or "inetany"
- opts = opts or {}
-
- local inetany = family == "inetany"
- family = inetany and "inet6" or family
-
- local socket, code, err = nixio.socket(family, "stream")
- if not socket and inetany then
- family = "inet"
- socket, code, err = nixio.socket(family, "stream")
- end
-
- if not socket then
- return nil, code, err
- end
-
- for k, v in pairs(opts) do
- socket:setsockopt("socket", k, v)
- end
-
- local stat, code, err = socket:bind(host, port)
- if not stat then
- return nil, code, err
- end
-
- stat, code, err = socket:listen(backlog)
- if not stat then
- return nil, code, err
- end
-
- socket:setblocking(false)
-
- return socket, family
-end
-
---- Prepare a TLS server context and load keys and certificates.
--- May invoke px5g to create keys and certificate on demand if available.
--- @param tlskey TLS configuration identifier
--- @return TLS server conext or nil
-function prepare_tls(tlskey)
- local tls
- if nixio.tls and tlskey and cursor:get(UCINAME, tlskey) then
- tls = nixio.tls("server")
-
- local make = cursor:get(UCINAME, tlskey, "generate") == "1"
- local key = cursor:get(UCINAME, tlskey, "key")
- local xtype = make and "asn1" or cursor:get(UCINAME, tlskey, "type")
- local cert = cursor:get(UCINAME, tlskey, "cert")
- local ciphers = cursor:get(UCINAME, tlskey, "ciphers")
-
- if make and (not fs.access(key) or not fs.access(cert)) then
- local CN = cursor:get(UCINAME, tlskey, "CN")
- local O = cursor:get(UCINAME, tlskey, "O")
- local bits = 2048
-
- local data = {
- CN = CN or nixio.uname().nodename,
- O = not O and "LuCId Keymaster" or #O > 0 and O
- }
-
- local stat, px5g = pcall(require, "px5g")
- if not stat then
- return nixio.syslog("err", "Unable to load PX5G Keymaster")
- end
-
- nixio.syslog("warning", "PX5G: Generating private key")
- local rk = px5g.genkey(bits)
- local keyfile = nixio.open(key, "w", 600)
- if not rk or not keyfile or not keyfile:writeall(rk:asn1()) then
- return nixio.syslog("err", "Unable to generate private key")
- end
- keyfile:close()
-
- nixio.syslog("warning", "PX5G: Generating self-signed certificate")
- if not fs.writefile(cert, rk:create_selfsigned(data,
- os.time(), os.time() + 3600 * 24 * 366 * 15)) then
- return nixio.syslog("err", "Unable to generate certificate")
- end
- end
-
- if cert then
- if not tls:set_cert(cert, xtype) then
- nixio.syslog("err", "Unable to load certificate: " .. cert)
- end
- end
- if key then
- if not tls:set_key(key, xtype) then
- nixio.syslog("err", "Unable to load private key: " .. key)
- end
- end
-
- if ciphers then
- if type(ciphers) == "table" then
- ciphers = table.concat(ciphers, ":")
- end
- tls:set_ciphers(ciphers)
- end
- end
- return tls
-end