[doldaconnect.git] / daemon / main.c

/*
 *  Dolda Connect - Modular multiuser Direct Connect-style client
 *  Copyright (C) 2004 Fredrik Tolf <fredrik@dolda2000.com>
 *  
 *  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 2 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, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <locale.h>
#include <signal.h>
#include <getopt.h>
#include <time.h>
#include <pwd.h>
#include <grp.h>
#include <sys/wait.h>
#include <stdarg.h>
#include <fcntl.h>
#include <sys/select.h>

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "utils.h"
#include "log.h"
#include "conf.h"
#include "module.h"
#include "net.h"
#include "client.h"
#include "sysevents.h"
#include "auth.h"

#ifdef HAVE_KEYUTILS
#include <keyutils.h>
#endif

struct module *modchain = NULL;
static struct timer *timers = NULL;
static struct child *children = NULL;
volatile int running;
volatile int reinit;
static volatile int childrendone = 0;

struct timer *timercallback(double at, void (*func)(int, void *), void *data)
{
    struct timer *new;
    
    new = smalloc(sizeof(*new));
    new->at = at;
    new->func = func;
    new->data = data;
    new->next = timers;
    new->prev = NULL;
    if(timers != NULL)
	timers->prev = new;
    timers = new;
    return(new);
}

void canceltimer(struct timer *timer)
{
    if(timer->next != NULL)
	timer->next->prev = timer->prev;
    if(timer->prev != NULL)
	timer->prev->next = timer->next;
    if(timer == timers)
	timers = timer->next;
    timer->func(1, timer->data);
    free(timer);
}

void childcallback(pid_t pid, void (*func)(pid_t, int, void *), void *data)
{
    struct child *new;
    
    new = smalloc(sizeof(*new));
    new->pid = pid;
    new->callback = func;
    new->data = data;
    new->finished = 0;
    new->prev = NULL;
    new->next = children;
    if(children != NULL)
	children->prev = new;
    children = new;
}

static void preinit(int hup)
{
    struct module *mod;
    
    for(mod = modchain; mod != NULL; mod = mod->next)
    {
	if(mod->preinit)
	    mod->preinit(hup);
	if(!hup && ((mod->conf.vars != NULL) || (mod->conf.cmds != NULL)))
	    confregmod(&mod->conf);
    }
}

static void init(int hup)
{
    struct module *mod;
    
    for(mod = modchain; mod != NULL; mod = mod->next)
    {
	if(mod->init && mod->init(hup))
	{
	    flog(LOG_CRIT, "initialization of \"%s\" failed", mod->name);
	    exit(1);
	}
    }
}

static void terminate(void)
{
    struct module *mod;
    
    for(mod = modchain; mod != NULL; mod = mod->next)
    {
	if(mod->terminate)
	    mod->terminate();
    }
}

static void handler(int signum)
{
    pid_t pid;
    int status;
    struct child *child;
    FILE *dumpfile;
    extern int numfnetnodes, numtransfers, numdcpeers;
    
    switch(signum)
    {
    case SIGHUP:
	reinit = 1;
	break;
    case SIGINT:
    case SIGTERM:
	running = 0;
	break;
    case SIGCHLD:
	while((pid = waitpid(-1, &status, WNOHANG)) > 0)
	{
	    for(child = children; child != NULL; child = child->next)
	    {
		if(child->pid == pid)
		{
		    child->finished = 1;
		    child->status = status;
		}
	    }
	    childrendone = 1;
	}
	break;
    case SIGUSR1:
	flog(LOG_NOTICE, "forking and dumping core upon SIGUSR1");
	if(fork() == 0)
	    abort();
	break;
    case SIGUSR2:
	flog(LOG_NOTICE, "dumping memstats to /tmp/dc-mem upon SIGUSR2");
	if((dumpfile = fopen("/tmp/dc-mem", "w")) == NULL) {
	    flog(LOG_ERR, "could not dump stats: %s", strerror(errno));
	    break;
	}
	fprintf(dumpfile, "%i %i %i\n", numfnetnodes, numtransfers, numdcpeers);
	fclose(dumpfile);
	break;
    }
}

pid_t forksess(uid_t user, struct authhandle *auth, void (*ccbfunc)(pid_t, int, void *), void *data, ...)
{
    int i, o;
    int cpipe[2];
    struct
    {
	int tfd;
	int fd;
    } *files;
    int maxfd, type, numfiles;
    int acc;
    int *ibuf;
    struct passwd *pwent;
    pid_t pid;
    char *buf;
    va_list args;
    sigset_t sigset;
    int ret, status;
    
    if((pwent = getpwuid(user)) == NULL)
    {
	flog(LOG_WARNING, "no passwd entry for uid %i, cannot fork session", user);
	errno = EACCES;
	return(-1);
    }
    if((geteuid() != 0) && (user != geteuid()))
    {
	flog(LOG_WARNING, "cannot fork non-owning session when not running as root (EUID is %i, target UID is %i)", geteuid(), user);
	errno = EPERM;
	return(-1);
    }
    va_start(args, data);
    numfiles = 0;
    files = NULL;
    maxfd = 0;
    while((type = va_arg(args, int)) != FD_END)
    {
	files = srealloc(files, sizeof(*files) * (numfiles + 1));
	files[numfiles].fd = va_arg(args, int);
	if(files[numfiles].fd > maxfd)
	    maxfd = files[numfiles].fd;
	acc = va_arg(args, int);
	if(type == FD_PIPE)
	{
	    if(pipe(cpipe) < 0)
	    {
		flog(LOG_CRIT, "could not create pipe(!): %s", strerror(errno));
		for(i = 0; i < numfiles; i++)
		    close(files[i].tfd);
		return(-1);
	    }
	    ibuf = va_arg(args, int *);
	    if(acc == O_WRONLY)
	    {
		*ibuf = cpipe[1];
		files[numfiles].tfd = cpipe[0];
	    } else {
		*ibuf = cpipe[0];
		files[numfiles].tfd = cpipe[1];
	    }
	} else if(type == FD_FILE) {
	    buf = va_arg(args, char *);
	    if((files[numfiles].tfd = open(buf, acc)) < 0)
	    {
		flog(LOG_CRIT, "could not open file \"%s\": %s", buf, strerror(errno));
		for(i = 0; i < numfiles; i++)
		    close(files[i].tfd);
		return(-1);
	    }
	}
	if(files[numfiles].tfd > maxfd)
	    maxfd = files[numfiles].tfd;
	numfiles++;
    }
    va_end(args);
    sigemptyset(&sigset);
    sigaddset(&sigset, SIGCHLD);
    sigprocmask(SIG_BLOCK, &sigset, NULL);
    if((pid = fork()) < 0)
    {
	flog(LOG_WARNING, "could not fork(!) in forksess(): %s", strerror(errno));
	for(i = 0; i < numfiles; i++)
	    close(files[i].tfd);
	sigprocmask(SIG_UNBLOCK, &sigset, NULL);
    }
    if(pid == 0)
    {
	sigprocmask(SIG_UNBLOCK, &sigset, NULL);
	signal(SIGPIPE, SIG_DFL);
	signal(SIGCHLD, SIG_DFL);
	signal(SIGINT, SIG_DFL);
	signal(SIGTERM, SIG_DFL);
	signal(SIGHUP, SIG_DFL);
	for(i = 0; i < numfiles; i++)
	{
	    if(dup2(files[i].tfd, maxfd + i + 1) < 0)
		exit(127);
	    files[i].tfd = maxfd + i + 1;
	}
	for(i = 0; i < numfiles; i++)
	{
	    if(dup2(files[i].tfd, files[i].fd) < 0)
		exit(127);
	}
	initlog();
	for(i = 0; i < FD_SETSIZE; i++)
	{
	    if(i <= maxfd)
	    {
		for(o = 0; o < numfiles; o++)
		{
		    if(i == files[o].fd)
			break;
		}
		if(o == numfiles)
		    close(i);
	    } else {
		close(i);
	    }
	}
	setpgid(0, 0);
	signal(SIGHUP, SIG_IGN);
	errno = 0;
#ifdef HAVE_KEYUTILS
	keyctl_join_session_keyring(NULL);
	keyctl_chown(KEY_SPEC_SESSION_KEYRING, pwent->pw_uid, pwent->pw_gid);
#endif
	if((authopensess(auth)) != AUTH_SUCCESS)
	{
	    flog(LOG_WARNING, "could not open session for user %s: %s", pwent->pw_name, (errno == 0)?"Unknown error - should be logged above":strerror(errno));
	    exit(127);
	}
	if((pid = fork()) < 0)
	{
	    authclosesess(auth);
	    exit(127);
	}
	if(pid == 0)
	{
	    if(geteuid() == 0)
	    {
		if(initgroups(pwent->pw_name, pwent->pw_gid))
		{
		    flog(LOG_WARNING, "could not initgroups: %s", strerror(errno));
		    exit(127);
		}
		if(setgid(pwent->pw_gid))
		{
		    flog(LOG_WARNING, "could not setgid: %s", strerror(errno));
		    exit(127);
		}
		if(setuid(pwent->pw_uid))
		{
		    flog(LOG_WARNING, "could not setuid: %s", strerror(errno));
		    exit(127);
		}
		putenv(sprintf2("HOME=%s", pwent->pw_dir));
		putenv(sprintf2("SHELL=%s", pwent->pw_shell));
		putenv(sprintf2("PATH=%s/bin:/usr/local/bin:/bin:/usr/bin", pwent->pw_dir));
	    }
	    putenv(sprintf2("USER=%s", pwent->pw_name));
	    putenv(sprintf2("LOGNAME=%s", pwent->pw_name));
	    chdir(pwent->pw_dir);
	    return(0);
	}
	for(i = 0; i < numfiles; i++)
	    close(files[i].fd);
	while(((ret = waitpid(pid, &status, 0)) != pid) && (ret >= 0));
	authclosesess(auth);
	if(ret < 0)
	{
	    flog(LOG_WARNING, "waitpid(%i) said \"%s\"", pid, strerror(errno));
	    exit(127);
	}
	if(!WIFEXITED(status))
	    exit(127);
	exit(WEXITSTATUS(status));
    }
    for(i = 0; i < numfiles; i++)
	close(files[i].tfd);
    if(files != NULL)
	free(files);
    if(ccbfunc != NULL)
	childcallback(pid, ccbfunc, data);
    sigprocmask(SIG_UNBLOCK, &sigset, NULL);
    return(pid);
}

int main(int argc, char **argv)
{
    int c;
    int nofork;
    char *configfile;
    char *pidfile;
    FILE *pfstream, *confstream;
    int delay, immsyslog;
    struct module *mod;
    struct timer *timer;
    struct child *child;
    double now;
    
    now = ntime();
    immsyslog = nofork = 0;
    syslogfac = LOG_DAEMON;
    configfile = NULL;
    pidfile = NULL;
    while((c = getopt(argc, argv, "p:C:f:hnsV")) != -1)
    {
	switch(c)
	{
	case 'p':
	    pidfile = optarg;
	    break;
	case 'C':
	    configfile = optarg;
	    break;
	case 'f':
	    if(!strcmp(optarg, "auth"))
		syslogfac = LOG_AUTH;
	    else if(!strcmp(optarg, "authpriv"))
		syslogfac = LOG_AUTHPRIV;
	    else if(!strcmp(optarg, "cron"))
		syslogfac = LOG_CRON;
	    else if(!strcmp(optarg, "daemon"))
		syslogfac = LOG_DAEMON;
	    else if(!strcmp(optarg, "ftp"))
		syslogfac = LOG_FTP;
	    else if(!strcmp(optarg, "kern"))
		syslogfac = LOG_KERN;
	    else if(!strcmp(optarg, "lpr"))
		syslogfac = LOG_LPR;
	    else if(!strcmp(optarg, "mail"))
		syslogfac = LOG_MAIL;
	    else if(!strcmp(optarg, "news"))
		syslogfac = LOG_NEWS;
	    else if(!strcmp(optarg, "syslog"))
		syslogfac = LOG_SYSLOG;
	    else if(!strcmp(optarg, "user"))
		syslogfac = LOG_USER;
	    else if(!strcmp(optarg, "uucp"))
		syslogfac = LOG_UUCP;
	    else if(!strncmp(optarg, "local", 5) && (strlen(optarg) == 6))
		syslogfac = LOG_LOCAL0 + (optarg[5] - '0');
	    else
		fprintf(stderr, "unknown syslog facility %s, using daemon\n", optarg);
	    break;
	case 'n':
	    nofork = 1;
	    break;
	case 's':
	    immsyslog = 1;
	    break;
	case 'V':
	    printf("%s", RELEASEINFO);
	    exit(0);
	case 'h':
	case ':':
	case '?':
	default:
	    printf("usage: doldacond [-hnsV] [-C configfile] [-p pidfile] [-f facility]\n");
	    exit(c != 'h');
	}
    }
    setlocale(LC_ALL, "");
    initlog();
    if(immsyslog)
    {
	logtosyslog = 1;
	logtostderr = 0;
    }
    signal(SIGPIPE, SIG_IGN);
    signal(SIGHUP, handler);
    signal(SIGINT, handler);
    signal(SIGTERM, handler);
    signal(SIGCHLD, handler);
    signal(SIGUSR1, handler);
    signal(SIGUSR2, handler);
    preinit(0);
    if(configfile == NULL)
    {
	if((configfile = findfile("doldacond.conf", NULL, 0)) == NULL)
	{
	    flog(LOG_CRIT, "could not find a configuration file");
	    exit(1);
	}
    }
    pfstream = NULL;
    if(pidfile != NULL)
    {
	if((pfstream = fopen(pidfile, "w")) == NULL)
	{
	    flog(LOG_CRIT, "could not open specified PID file %s: %s", pidfile, strerror(errno));
	    exit(1);
	}
    }
    if((confstream = fopen(configfile, "r")) == NULL)
    {
	flog(LOG_CRIT, "could not open configuration file %s: %s", configfile, strerror(errno));
	exit(1);
    }
    readconfig(confstream);
    fclose(confstream);
    init(0);
    if(!nofork)
    {
	logtosyslog = 1;
	daemon(0, 0);
	flog(LOG_INFO, "daemonized");
	logtostderr = 0;
    }
    if(pfstream != NULL) {
	fprintf(pfstream, "%i\n", getpid());
	fclose(pfstream);
    }
    flog(LOG_INFO, "startup took %f seconds", ntime() - now);
    running = 1;
    reinit = 0;
    while(running)
    {
	if(reinit)
	{
	    if((confstream = fopen(configfile, "r")) == NULL)
	    {
		flog(LOG_ERR, "could not open configuration file %s: %s (ignoring HUP)", configfile, strerror(errno));
	    } else {
		preinit(1);
		readconfig(confstream);
		fclose(confstream);
		init(1);
	    }
	    reinit = 0;
	}
	delay = 1000; /* -1; */
	for(mod = modchain; mod != NULL; mod = mod->next)
	{
	    if(mod->run && mod->run())
		delay = 0;
	}
	if(!running)
	    delay = 0;
	if(delay != 0)
	{
	    now = ntime();
	    for(timer = timers; timer != NULL; timer = timer->next)
	    {
		if((delay == -1) || ((int)((timer->at - now) * 1000.0) < delay))
		    delay = (int)((timer->at - now) * 1000.0);
	    }
	}
	if(childrendone)
	{
	    delay = 0;
	    childrendone = 0;
	}
	pollsocks(delay);
	now = ntime();
	do
	{
	    for(timer = timers; timer != NULL; timer = timer->next)
	    {
		if(now < timer->at)
		    continue;
		if(timer->prev != NULL)
		    timer->prev->next = timer->next;
		if(timer->next != NULL)
		    timer->next->prev = timer->prev;
		if(timer == timers)
		    timers = timer->next;
		timer->func(0, timer->data);
		free(timer);
		break;
	    }
	} while(timer != NULL);
	do
	{
	    for(child = children; child != NULL; child = child->next)
	    {
		if(child->finished)
		{
		    child->callback(child->pid, child->status, child->data);
		    if(child == children)
			children = child->next;
		    if(child->prev != NULL)
			child->prev->next = child->next;
		    if(child->next != NULL)
			child->next->prev = child->prev;
		    free(child);
		    break;
		}
	    }
	} while(child != NULL);
    }
    flog(LOG_INFO, "terminating...");
    terminate();
    if(pidfile != NULL)
	unlink(pidfile);
    return(0);
}
Commit	Line	Data
	1	/*
	2	* Dolda Connect - Modular multiuser Direct Connect-style client
	3	* Copyright (C) 2004 Fredrik Tolf <fredrik@dolda2000.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*/
	19	#include <stdio.h>
	20	#include <unistd.h>
	21	#include <stdlib.h>
	22	#include <string.h>
	23	#include <errno.h>
	24	#include <locale.h>
	25	#include <signal.h>
	26	#include <getopt.h>
	27	#include <time.h>
	28	#include <pwd.h>
	29	#include <grp.h>
	30	#include <sys/wait.h>
	31	#include <stdarg.h>
	32	#include <fcntl.h>
	33	#include <sys/select.h>
	34
	35	#ifdef HAVE_CONFIG_H
	36	#include <config.h>
	37	#endif
	38	#include "utils.h"
	39	#include "log.h"
	40	#include "conf.h"
	41	#include "module.h"
	42	#include "net.h"
	43	#include "client.h"
	44	#include "sysevents.h"
	45	#include "auth.h"
	46
	47	#ifdef HAVE_KEYUTILS
	48	#include <keyutils.h>
	49	#endif
	50
	51	struct module *modchain = NULL;
	52	static struct timer *timers = NULL;
	53	static struct child *children = NULL;
	54	volatile int running;
	55	volatile int reinit;
	56	static volatile int childrendone = 0;
	57
	58	struct timer timercallback(double at, void (func)(int, void ), void data)
	59	{
	60	struct timer *new;
	61
	62	new = smalloc(sizeof(*new));
	63	new->at = at;
	64	new->func = func;
	65	new->data = data;
	66	new->next = timers;
	67	new->prev = NULL;
	68	if(timers != NULL)
	69	timers->prev = new;
	70	timers = new;
	71	return(new);
	72	}
	73
	74	void canceltimer(struct timer *timer)
	75	{
	76	if(timer->next != NULL)
	77	timer->next->prev = timer->prev;
	78	if(timer->prev != NULL)
	79	timer->prev->next = timer->next;
	80	if(timer == timers)
	81	timers = timer->next;
	82	timer->func(1, timer->data);
	83	free(timer);
	84	}
	85
	86	void childcallback(pid_t pid, void (func)(pid_t, int, void ), void *data)
	87	{
	88	struct child *new;
	89
	90	new = smalloc(sizeof(*new));
	91	new->pid = pid;
	92	new->callback = func;
	93	new->data = data;
	94	new->finished = 0;
	95	new->prev = NULL;
	96	new->next = children;
	97	if(children != NULL)
	98	children->prev = new;
	99	children = new;
	100	}
	101
	102	static void preinit(int hup)
	103	{
	104	struct module *mod;
	105
	106	for(mod = modchain; mod != NULL; mod = mod->next)
	107	{
	108	if(mod->preinit)
	109	mod->preinit(hup);
	110	if(!hup && ((mod->conf.vars != NULL) \|\| (mod->conf.cmds != NULL)))
	111	confregmod(&mod->conf);
	112	}
	113	}
	114
	115	static void init(int hup)
	116	{
	117	struct module *mod;
	118
	119	for(mod = modchain; mod != NULL; mod = mod->next)
	120	{
	121	if(mod->init && mod->init(hup))
	122	{
	123	flog(LOG_CRIT, "initialization of \"%s\" failed", mod->name);
	124	exit(1);
	125	}
	126	}
	127	}
	128
	129	static void terminate(void)
	130	{
	131	struct module *mod;
	132
	133	for(mod = modchain; mod != NULL; mod = mod->next)
	134	{
	135	if(mod->terminate)
	136	mod->terminate();
	137	}
	138	}
	139
	140	static void handler(int signum)
	141	{
	142	pid_t pid;
	143	int status;
	144	struct child *child;
	145	FILE *dumpfile;
	146	extern int numfnetnodes, numtransfers, numdcpeers;
	147
	148	switch(signum)
	149	{
	150	case SIGHUP:
	151	reinit = 1;
	152	break;
	153	case SIGINT:
	154	case SIGTERM:
	155	running = 0;
	156	break;
	157	case SIGCHLD:
	158	while((pid = waitpid(-1, &status, WNOHANG)) > 0)
	159	{
	160	for(child = children; child != NULL; child = child->next)
	161	{
	162	if(child->pid == pid)
	163	{
	164	child->finished = 1;
	165	child->status = status;
	166	}
	167	}
	168	childrendone = 1;
	169	}
	170	break;
	171	case SIGUSR1:
	172	flog(LOG_NOTICE, "forking and dumping core upon SIGUSR1");
	173	if(fork() == 0)
	174	abort();
	175	break;
	176	case SIGUSR2:
	177	flog(LOG_NOTICE, "dumping memstats to /tmp/dc-mem upon SIGUSR2");
	178	if((dumpfile = fopen("/tmp/dc-mem", "w")) == NULL) {
	179	flog(LOG_ERR, "could not dump stats: %s", strerror(errno));
	180	break;
	181	}
	182	fprintf(dumpfile, "%i %i %i\n", numfnetnodes, numtransfers, numdcpeers);
	183	fclose(dumpfile);
	184	break;
	185	}
	186	}
	187
	188	pid_t forksess(uid_t user, struct authhandle auth, void (ccbfunc)(pid_t, int, void ), void data, ...)
	189	{
	190	int i, o;
	191	int cpipe[2];
	192	struct
	193	{
	194	int tfd;
	195	int fd;
	196	} *files;
	197	int maxfd, type, numfiles;
	198	int acc;
	199	int *ibuf;
	200	struct passwd *pwent;
	201	pid_t pid;
	202	char *buf;
	203	va_list args;
	204	sigset_t sigset;
	205	int ret, status;
	206
	207	if((pwent = getpwuid(user)) == NULL)
	208	{
	209	flog(LOG_WARNING, "no passwd entry for uid %i, cannot fork session", user);
	210	errno = EACCES;
	211	return(-1);
	212	}
	213	if((geteuid() != 0) && (user != geteuid()))
	214	{
	215	flog(LOG_WARNING, "cannot fork non-owning session when not running as root (EUID is %i, target UID is %i)", geteuid(), user);
	216	errno = EPERM;
	217	return(-1);
	218	}
	219	va_start(args, data);
	220	numfiles = 0;
	221	files = NULL;
	222	maxfd = 0;
	223	while((type = va_arg(args, int)) != FD_END)
	224	{
	225	files = srealloc(files, sizeof(files) (numfiles + 1));
	226	files[numfiles].fd = va_arg(args, int);
	227	if(files[numfiles].fd > maxfd)
	228	maxfd = files[numfiles].fd;
	229	acc = va_arg(args, int);
	230	if(type == FD_PIPE)
	231	{
	232	if(pipe(cpipe) < 0)
	233	{
	234	flog(LOG_CRIT, "could not create pipe(!): %s", strerror(errno));
	235	for(i = 0; i < numfiles; i++)
	236	close(files[i].tfd);
	237	return(-1);
	238	}
	239	ibuf = va_arg(args, int *);
	240	if(acc == O_WRONLY)
	241	{
	242	*ibuf = cpipe[1];
	243	files[numfiles].tfd = cpipe[0];
	244	} else {
	245	*ibuf = cpipe[0];
	246	files[numfiles].tfd = cpipe[1];
	247	}
	248	} else if(type == FD_FILE) {
	249	buf = va_arg(args, char *);
	250	if((files[numfiles].tfd = open(buf, acc)) < 0)
	251	{
	252	flog(LOG_CRIT, "could not open file \"%s\": %s", buf, strerror(errno));
	253	for(i = 0; i < numfiles; i++)
	254	close(files[i].tfd);
	255	return(-1);
	256	}
	257	}
	258	if(files[numfiles].tfd > maxfd)
	259	maxfd = files[numfiles].tfd;
	260	numfiles++;
	261	}
	262	va_end(args);
	263	sigemptyset(&sigset);
	264	sigaddset(&sigset, SIGCHLD);
	265	sigprocmask(SIG_BLOCK, &sigset, NULL);
	266	if((pid = fork()) < 0)
	267	{
	268	flog(LOG_WARNING, "could not fork(!) in forksess(): %s", strerror(errno));
	269	for(i = 0; i < numfiles; i++)
	270	close(files[i].tfd);
	271	sigprocmask(SIG_UNBLOCK, &sigset, NULL);
	272	}
	273	if(pid == 0)
	274	{
	275	sigprocmask(SIG_UNBLOCK, &sigset, NULL);
	276	signal(SIGPIPE, SIG_DFL);
	277	signal(SIGCHLD, SIG_DFL);
	278	signal(SIGINT, SIG_DFL);
	279	signal(SIGTERM, SIG_DFL);
	280	signal(SIGHUP, SIG_DFL);
	281	for(i = 0; i < numfiles; i++)
	282	{
	283	if(dup2(files[i].tfd, maxfd + i + 1) < 0)
	284	exit(127);
	285	files[i].tfd = maxfd + i + 1;
	286	}
	287	for(i = 0; i < numfiles; i++)
	288	{
	289	if(dup2(files[i].tfd, files[i].fd) < 0)
	290	exit(127);
	291	}
	292	initlog();
	293	for(i = 0; i < FD_SETSIZE; i++)
	294	{
	295	if(i <= maxfd)
	296	{
	297	for(o = 0; o < numfiles; o++)
	298	{
	299	if(i == files[o].fd)
	300	break;
	301	}
	302	if(o == numfiles)
	303	close(i);
	304	} else {
	305	close(i);
	306	}
	307	}
	308	setpgid(0, 0);
	309	signal(SIGHUP, SIG_IGN);
	310	errno = 0;
	311	#ifdef HAVE_KEYUTILS
	312	keyctl_join_session_keyring(NULL);
	313	keyctl_chown(KEY_SPEC_SESSION_KEYRING, pwent->pw_uid, pwent->pw_gid);
	314	#endif
	315	if((authopensess(auth)) != AUTH_SUCCESS)
	316	{
	317	flog(LOG_WARNING, "could not open session for user %s: %s", pwent->pw_name, (errno == 0)?"Unknown error - should be logged above":strerror(errno));
	318	exit(127);
	319	}
	320	if((pid = fork()) < 0)
	321	{
	322	authclosesess(auth);
	323	exit(127);
	324	}
	325	if(pid == 0)
	326	{
	327	if(geteuid() == 0)
	328	{
	329	if(initgroups(pwent->pw_name, pwent->pw_gid))
	330	{
	331	flog(LOG_WARNING, "could not initgroups: %s", strerror(errno));
	332	exit(127);
	333	}
	334	if(setgid(pwent->pw_gid))
	335	{
	336	flog(LOG_WARNING, "could not setgid: %s", strerror(errno));
	337	exit(127);
	338	}
	339	if(setuid(pwent->pw_uid))
	340	{
	341	flog(LOG_WARNING, "could not setuid: %s", strerror(errno));
	342	exit(127);
	343	}
	344	putenv(sprintf2("HOME=%s", pwent->pw_dir));
	345	putenv(sprintf2("SHELL=%s", pwent->pw_shell));
	346	putenv(sprintf2("PATH=%s/bin:/usr/local/bin:/bin:/usr/bin", pwent->pw_dir));
	347	}
	348	putenv(sprintf2("USER=%s", pwent->pw_name));
	349	putenv(sprintf2("LOGNAME=%s", pwent->pw_name));
	350	chdir(pwent->pw_dir);
	351	return(0);
	352	}
	353	for(i = 0; i < numfiles; i++)
	354	close(files[i].fd);
	355	while(((ret = waitpid(pid, &status, 0)) != pid) && (ret >= 0));
	356	authclosesess(auth);
	357	if(ret < 0)
	358	{
	359	flog(LOG_WARNING, "waitpid(%i) said \"%s\"", pid, strerror(errno));
	360	exit(127);
	361	}
	362	if(!WIFEXITED(status))
	363	exit(127);
	364	exit(WEXITSTATUS(status));
	365	}
	366	for(i = 0; i < numfiles; i++)
	367	close(files[i].tfd);
	368	if(files != NULL)
	369	free(files);
	370	if(ccbfunc != NULL)
	371	childcallback(pid, ccbfunc, data);
	372	sigprocmask(SIG_UNBLOCK, &sigset, NULL);
	373	return(pid);
	374	}
	375
	376	int main(int argc, char **argv)
	377	{
	378	int c;
	379	int nofork;
	380	char *configfile;
	381	char *pidfile;
	382	FILE pfstream, confstream;
	383	int delay, immsyslog;
	384	struct module *mod;
	385	struct timer *timer;
	386	struct child *child;
	387	double now;
	388
	389	now = ntime();
	390	immsyslog = nofork = 0;
	391	syslogfac = LOG_DAEMON;
	392	configfile = NULL;
	393	pidfile = NULL;
	394	while((c = getopt(argc, argv, "p:C:f:hnsV")) != -1)
	395	{
	396	switch(c)
	397	{
	398	case 'p':
	399	pidfile = optarg;
	400	break;
	401	case 'C':
	402	configfile = optarg;
	403	break;
	404	case 'f':
	405	if(!strcmp(optarg, "auth"))
	406	syslogfac = LOG_AUTH;
	407	else if(!strcmp(optarg, "authpriv"))
	408	syslogfac = LOG_AUTHPRIV;
	409	else if(!strcmp(optarg, "cron"))
	410	syslogfac = LOG_CRON;
	411	else if(!strcmp(optarg, "daemon"))
	412	syslogfac = LOG_DAEMON;
	413	else if(!strcmp(optarg, "ftp"))
	414	syslogfac = LOG_FTP;
	415	else if(!strcmp(optarg, "kern"))
	416	syslogfac = LOG_KERN;
	417	else if(!strcmp(optarg, "lpr"))
	418	syslogfac = LOG_LPR;
	419	else if(!strcmp(optarg, "mail"))
	420	syslogfac = LOG_MAIL;
	421	else if(!strcmp(optarg, "news"))
	422	syslogfac = LOG_NEWS;
	423	else if(!strcmp(optarg, "syslog"))
	424	syslogfac = LOG_SYSLOG;
	425	else if(!strcmp(optarg, "user"))
	426	syslogfac = LOG_USER;
	427	else if(!strcmp(optarg, "uucp"))
	428	syslogfac = LOG_UUCP;
	429	else if(!strncmp(optarg, "local", 5) && (strlen(optarg) == 6))
	430	syslogfac = LOG_LOCAL0 + (optarg[5] - '0');
	431	else
	432	fprintf(stderr, "unknown syslog facility %s, using daemon\n", optarg);
	433	break;
	434	case 'n':
	435	nofork = 1;
	436	break;
	437	case 's':
	438	immsyslog = 1;
	439	break;
	440	case 'V':
	441	printf("%s", RELEASEINFO);
	442	exit(0);
	443	case 'h':
	444	case ':':
	445	case '?':
	446	default:
	447	printf("usage: doldacond [-hnsV] [-C configfile] [-p pidfile] [-f facility]\n");
	448	exit(c != 'h');
	449	}
	450	}
	451	setlocale(LC_ALL, "");
	452	initlog();
	453	if(immsyslog)
	454	{
	455	logtosyslog = 1;
	456	logtostderr = 0;
	457	}
	458	signal(SIGPIPE, SIG_IGN);
	459	signal(SIGHUP, handler);
	460	signal(SIGINT, handler);
	461	signal(SIGTERM, handler);
	462	signal(SIGCHLD, handler);
	463	signal(SIGUSR1, handler);
	464	signal(SIGUSR2, handler);
	465	preinit(0);
	466	if(configfile == NULL)
	467	{
	468	if((configfile = findfile("doldacond.conf", NULL, 0)) == NULL)
	469	{
	470	flog(LOG_CRIT, "could not find a configuration file");
	471	exit(1);
	472	}
	473	}
	474	pfstream = NULL;
	475	if(pidfile != NULL)
	476	{
	477	if((pfstream = fopen(pidfile, "w")) == NULL)
	478	{
	479	flog(LOG_CRIT, "could not open specified PID file %s: %s", pidfile, strerror(errno));
	480	exit(1);
	481	}
	482	}
	483	if((confstream = fopen(configfile, "r")) == NULL)
	484	{
	485	flog(LOG_CRIT, "could not open configuration file %s: %s", configfile, strerror(errno));
	486	exit(1);
	487	}
	488	readconfig(confstream);
	489	fclose(confstream);
	490	init(0);
	491	if(!nofork)
	492	{
	493	logtosyslog = 1;
	494	daemon(0, 0);
	495	flog(LOG_INFO, "daemonized");
	496	logtostderr = 0;
	497	}
	498	if(pfstream != NULL) {
	499	fprintf(pfstream, "%i\n", getpid());
	500	fclose(pfstream);
	501	}
	502	flog(LOG_INFO, "startup took %f seconds", ntime() - now);
	503	running = 1;
	504	reinit = 0;
	505	while(running)
	506	{
	507	if(reinit)
	508	{
	509	if((confstream = fopen(configfile, "r")) == NULL)
	510	{
	511	flog(LOG_ERR, "could not open configuration file %s: %s (ignoring HUP)", configfile, strerror(errno));
	512	} else {
	513	preinit(1);
	514	readconfig(confstream);
	515	fclose(confstream);
	516	init(1);
	517	}
	518	reinit = 0;
	519	}
	520	delay = 1000; /* -1; */
	521	for(mod = modchain; mod != NULL; mod = mod->next)
	522	{
	523	if(mod->run && mod->run())
	524	delay = 0;
	525	}
	526	if(!running)
	527	delay = 0;
	528	if(delay != 0)
	529	{
	530	now = ntime();
	531	for(timer = timers; timer != NULL; timer = timer->next)
	532	{
	533	if((delay == -1) \|\| ((int)((timer->at - now) * 1000.0) < delay))
	534	delay = (int)((timer->at - now) * 1000.0);
	535	}
	536	}
	537	if(childrendone)
	538	{
	539	delay = 0;
	540	childrendone = 0;
	541	}
	542	pollsocks(delay);
	543	now = ntime();
	544	do
	545	{
	546	for(timer = timers; timer != NULL; timer = timer->next)
	547	{
	548	if(now < timer->at)
	549	continue;
	550	if(timer->prev != NULL)
	551	timer->prev->next = timer->next;
	552	if(timer->next != NULL)
	553	timer->next->prev = timer->prev;
	554	if(timer == timers)
	555	timers = timer->next;
	556	timer->func(0, timer->data);
	557	free(timer);
	558	break;
	559	}
	560	} while(timer != NULL);
	561	do
	562	{
	563	for(child = children; child != NULL; child = child->next)
	564	{
	565	if(child->finished)
	566	{
	567	child->callback(child->pid, child->status, child->data);
	568	if(child == children)
	569	children = child->next;
	570	if(child->prev != NULL)
	571	child->prev->next = child->next;
	572	if(child->next != NULL)
	573	child->next->prev = child->prev;
	574	free(child);
	575	break;
	576	}
	577	}
	578	} while(child != NULL);
	579	}
	580	flog(LOG_INFO, "terminating...");
	581	terminate();
	582	if(pidfile != NULL)
	583	unlink(pidfile);
	584	return(0);
	585	}