module "luci.lucid.http"
+--- Prepare the HTTP-daemon and its associated publishers.
+-- @param publisher Table of publishers
+-- @return factory callback or nil, error message
function factory(publisher)
local server = srv.Server()
for _, r in ipairs(publisher) do
module "luci.lucid.http.DirectoryPublisher"
+--- Prepare a directory publisher and assign it to a given Virtual Host.
+-- @param server HTTP daemon object
+-- @param config publisher configuration
function factory(server, config)
config.domain = config.domain or ""
local vhost = server:get_vhosts()[config.domain]
module "luci.lucid.http.LuciWebPublisher"
+
+--- Prepare a LuCI web publisher and assign it to a given Virtual Host.
+-- @param server HTTP daemon object
+-- @param config publisher configuration
function factory(server, config)
pcall(function()
require "luci.dispatcher"
module "luci.lucid.http.Redirector"
-
+--- Prepare a redirector publisher and assign it to a given Virtual Host.
+-- @param server HTTP daemon object
+-- @param config publisher configuration
function factory(server, config)
config.domain = config.domain or ""
local vhost = server:get_vhosts()[config.domain]
local proto = require "luci.http.protocol"
local util = require "luci.util"
+--- Catchall Handler
+-- @cstyle instance
module "luci.lucid.http.handler.catchall"
+--- Create a Redirect handler.
+-- @param name Name
+-- @param target Redirect Target
+-- @class function
+-- @return Redirect handler object
Redirect = util.class(srv.Handler)
function Redirect.__init__(self, name, target)
self.target = target
end
+--- Handle a GET request.
+-- @param request Request object
+-- @return status code, header table, response source
function Redirect.handle_GET(self, request)
local target = self.target
local protocol = request.env.HTTPS and "https://" or "http://"
return 302, { Location = target }
end
+--- Handle a POST request.
+-- @class function
+-- @param request Request object
+-- @return status code, header table, response source
Redirect.handle_POST = Redirect.handle_GET
+--- Handle a HEAD request.
+-- @class function
+-- @param request Request object
+-- @return status code, header table, response source
function Redirect.handle_HEAD(self, request)
local stat, head = self:handle_GET(request)
return stat, head
local mime = require "luci.http.protocol.mime"
local cond = require "luci.http.protocol.conditionals"
+--- File system handler
+-- @cstyle instance
module "luci.lucid.http.handler.file"
+--- Create a simple file system handler.
+-- @class function
+-- @param name Name
+-- @param docroot Physical Document Root
+-- @param options Options
+-- @return Simple file system handler object
Simple = util.class(srv.Handler)
function Simple.__init__(self, name, docroot, options)
self.error404 = options.error404
end
+--- Parse a range request.
+-- @param request Request object
+-- @param size File size
+-- @return offset, length, range header or boolean status
function Simple.parse_range(self, request, size)
if not request.headers.Range then
return true
return from, (1 + to - from), range
end
+--- Translate path and return file information.
+-- @param uri Request URI
+-- @return physical file path, file information
function Simple.getfile(self, uri)
if not self.realdocroot then
self.realdocroot = fs.realpath(self.docroot)
return file, fs.stat(file)
end
+--- Handle a GET request.
+-- @param request Request object
+-- @return status code, header table, response source
function Simple.handle_GET(self, request)
local file, stat = self:getfile(prot.urldecode(request.env.PATH_INFO, true))
'p { margin:0 }' ..
'\n</style></head><body><h1>Index of %s/</h1><hr /><ul>'..
'<li><p><a href="%s/../">../</a> ' ..
- '<small>(parent directory)</small><br />' ..
+ '<small>(parent directory)</small><br />' ..
'<small></small></li>',
duri, duri, ruri
)
end
end
+--- Handle a HEAD request.
+-- @param request Request object
+-- @return status code, header table, response source
function Simple.handle_HEAD(self, ...)
local stat, head = self:handle_GET(...)
return stat, head
local coroutine = require "coroutine"
local type = type
+--- LuCI web handler
+-- @cstyle instance
module "luci.lucid.http.handler.luci"
+--- Create a LuCI web handler.
+-- @class function
+-- @param name Name
+-- @param prefix Dispatching prefix
+-- @return LuCI web handler object
Luci = util.class(srv.Handler)
function Luci.__init__(self, name, prefix)
self.prefix = prefix
end
+--- Handle a HEAD request.
+-- @param request Request object
+-- @return status code, header table, response source
function Luci.handle_HEAD(self, ...)
local stat, head = self:handle_GET(...)
return stat, head
end
+--- Handle a POST request.
+-- @param request Request object
+-- @return status code, header table, response source
function Luci.handle_POST(self, ...)
return self:handle_GET(...)
end
+--- Handle a GET request.
+-- @param request Request object
+-- @return status code, header table, response source
function Luci.handle_GET(self, request, sourcein)
local r = http.Request(
request.env,
local table = require "table"
local date = require "luci.http.protocol.date"
+--- HTTP Daemon
+-- @cstyle instance
module "luci.lucid.http.server"
VERSION = "1.0"
[503] = "Server Unavailable",
}
--- File Resource
+--- Create a new IO resource response.
+-- @class function
+-- @param fd File descriptor
+-- @param len Length of data
+-- @return IO resource
IOResource = util.class()
function IOResource.__init__(self, fd, len)
end
--- Server handler implementation
+--- Create a server handler.
+-- @class function
+-- @param name Name
+-- @return Handler
Handler = util.class()
function Handler.__init__(self, name)
self.name = name or tostring(self)
end
--- Creates a failure reply
+--- Create a failure reply.
+-- @param code HTTP status code
+-- @param msg Status message
+-- @return status code, header table, response source
function Handler.failure(self, code, msg)
return code, { ["Content-Type"] = "text/plain" }, ltn12.source.string(msg)
end
--- Access Restrictions
+--- Add an access restriction.
+-- @param restriction Restriction specification
function Handler.restrict(self, restriction)
if not self.restrictions then
self.restrictions = {restriction}
end
end
--- Check restrictions
+--- Enforce access restrictions.
+-- @param request Request object
+-- @return nil or HTTP statuscode, table of headers, response source
function Handler.checkrestricted(self, request)
if not self.restrictions then
return
}, ltn12.source.string("Unauthorized")
end
--- Processes a request
+--- Process a request.
+-- @param request Request object
+-- @param sourcein Request data source
+-- @return HTTP statuscode, table of headers, response source
function Handler.process(self, request, sourcein)
local stat, code, hdr, sourceout
end
+--- Create a Virtual Host.
+-- @class function
+-- @return Virtual Host
VHost = util.class()
function VHost.__init__(self)
self.handlers = {}
end
+--- Process a request and invoke the appropriate handler.
+-- @param request Request object
+-- @param ... Additional parameters passed to the handler
+-- @return HTTP statuscode, table of headers, response source
function VHost.process(self, request, ...)
local handler
local hlen = -1
end
end
+--- Get a list of registered handlers.
+-- @return Table of handlers
function VHost.get_handlers(self)
return self.handlers
end
+--- Register handler with a given URI prefix.
+-- @oaram match URI prefix
+-- @param handler Handler object
function VHost.set_handler(self, match, handler)
self.handlers[match] = handler
end
-
+-- Remap IPv6-IPv4-compatibility addresses back to IPv4 addresses.
local function remapipv6(adr)
local map = "::ffff:"
if adr:sub(1, #map) == map then
end
end
+-- Create a source that decodes chunked-encoded data from a socket.
local function chunksource(sock, buffer)
buffer = buffer or ""
return function()
end
end
+-- Create a sink that chunk-encodes data and writes it on a given socket.
local function chunksink(sock)
return function(chunk, err)
if not chunk then
end
end
+
+--- Create a server object.
+-- @class function
+-- @return Server object
Server = util.class()
function Server.__init__(self)
self.vhosts = {}
end
+--- Get a list of registered virtual hosts.
+-- @return Table of virtual hosts
function Server.get_vhosts(self)
return self.vhosts
end
+--- Register a virtual host with a given name.
+-- @param name Hostname
+-- @param vhost Virtual host object
function Server.set_vhost(self, name, vhost)
self.vhosts[name] = vhost
end
+--- Send a fatal error message to given client and close the connection.
+-- @param client Client socket
+-- @param code HTTP status code
+-- @param msg status message
function Server.error(self, client, code, msg)
hcode = tostring(code)
["User-Agent"] = "HTTP_USER_AGENT"
}
+--- Parse the request headers and prepare the environment.
+-- @param source line-based input source
+-- @return Request object
function Server.parse_headers(self, source)
local env = {}
local req = {env = env, headers = {}}
return req
end
-
+--- Handle a new client connection.
+-- @param client client socket
+-- @param env superserver environment
function Server.process(self, client, env)
local sourcein = function() end
local sourcehdr = client:linesource()
module "luci.lucid.rpc"
-
+--- Prepare the RPC-daemon and its associated publishers.
+-- @param publisher Table of publishers
+-- @return factory callback or nil, error message
function factory(publisher)
local root = srv.Module()
local server = srv.Server(root)
local nixio = require "nixio"
local srv = require "luci.lucid.rpc.server"
+--- Remote UCI functions.
module "luci.lucid.rpc.ruci"
+-- Prepare the remote UCI functions.
function _factory()
local m = srv.Module("Remote UCI API")
return m
end
+-- Get the associate RUCI instance.
local function getinst(session, name)
return session.ruci and session.ruci[name]
end
+-- Set a new RUCI instance.
local function setinst(session, obj)
session.ruci = session.ruci or {}
local name = tostring(obj):match("0x([a-z0-9]+)")
return name
end
+
local Cursor = getmetatable(uci.cursor())
for name, func in pairs(Cursor) do
end
end
+--- Generate a new RUCI cursor.
+-- @param session Session object
+-- @param ... Parameters passed to the UCI constructor
+-- @return RUCI instance
function cursor(session, ...)
return setinst(session, uci.cursor(...))
end
+--- Generate a new RUCI state cursor.
+-- @param session Session object
+-- @param ... Parameters passed to the UCI constructor
+-- @return RUCI instance
function cursor_state(session, ...)
return setinst(session, uci.cursor_state(...))
end
+--- Custom foreach function.
+-- @param session Session object
+-- @param inst RUCI instance
+-- @param config UCI config
+-- @param sectiontype UCI sectiontype
+-- @return section data
function foreach(session, inst, config, sectiontype)
local inst = getinst(session, inst)
local secs = {}
local table = require "table"
local ltn12 = require "luci.ltn12"
+--- RPC daemom.
+-- @cstyle instance
module "luci.lucid.rpc.server"
RQLIMIT = 32 * nixio.const.buffersize
}
-
+--- Create an RPC method wrapper.
+-- @class function
+-- @param method Lua function
+-- @param description Method description
+-- @return Wrapped RPC method
Method = util.class()
+--- Create an extended wrapped RPC method.
+-- @class function
+-- @param method Lua function
+-- @param description Method description
+-- @return Wrapped RPC method
function Method.extended(...)
local m = Method(...)
m.call = m.xcall
self.method = method
end
+--- Extended call the associated function.
+-- @param session Session storage
+-- @param argv Request parameters
+-- @return function call response
function Method.xcall(self, session, argv)
return self.method(session, unpack(argv))
end
+--- Standard call the associated function.
+-- @param session Session storage
+-- @param argv Request parameters
+-- @return function call response
function Method.call(self, session, argv)
return self.method(unpack(argv))
end
+--- Process a given request and create a JSON response.
+-- @param session Session storage
+-- @param request Requested method
+-- @param argv Request parameters
function Method.process(self, session, request, argv)
local stat, result = pcall(self.call, self, session, argv)
end
end
-
+-- Remap IPv6-IPv4-compatibility addresses to IPv4 addresses
local function remapipv6(adr)
local map = "::ffff:"
if adr:sub(1, #map) == map then
end
end
+
+--- Create an RPC module.
+-- @class function
+-- @param description Method description
+-- @return RPC module
Module = util.class()
function Module.__init__(self, description)
self.handler = {}
end
+--- Add a handler.
+-- @param k key
+-- @param v handler
function Module.add(self, k, v)
self.handler[k] = v
end
--- Access Restrictions
+--- Add an access restriction.
+-- @param restriction Restriction specification
function Module.restrict(self, restriction)
if not self.restrictions then
self.restrictions = {restriction}
end
end
--- Check restrictions
+--- Enforce access restrictions.
+-- @param request Request object
+-- @return nil or HTTP statuscode, table of headers, response source
function Module.checkrestricted(self, session, request, argv)
if not self.restrictions then
return
return {error={code=ERRNO_NOACCESS, message=ERRMSG[ERRNO_NOACCESS]}}
end
+--- Register a handler, submodule or function.
+-- @param m entity
+-- @param descr description
+-- @return Module (self)
function Module.register(self, m, descr)
descr = descr or {}
for k, v in pairs(m) do
return self
end
+--- Process a request.
+-- @param session Session storage
+-- @param request Request object
+-- @param argv Request parameters
+-- @return JSON response object
function Module.process(self, session, request, argv)
local first, last = request:match("^([^.]+).?(.*)$")
end
-
+--- Create a server object.
+-- @class function
+-- @param root Root module
+-- @return Server object
Server = util.class()
function Server.__init__(self, root)
self.root = root
end
+--- Get the associated root module.
+-- @return Root module
function Server.get_root(self)
return self.root
end
+--- Set a new root module.
+-- @param root Root module
function Server.set_root(self, root)
self.root = root
end
+--- Create a JSON reply.
+-- @param jsonrpc JSON-RPC version
+-- @param id Message id
+-- @param res Result
+-- @param err Error
+-- @reutrn JSON response source
function Server.reply(self, jsonrpc, id, res, err)
id = id or json.null
):source()
end
+--- Handle a new client connection.
+-- @param client client socket
+-- @param env superserver environment
function Server.process(self, client, env)
local decoder
local sinkout = client:sink()
local nixio = require "nixio"
local lucid = require "luci.lucid"
+--- Internal system functions.
module "luci.lucid.rpc.system"
+-- Prepare the RPC module.
function _factory()
local mod = srv.Module("System functions"):register({
echo = echo,
return mod
end
-
+--- Simple echo test function.
+-- @param object to be echoed object
+-- @return echo object
function echo(object)
return object
end
+--- Simple void test function.
function void()
end
+--- Accumulate different requests and execute them.
+-- @param session Session object
+-- @param ...
+-- @return overall response object
function multicall(session, ...)
local server, responses, response = session.server, {}, nil
for k, req in ipairs({...}) do
return responses
end
+--- Create or use a new authentication token.
+-- @param session Session object
+-- @param type Authentication type
+-- @param entity Authentication enttity (username)
+-- @param key Authentication key (password)
+-- @return boolean status
function authenticate(session, type, entity, key)
if not type then
session.user = nil
projects / project / luci.git / commitdiff