2 LuCI - Lua Development Framework
4 Copyright 2009 Steven Barth <steven@midlink.org>
6 Licensed under the Apache License, Version 2.0 (the "License");
7 you may not use this file except in compliance with the License.
8 You may obtain a copy of the License at
10 http://www.apache.org/licenses/LICENSE-2.0
15 local nixio = require "nixio"
16 local table = require "table"
17 local uci = require "luci.model.uci"
18 local os = require "os"
19 local io = require "io"
21 local pairs, require, pcall, assert, type = pairs, require, pcall, assert, type
22 local ipairs, tonumber, collectgarbage = ipairs, tonumber, collectgarbage
32 local ifaddrs = nixio.getifaddrs()
35 state = uci.cursor_state()
40 local UCINAME = UCINAME
41 local SSTATE = "/tmp/.lucid_store"
44 --- Starts a new LuCId superprocess.
46 state:revert(UCINAME, "main")
50 local detach = cursor:get(UCINAME, "main", "daemonize")
52 local stat, code, msg = daemonize()
54 nixio.syslog("crit", "Unable to detach process: " .. msg .. "\n")
59 state:set(UCINAME, "main", "pid", nixio.getpid())
65 --- Returns the PID of the currently active LuCId process.
67 local pid = tonumber(state:get(UCINAME, "main", "pid"))
68 return pid and nixio.kill(pid, 0) and pid
71 --- Stops any running LuCId superprocess.
73 local pid = tonumber(state:get(UCINAME, "main", "pid"))
75 return nixio.kill(pid, nixio.const.SIGTERM)
80 --- Prepares the slaves, daemons and publishers, allocate resources.
82 local debug = tonumber((cursor:get(UCINAME, "main", "debug")))
84 nixio.openlog("lucid", "pid", "perror")
86 nixio.setlogmask("warning")
89 cursor:foreach(UCINAME, "daemon", function(config)
90 if config.enabled ~= "1" then
94 local key = config[".name"]
95 if not config.slave then
96 nixio.syslog("crit", "Daemon "..key.." is missing a slave\n")
99 nixio.syslog("info", "Initializing daemon " .. key)
102 state:revert(UCINAME, key)
104 local daemon, code, err = prepare_daemon(config)
106 state:set(UCINAME, key, "status", "started")
107 nixio.syslog("info", "Prepared daemon " .. key)
109 state:set(UCINAME, key, "status", "error")
110 state:set(UCINAME, key, "error", err)
111 nixio.syslog("err", "Failed to initialize daemon "..key..": "..
117 --- Run the superprocess if prepared before.
118 -- This main function of LuCId will wait for events on given file descriptors.
120 local pollint = tonumber((cursor:get(UCINAME, "main", "pollinterval")))
121 local threadlimit = tonumber((cursor:get(UCINAME, "main", "threadlimit")))
124 local stat, code = nixio.poll(pollt, pollint)
126 if stat and stat > 0 then
128 for _, polle in ipairs(pollt) do
129 if polle.revents ~= 0 and polle.handler then
130 ok = ok or polle.handler(polle)
134 -- Avoid high CPU usage if thread limit is reached
135 nixio.nanosleep(0, 100000000)
137 elseif stat == 0 then
138 ifaddrs = nixio.getifaddrs()
139 collectgarbage("collect")
142 for _, cb in ipairs(tickt) do
146 local pid, stat, code = nixio.wait(-1, "nohang")
147 while pid and pid > 0 do
149 if tpids[pid] and tpids[pid] ~= true then
150 tpids[pid](pid, stat, code)
152 pid, stat, code = nixio.wait(-1, "nohang")
157 --- Add a file descriptor for the main loop and associate handler functions.
158 -- @param polle Table containing: {fd = FILE DESCRIPTOR, events = POLL EVENTS,
159 -- handler = EVENT HANDLER CALLBACK}
160 -- @see unregister_pollfd
161 -- @return boolean status
162 function register_pollfd(polle)
163 pollt[#pollt+1] = polle
167 --- Unregister a file desciptor and associate handler from the main loop.
168 -- @param polle Poll descriptor
169 -- @see register_pollfd
170 -- @return boolean status
171 function unregister_pollfd(polle)
172 for k, v in ipairs(pollt) do
174 table.remove(pollt, k)
181 --- Close all registered file descriptors from main loop.
182 -- This is useful for forked child processes.
183 function close_pollfds()
184 for k, v in ipairs(pollt) do
185 if v.fd and v.fd.close then
191 --- Register a tick function that will be called at each cycle of the main loop.
192 -- @param cb Callback
193 -- @see unregister_tick
194 -- @return boolean status
195 function register_tick(cb)
200 --- Unregister a tick function from the main loop.
201 -- @param cb Callback
202 -- @see register_tick
203 -- @return boolean status
204 function unregister_tick(cb)
205 for k, v in ipairs(tickt) do
207 table.remove(tickt, k)
214 --- Tests whether a given number of processes can be created.
215 -- @oaram num Processes to be created
216 -- @return boolean status
217 function try_process(num)
218 local threadlimit = tonumber((cursor:get(UCINAME, "main", "threadlimit")))
219 return not threadlimit or (threadlimit - tcount) >= (num or 1)
222 --- Create a new child process from a Lua function and assign a destructor.
223 -- @param threadcb main function of the new process
224 -- @param waitcb destructor callback
225 -- @return process identifier or nil, error code, error message
226 function create_process(threadcb, waitcb)
227 local threadlimit = tonumber(cursor:get(UCINAME, "main", "threadlimit"))
228 if threadlimit and tcount >= threadlimit then
229 nixio.syslog("warning", "Cannot create thread: process limit reached")
232 local pid, code, err = nixio.fork()
233 if pid and pid ~= 0 then
237 local code = threadcb()
240 nixio.syslog("err", "Unable to fork(): " .. err)
242 return pid, code, err
245 --- Prepare a daemon from a given configuration table.
246 -- @param config Configuration data.
247 -- @return boolean status or nil, error code, error message
248 function prepare_daemon(config)
249 nixio.syslog("info", "Preparing daemon " .. config[".name"])
250 local modname = cursor:get(UCINAME, config.slave)
252 return nil, -1, "invalid slave"
255 local stat, module = pcall(require, _NAME .. "." .. modname)
256 if not stat or not module.prepare_daemon then
257 return nil, -2, "slave type not supported"
260 config.slave = prepare_slave(config.slave)
262 return module.prepare_daemon(config, _M)
266 -- @param name slave name
267 -- @return table containing slave module and configuration or nil, error message
268 function prepare_slave(name)
269 local slave = slaves[name]
271 local config = cursor:get_all(UCINAME, name)
273 local stat, module = pcall(require, config and config.entrypoint)
275 slave = {module = module, config = config}
286 --- Return a list of available network interfaces on the host.
287 -- @return table returned by nixio.getifaddrs()
288 function get_interfaces()
292 --- Revoke process privileges.
293 -- @param user new user name or uid
294 -- @param group new group name or gid
295 -- @return boolean status or nil, error code, error message
296 function revoke_privileges(user, group)
297 if nixio.getuid() == 0 then
298 return nixio.setgid(group) and nixio.setuid(user)
302 --- Return a secure UCI cursor.
303 -- @return UCI cursor
304 function securestate()
305 local stat = nixio.fs.stat(SSTATE) or {}
306 local uid = nixio.getuid()
307 if stat.type ~= "dir" or (stat.modedec % 100) ~= 0 or stat.uid ~= uid then
308 nixio.fs.remover(SSTATE)
309 if not nixio.fs.mkdir(SSTATE, 700) then
310 local errno = nixio.errno()
311 nixio.syslog("err", "Integrity check on secure state failed!")
312 return nil, errno, nixio.perror(errno)
316 return uci.cursor(nil, SSTATE)
319 --- Daemonize the process.
320 -- @return boolean status or nil, error code, error message
322 if nixio.getppid() == 1 then
326 local pid, code, msg = nixio.fork()
328 return nil, code, msg
336 local devnull = nixio.open("/dev/null", nixio.open_flags("rdwr"))
337 nixio.dup(devnull, nixio.stdin)
338 nixio.dup(devnull, nixio.stdout)
339 nixio.dup(devnull, nixio.stderr)