#include <unistd.h>

#include <signal.h>

#include <syslog.h>

#include <iostream>

#include <fstream>

#include <stdexcept>

using namespace std;

#include "configuration.h"

#include "util.h"

#include "config.h"

#ifdef HAVE_GETOPT_H

# include <getopt.h>

#endif

#ifndef DEFAULT_CONF_FILE

# define DEFAULT_CONF_FILE "/etc/dudki.conf"

#endif

#define PHEADER PACKAGE " Version " VERSION

#define PCOPY "Copyright (c) 2004 Klever Group"

bool finishing = false;

static char **_argv = NULL;

static void lethal_signal_handler(int signum) {

syslog(LOG_NOTICE,"Lethal signal received. Terminating.");

finishing = true;

}

static void sighup_handler(int signum) {

syslog(LOG_NOTICE,"SUGHUP received, reloading.");

}

void check_herd(configuration& config) {

for(processes_t::iterator i=config.processes.begin();i!=config.processes.end();++i)

i->second.check(i->first,config);

}

void signal_self(const configuration& config,int signum) {

ifstream pids(config.pidfile.c_str(),ios::in);

if(!pids)

throw runtime_error("Can't detect running instance");

pid_t pid = 0;

pids >> pid;

if(!pid)

throw runtime_error("Can't detect running instance");

if(pid==getpid())

throw 0;

if(kill(pid,signum))

throw runtime_error("Failed to signal running instance");

}

int main(int argc,char **argv) {

try {

_argv = new char*[argc+1];

if(!_argv)

throw runtime_error("memory allocation problem at the very start");

memmove(_argv,argv,sizeof(*_argv)*(argc+1));

string config_file = DEFAULT_CONF_FILE;

enum {

op_default,

op_work,

op_hup,

config.daemonize = true;

}catch(int zero) {

// we throw zero in case we're ensuring that this very process is running.

// we don't have to daemonize if we're daemonic.

config.daemonize = false;

}

case op_default:

case op_work:

{

if(config.daemonize) {

pid_t pf = fork();

if(pf<0)

throw runtime_error(string(__PRETTY_FUNCTION__)+": failed to fork()");

if(pf) {

_exit(0);

}

}

pid_file pidfile;

pidfile.set(config.pidfile);

signal(SIGINT,lethal_signal_handler);

signal(SIGABRT,lethal_signal_handler);

signal(SIGTERM,lethal_signal_handler);

signal(SIGHUP,sighup_handler);

sigset_t sset;

sigemptyset(&sset);

sigaddset(&sset,SIGINT); sigaddset(&sset,SIGABRT);

sigaddset(&sset,SIGTERM); sigaddset(&sset,SIGHUP);

sigprocmask(SIG_UNBLOCK,&sset,NULL);

while(!finishing) {

check_herd(config);

sleep(config.check_interval);

}

}

break;

default:

throw runtime_error(string(__PRETTY_FUNCTION__)+": internal error");

}

}catch(exception& e) {

cerr << "Oops: " << e.what() << endl;

return 1;

}

}