#!/usr/bin/env lua
-- ***********************************************************************
--
-- 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: [email protected]
--
-- =======================================================================
--
-- Main entry point to the Gopher Daemon.  This daemon creates N number of
-- server processes, where N is the number of cores in the system.  Each
-- server process will then accept connections, and fork a handler processor
-- (the 90s called---they want their forking daemons back) and while this is
-- frowned upon these days, I don't think the traffic bears a more modern
-- event driven architecture (and if it does---well, that's a nice problem
-- to have).
--
-- The default values for configuration is below.  All of these can be
-- overridden in the configuration file.
--
-- ***********************************************************************
-- luacheck: globals config blog handler
-- luacheck: ignore 611

config =
{
 interface =
 {
   address  = '0.0.0.0',
   hostname = 'lucy.roswell.area51',
   port     = 'gopher',
 },

 syslog =
 {
   id       = 'gopher',
   facility = 'daemon',
 },

 user =
 {
   uid = 'gopher',
   gid = 'gopher',
 },

 bible =
 {
   books  = "thebooks",
   verses = "books",
 },

 movie = "/home/spc/LINUS/source/play/plotdriver/plotdriver.cnf",

 files  = "/home/spc/source/gopher-blog/share",
 blog   = "/home/spc/web/boston/journal/blog.conf",
 quotes = "/home/spc/LINUS/quotes/quote -r",
}

local exit      = require "org.conman.const.exit"
local process   = require "org.conman.process"
local signal    = require "org.conman.signal"
local getopt    = require "org.conman.getopt"
local syslog    = require "org.conman.syslog"
local errno     = require "org.conman.errno"
local fsys      = require "org.conman.fsys"
local net       = require "org.conman.net"
local sys       = require "org.conman.sys"

local CHILDREN = {}
local SOCKET

-- ***********************************************************************
--
-- usage:       okay,child = create_server_process(socket)
--
-- desc:        Create a server process.
-- input:       socket (userdata/socket)
-- return:      okay (boolean) true if success, false othersise
--              child (integer) child pid, nil on error
-- ***********************************************************************

local function create_server_process(socket)
 -- -----------------------------------------------------------
 -- usage:     wait_for_it()
 -- desc:      accepts connections and forks a handler process
 -- notes:     infinite loop, never returns
 -- -----------------------------------------------------------

 local function wait_for_it()
   local connection,remote,err = socket:accept()
   if not connection then
     syslog('error',"failed connection: %s",errno[err])
     return wait_for_it()
   end

   local child,err = process.fork() -- luacheck: ignore
   if not child then
     syslog('error',"cannot create handler process: %s",errno[err])
     connection:close()
     return wait_for_it()
   end

   if child == 0 then
     socket:close()
     fsys.redirect(connection,io.stdin)
     fsys.redirect(connection,io.stdout)
     io.stdin:setvbuf('no')
     io.stdout:setvbuf('no')
     connection:close()
     signal.default('child')
     local _,msg = pcall(handler.main,remote)
     syslog('error',"handle_request = %s",msg)
     process.exit(exit.SOFTWARE) -- handle_request() should exit
   end

   connection:close()
   return wait_for_it()
 end

 -- ----------------------------------------------------------------

 local child,err = process.fork()
 if not child then
   syslog('critical',"cannot create server process: %s",errno[err])
   return false
 end

 if child > 0 then
   syslog('info',"created server process %d",child)
   return true,child
 end

 if not require "reapchild" then
   syslog('error',"unable to reap children")
   process.exit(exit.SOFTWARE)
 end

 signal.default('int')
 signal.default('term')
 wait_for_it()
end

-- ***********************************************************************
-- usage:       shut_down_server_processes()
-- desc:        Pretty much what it says on the box
-- ***********************************************************************

local function shut_down_server_processes()
 for pid in pairs(CHILDREN) do
   signal.raise('term',pid)
   local info,err = process.wait(pid)
   if not info then
     syslog('error',"process.wait(%d) = %s",pid,errno[err])
   else
     syslog('info',"server process %d stopped: %s",pid,info.description)
   end
 end
 process.exit(0)
end

-- ***********************************************************************
--
-- Main entry point---parse the command line, read the configuration file,
-- create the listening socket and set up signal handling.
--
-- ***********************************************************************

do
 local cfile = "gopher-config.lua"
 local usage = [[
usage: %s [options]
       -c | --config file      Configuration file (%s)
       -h | --help             This very text
]]

 local opts =
 {
   { 'c' , 'config' , true  , function(c) cfile = c end },
   { 'h' , 'help'   , false , function()
       io.stderr:write(string.format(usage,arg[0],cfile))
       os.exit(exit.USAGE)
     end
   }
 }

 getopt.getopt(arg,opts)

 do
   local f,err = loadfile(cfile,"t",config)
   if not f then
     syslog('critical',"%s: %s",cfile,err)
     os.exit(exit.CONFIG)
   end

   if _VERSION == "Lua 5.1" then
     setfenv(f,config)
   end

   f()
   package.loaded['CONFIG'] = config
 end

 syslog.open(config.syslog.id,config.syslog.facility)

 local addr = net.address(config.interface.address,'tcp',config.interface.port)
 config.interface.port = addr.port

 SOCKET = net.socket(addr.family,'tcp')
 SOCKET.reuseaddr = true
 local err = SOCKET:bind(addr)
 if err ~= 0 then
   syslog('critical',"cannot bind to interface: %s",errno[err])
   os.exit(exit.CANTCREATE)
 end

 if process.getuid() == 0 then
   local unix = require "org.conman.unix"
   local gid  = unix.groups[config.user.gid].gid
   local uid  = unix.users[config.user.uid].uid

   process.setgid(gid,gid,gid)
   process.setuid(uid,uid,uid)
   package.loaded['org.conman.unix'] = nil
   unix                              = nil -- luacheck: ignore
 end

 -- ----------------------------------------------------------------
 -- XXX - Unfortunately, due to the way the code is current written, the
 -- following two modules need to be globally visible.  I really need to
 -- fix this some day.
 --
 -- Also, because I know make the config a loaded modules, these need to be
 -- after that happens, not before.
 -- ----------------------------------------------------------------

 blog    = require "blog"
 handler = require "handler"

 blog.init()
 handler.init()

 signal.catch('int')
 signal.catch('term')
 signal.catch('child')
 SOCKET:listen()
end

-- ***********************************************************************
--
-- Main processing loop.  Create the server processes, then monitor them and
-- restart if required.
--
-- ***********************************************************************

for _ = 1 , sys.CORES do
 local okay,child = create_server_process(SOCKET)
 if okay then
   CHILDREN[child] = true
 end
end

while true do
 process.pause()

 if signal.caught('int') or signal.caught('term') then
   shut_down_server_processes()
   os.exit(exit.SUCCESS)

 elseif signal.caught('child') then
   local info,err = process.wait()

   if not info then
     if err ~= errno.ECHILD then
       syslog('error',"process.wait() = %s",errno[err])
     else
       syslog('error',"say what?")
     end

   else
     syslog('error',"server process: status=%s description=%s",info.status,info.description)
     syslog('notice',"restarting server process")
     CHILDREN[info.pid] = nil

     local okay,child = create_server_process(SOCKET)
     if okay then
       CHILDREN[child] = true
     end
   end
 end
end

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

You are viewing proxied material from gopher.conman.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.