deb-mbse/mbtask/mbtask.c

/*****************************************************************************
 *
 * $Id$
 * Purpose ...............: MBSE BBS Task Manager
 *
 *****************************************************************************
 * Copyright (C) 1997-2002
 *   
 * Michiel Broek		FIDO:		2:280/2802
 * Beekmansbos 10
 * 1971 BV IJmuiden
 * the Netherlands
 *
 * This file is part of MBSE BBS.
 *
 * This BBS 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, or (at your option) any
 * later version.
 *
 * MBSE BBS 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 MBSE BBS; see the file COPYING.  If not, write to the Free
 * Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 *****************************************************************************/

#include "libs.h"
#include "../lib/structs.h"
#include "signame.h"
#include "taskstat.h"
#include "taskutil.h"
#include "taskregs.h"
#include "taskcomm.h"
#include "callstat.h"
#include "outstat.h"
#include "nodelist.h"
#include "mbtask.h"



/*
 *  Defines. 
 *  SLOWRUN is number of seconds for scheduling mailer calls. Leave at 20!
 */
#define	MAXTASKS		10
#define	SLOWRUN			20
#define TMPNAME 		"TMP."
#define LCKNAME			"LOCKTASK"
#define ICMP_BASEHDR_LEN	8
#define ICMP_MAX_ERRS		5
#define SET_SOCKA_LEN4(socka)


typedef enum {P_INIT, P_SENT, P_FAIL, P_OK, P_ERROR, P_NONE} PINGSTATE;



/*
 *  Global variables
 */
static onetask		task[MAXTASKS];		/* Array with tasks	*/
static tocall		calllist[MAXTASKS];	/* Array with calllist	*/
reg_info		reginfo[MAXCLIENT];	/* Array with clients	*/
static pid_t		pgrp;			/* Pids group		*/
static char		lockfile[PATH_MAX];	/* Lockfile 		*/
int			sock = -1;		/* Datagram socket	*/
struct sockaddr_un	servaddr;		/* Server address	*/
struct sockaddr_un	from;			/* From address		*/
int			fromlen;
static char		spath[PATH_MAX];	/* Socket path		*/
int			logtrans = 0;		/* Log transactions	*/
struct taskrec		TCFG;			/* Task config record	*/
struct sysconfig	CFG;			/* System config	*/
struct _nodeshdr	nodeshdr;		/* Nodes header record	*/
struct _nodes		nodes;			/* Nodes data record	*/
struct _fidonethdr	fidonethdr;		/* Fidonet header rec.	*/
struct _fidonet		fidonet;		/* Fidonet data record	*/
time_t			tcfg_time;		/* Config record time	*/
time_t			cfg_time;		/* Config record time	*/
time_t			tty_time;		/* TTY config time	*/
char			tcfgfn[PATH_MAX];	/* Config file name	*/
char			cfgfn[PATH_MAX];	/* Config file name	*/
char			ttyfn[PATH_MAX];	/* TTY file name	*/
int     		ping_isocket;		/* Ping socket		*/
int     		icmp_errs = 0;		/* ICMP error counter	*/
int			internet = FALSE;	/* Internet is down	*/
double			Load;			/* System Load		*/
int			Processing;		/* Is system running	*/
int			ZMH = FALSE;		/* Zone Mail Hour	*/
int			UPSalarm = FALSE;	/* UPS alarm status	*/
extern int		s_bbsopen;		/* BBS open semafore	*/
extern int		s_scanout;		/* Scan outbound sema	*/
extern int		s_mailout;		/* Mail out semafore	*/
extern int		s_mailin;		/* Mail in semafore	*/
extern int		s_index;		/* Compile nl semafore	*/
extern int		s_newnews;		/* New news semafore	*/
extern int		s_reqindex;		/* Create req index sem */
extern int		s_msglink;		/* Messages link sem	*/
extern int		s_do_inet;		/* Internet wanted	*/
int			pingstate = P_INIT;	/* Ping state		*/
int			pingnr = 1;		/* Ping #, 1 or 2	*/
int			pingresult[2];		/* Ping results		*/
char			pingaddress[41];	/* Ping current address	*/
int			masterinit = FALSE;	/* Master init needed	*/
int			ptimer = PAUSETIME;	/* Pause timer		*/
int			tflags = FALSE;		/* if nodes with Txx	*/
extern int		nxt_hour;		/* Next event hour	*/
extern int		nxt_min;		/* Next event minute	*/
extern _alist_l		*alist;			/* Nodes to call list	*/
extern int		pots_calls;
extern int		isdn_calls;
extern int		inet_calls;



/*
 *  Load main configuration, if it doesn't exist, create it.
 *  This is the case the very first time when you start MBSE BBS.
 */
void load_maincfg(void)
{
	FILE		*fp;
	struct utsname	un;
	int		i;

        if ((fp = fopen(cfgfn, "r")) == NULL) {
		masterinit = TRUE;
                memset(&CFG, 0, sizeof(CFG));

                /*
                 * Fill Registration defaults
                 */
                sprintf(CFG.bbs_name, "MBSE BBS");
                uname((struct utsname *)&un); 
#ifdef __USE_GNU
                sprintf(CFG.sysdomain, "%s.%s", un.nodename, un.domainname); 
#else
#ifdef __linux__
                sprintf(CFG.sysdomain, "%s.%s", un.nodename, un.__domainname);
#endif
#endif
                sprintf(CFG.comment, "MBSE BBS development");
                sprintf(CFG.origin, "MBSE BBS. Made in the Netherlands");
                sprintf(CFG.location, "Earth");

                /*
                 * Fill Filenames defaults
                 */
                sprintf(CFG.logfile, "system.log");
                sprintf(CFG.error_log, "error.log");
                sprintf(CFG.default_menu, "main.mnu");
                sprintf(CFG.current_language, "english.lang");
                sprintf(CFG.chat_log, "chat.log");
                sprintf(CFG.welcome_logo, "logo.asc");

                /*
                 * Fill Global defaults
                 */
                sprintf(CFG.bbs_menus, "%s/english/menus", getenv("MBSE_ROOT"));
                sprintf(CFG.bbs_txtfiles, "%s/english/txtfiles", getenv("MBSE_ROOT"));
                sprintf(CFG.bbs_usersdir, "%s/home", getenv("MBSE_ROOT"));
                sprintf(CFG.nodelists, "%s/var/nodelist", getenv("MBSE_ROOT"));
                sprintf(CFG.inbound, "%s/var/unknown", getenv("MBSE_ROOT"));
                sprintf(CFG.pinbound, "%s/var/inbound", getenv("MBSE_ROOT"));
                sprintf(CFG.outbound, "%s/var/bso/outbound", getenv("MBSE_ROOT"));
		sprintf(CFG.msgs_path, "%s/var/msgs", getenv("MBSE_ROOT"));
                sprintf(CFG.uxpath, "%s", getenv("MBSE_ROOT"));
                sprintf(CFG.badtic, "%s/var/badtic", getenv("MBSE_ROOT"));
                sprintf(CFG.ticout, "%s/var/ticqueue", getenv("MBSE_ROOT"));
                sprintf(CFG.req_magic, "%s/magic", getenv("MBSE_ROOT"));
		CFG.leavecase = TRUE;

                /*
                 * Newfiles reports
                 */
                sprintf(CFG.ftp_base, "%s/ftp", getenv("MBSE_ROOT"));
                CFG.newdays = 30;
                CFG.security.level = 20;
                CFG.new_split = 27;
                CFG.new_force = 30;

                /*
                 * BBS Globals
                 */
                CFG.CityLen = 6;
                CFG.max_login = 5;
                CFG.exclude_sysop = TRUE;
                CFG.iConnectString = FALSE;
                CFG.iAskFileProtocols = FALSE;
                CFG.sysop_access = 32000;
                CFG.password_length = 4;
                CFG.iPasswd_Char = '.';
                CFG.idleout = 3;
                CFG.iQuota = 10;
                CFG.iCRLoginCount = 10;
                CFG.bbs_loglevel = DLOG_ALLWAYS | DLOG_ERROR | DLOG_ATTENT | DLOG_NORMAL | DLOG_VERBOSE;
                CFG.util_loglevel = DLOG_ALLWAYS | DLOG_ERROR | DLOG_ATTENT | DLOG_NORMAL | DLOG_VERBOSE;
                CFG.OLR_NewFileLimit = 30;
                CFG.OLR_MaxReq = 25;
                CFG.slow_util = TRUE;
                CFG.iCrashLevel = 100;
                CFG.iAttachLevel = 100;
                CFG.new_groups = 25;

                CFG.slow_util = TRUE;
                CFG.iCrashLevel = 100;
                CFG.iAttachLevel = 100;
                CFG.new_groups = 25;
                sprintf(CFG.startname, "bbs");
                CFG.freespace = 10;

                /*
                 * New Users
                 */
                CFG.newuser_access.level = 20;
                CFG.iCapUserName = TRUE;
                CFG.iAnsi = TRUE;
                CFG.iDataPhone = TRUE;
                CFG.iVoicePhone = TRUE;
                CFG.iDOB = TRUE;
                CFG.iTelephoneScan = TRUE;
                CFG.iLocation = TRUE;
                CFG.iHotkeys = TRUE;
                CFG.iCapLocation = FALSE;
                CFG.AskAddress = TRUE;
                CFG.GiveEmail = TRUE;

                /*
                 * Colors
                 */
                CFG.TextColourF         = 3;
                CFG.TextColourB         = 0;
                CFG.UnderlineColourF    = 14;
                CFG.UnderlineColourB    = 0;
                CFG.InputColourF        = 11;
                CFG.InputColourB        = 0;
                CFG.CRColourF           = 15;
                CFG.CRColourB           = 0;
                CFG.MoreF               = 13;
                CFG.MoreB               = 0;
                CFG.HiliteF             = 15;
                CFG.HiliteB             = 0;
                CFG.FilenameF           = 14;
                CFG.FilenameB           = 0;
                CFG.FilesizeF           = 13;
                CFG.FilesizeB           = 0;
                CFG.FiledateF           = 10;
                CFG.FiledateB           = 0;
                CFG.FiledescF           = 3;
                CFG.FiledescB           = 0;
                CFG.MsgInputColourF     = 3;
                CFG.MsgInputColourB     = 0;

                /*
                 * NextUser Door
                 */
                sprintf(CFG.sNuScreen, "welcome");
                sprintf(CFG.sNuQuote, "Please press [ENTER] to continue: ");

                /*
                 * Safe Door
                 */
                CFG.iSafeFirstDigit     = 1;
                CFG.iSafeSecondDigit    = 2;
                CFG.iSafeThirdDigit     = 3;
                CFG.iSafeMaxTrys        = 4;
                CFG.iSafeMaxNumber      = 20;
                CFG.iSafeNumGen         = FALSE;
                strcpy(CFG.sSafePrize, "Free access for a year!");
                sprintf(CFG.sSafeWelcome, "safewel");
                sprintf(CFG.sSafeOpened, "safeopen");

                /*
                 * Paging
                 */
                CFG.iPageLength         = 30;
                CFG.iMaxPageTimes       = 5;
                CFG.iAskReason          = TRUE;
                CFG.iSysopArea          = 1;
                CFG.iExternalChat       = FALSE;
                strcpy(CFG.sExternalChat, "/usr/local/bin/chat");
                CFG.iAutoLog            = TRUE;
                strcpy(CFG.sChatDevice, "/dev/tty01");
                CFG.iChatPromptChk      = TRUE;
                CFG.iStopChatTime       = TRUE;
                for (i = 0; i < 7; i++) {
                        sprintf(CFG.cStartTime[i], "18:00");
                        sprintf(CFG.cStopTime[i], "23:59");
                }

                /*
                 * Time Bank
                 */
                CFG.iMaxTimeBalance     = 200;
                CFG.iMaxTimeWithdraw    = 100;
                CFG.iMaxTimeDeposit     = 60;
                CFG.iMaxByteBalance     = 500;
                CFG.iMaxByteWithdraw    = 300;
                CFG.iMaxByteDeposit     = 150;
                strcpy(CFG.sTimeRatio, "3:1");
                strcpy(CFG.sByteRatio, "3:1");

                /*
                 * Fill ticconf defaults
                 */
                CFG.ct_ResFuture = TRUE;
                CFG.ct_ReplExt = TRUE;
                CFG.ct_PlusAll = TRUE;
                CFG.ct_Notify = TRUE;
                CFG.ct_Message = TRUE;
                CFG.ct_TIC = TRUE;
                CFG.tic_days = 30;
                sprintf(CFG.hatchpasswd, "DizIzMyBIGseeKret");
                CFG.drspace = 2048;
                CFG.tic_systems = 10;
                CFG.tic_groups  = 25;
                CFG.tic_dupes   = 16000;

                /*
                 * Fill Mail defaults
                 */
                CFG.maxpktsize = 150;
                CFG.maxarcsize = 300;
                sprintf(CFG.badboard, "%s/var/mail/badmail", getenv("MBSE_ROOT"));
                sprintf(CFG.dupboard, "%s/var/mail/dupemail", getenv("MBSE_ROOT"));
                sprintf(CFG.popnode, "localhost");
                sprintf(CFG.smtpnode, "localhost");
                sprintf(CFG.nntpnode, "localhost");
                CFG.toss_days = 30;
                CFG.toss_dupes = 16000;
                CFG.toss_old = 60;
                CFG.defmsgs = 500;
                CFG.defdays = 90;
                CFG.toss_systems = 10;
                CFG.toss_groups = 25;
                CFG.UUCPgate.zone = 2;
                CFG.UUCPgate.net  = 292;
                CFG.UUCPgate.node = 875;
                sprintf(CFG.UUCPgate.domain, "fidonet");
                CFG.nntpdupes = 16000;

                for (i = 0; i < 32; i++) 
                        sprintf(CFG.fname[i], "Flag %d", i+1);


                /*
                 * Fido mailer defaults
                 */
                CFG.timeoutreset = 3L;
                CFG.timeoutconnect = 60L;
                sprintf(CFG.phonetrans[0].match, "31-255");
                sprintf(CFG.phonetrans[1].match, "31-");
                sprintf(CFG.phonetrans[1].repl, "0");
                sprintf(CFG.phonetrans[2].repl, "00");
                CFG.Speed = 9600;
                CFG.dialdelay = 60;
                sprintf(CFG.Flags, "CM,XX,IBN,IFC,ITN");
                CFG.cico_loglevel = DLOG_ALLWAYS | DLOG_ERROR | DLOG_ATTENT | DLOG_NORMAL | DLOG_VERBOSE;

                /*
                 * FTP Server
                 */
                CFG.ftp_limit = 20;
                CFG.ftp_loginfails = 2;
                CFG.ftp_compress = TRUE;
                CFG.ftp_tar = TRUE;
                CFG.ftp_log_cmds = TRUE;
                CFG.ftp_anonymousok = TRUE;
                CFG.ftp_mbseok = FALSE;
                sprintf(CFG.ftp_readme_login, "README*");
                sprintf(CFG.ftp_readme_cwd, "README*");
                sprintf(CFG.ftp_msg_login, "/welcome.msg");
                sprintf(CFG.ftp_msg_cwd, ".message");
                sprintf(CFG.ftp_msg_shutmsg, "/etc/nologin");
                sprintf(CFG.ftp_upl_path, "%s/incoming", CFG.ftp_base);
                sprintf(CFG.ftp_banner, "%s/etc/ftpbanner", getenv("MBSE_ROOT"));
                sprintf(CFG.ftp_email, "sysop@%s", CFG.sysdomain);
                sprintf(CFG.ftp_pth_filter, "^[-A-Za-z0-9_\\.]*$  ^\\.  ^-");
                sprintf(CFG.ftp_pth_message, "%s/etc/pathmsg", getenv("MBSE_ROOT"));

		/*
		 *  WWW defaults
		 */
        	sprintf(CFG.www_root, "/var/www/htdocs");
        	sprintf(CFG.www_link2ftp, "files");
        	sprintf(CFG.www_url, "http://%s", CFG.sysdomain);
        	sprintf(CFG.www_charset, "ISO 8859-1");
        	sprintf(CFG.www_tbgcolor, "Silver");
        	sprintf(CFG.www_hbgcolor, "Aqua");
        	sprintf(CFG.www_author, "Your Name");
        	sprintf(CFG.www_convert,"/usr/X11R6/bin/convert -geometry x100");
        	sprintf(CFG.www_icon_home, "up.gif");
        	sprintf(CFG.www_name_home, "Home");
        	sprintf(CFG.www_icon_back, "back.gif");
        	sprintf(CFG.www_name_back, "Back");
        	sprintf(CFG.www_icon_prev, "left.gif");
        	sprintf(CFG.www_name_prev, "Previous page");
        	sprintf(CFG.www_icon_next, "right.gif");
        	sprintf(CFG.www_name_next, "Next page");
        	CFG.www_files_page = 10;

		CFG.maxarticles = 500;

                if ((fp = fopen(cfgfn, "a+")) == NULL) {
			perror("");
                        fprintf(stderr, "Can't create %s\n", cfgfn);
                        exit(2);
                }
                fwrite(&CFG, sizeof(CFG), 1, fp);
                fclose(fp);
		chmod(cfgfn, 0640);
        } else {
                fread(&CFG, sizeof(CFG), 1, fp);
                fclose(fp);
        }

        cfg_time = file_time(cfgfn);
}



/*
 *  Load task configuration data.
 */
void load_taskcfg(void)
{
	FILE	*fp;

	if ((fp = fopen(tcfgfn, "r")) == NULL) {
		memset(&TCFG, 0, sizeof(TCFG));
		TCFG.maxload = 1.50;
		sprintf(TCFG.zmh_start, "02:30");
		sprintf(TCFG.zmh_end, "03:30");
		sprintf(TCFG.cmd_mailout,  "%s/bin/mbfido scan web -quiet", getenv("MBSE_ROOT"));
		sprintf(TCFG.cmd_mailin,   "%s/bin/mbfido tic toss web -quiet", getenv("MBSE_ROOT"));
		sprintf(TCFG.cmd_newnews,  "%s/bin/mbfido news web -quiet", getenv("MBSE_ROOT"));
		sprintf(TCFG.cmd_mbindex1, "%s/bin/mbindex -quiet", getenv("MBSE_ROOT"));
		sprintf(TCFG.cmd_mbindex2, "%s/bin/goldnode -f -q", getenv("MBSE_ROOT"));
		sprintf(TCFG.cmd_msglink,  "%s/bin/mbmsg link -quiet", getenv("MBSE_ROOT"));
		sprintf(TCFG.cmd_reqindex, "%s/bin/mbfile index -quiet", getenv("MBSE_ROOT"));
		TCFG.ipblocks = TRUE;
		TCFG.debug    = FALSE;
		TCFG.max_pots = 1;
		TCFG.max_isdn = 0;
		TCFG.max_tcp  = 0;
		sprintf(TCFG.isp_ping1, "192.168.1.1");
		sprintf(TCFG.isp_ping2, "192.168.1.1");
		if ((fp = fopen(tcfgfn, "a+")) == NULL) {
			tasklog('?', "$Can't create %s", tcfgfn);
			die(2);
		}
		fwrite(&TCFG, sizeof(TCFG), 1, fp);
		fclose(fp);
		chmod(tcfgfn, 0640);
		tasklog('+', "Created new %s", tcfgfn);
	} else {
		fread(&TCFG, sizeof(TCFG), 1, fp);
		fclose(fp);
	}

	tcfg_time = file_time(tcfgfn);
}



/*
 * Check the actual list of nodes to call.
 */
int check_calllist(void);
int check_calllist(void)
{
    int		    i, found, call_work;
    struct _alist   *tmp;

    /*
     * Check callist, remove obsolete entries.
     */
    for (i = 0; i < MAXTASKS; i++) {
	if (calllist[i].addr.zone) {
	    found = FALSE;
	    for (tmp = alist; tmp; tmp = tmp->next) {
		if ((calllist[i].addr.zone  == tmp->addr.zone) && (calllist[i].addr.net   == tmp->addr.net) &&
		    (calllist[i].addr.node  == tmp->addr.node) && (calllist[i].addr.point == tmp->addr.point) &&
		    ((tmp->flavors) & F_CALL)) {
		    found = TRUE;
		}
	    }
	    if (!found) {
		tasklog('c', "Removing slot %d node %s from calllist", i, ascfnode(calllist[i].addr, 0x0f));
		memset(&calllist[i], 0, sizeof(tocall));
	    }
	}
    }

    if (pots_calls || isdn_calls || inet_calls) {
	call_work = 0;
	for (tmp = alist; tmp; tmp = tmp->next) {
	    if (tmp->callmode != CM_NONE) {
		call_work++;
		found = FALSE;
		for (i = 0; i < MAXTASKS; i++) {
		    if ((calllist[i].addr.zone  == tmp->addr.zone) && (calllist[i].addr.net   == tmp->addr.net) &&
			(calllist[i].addr.node  == tmp->addr.node) && (calllist[i].addr.point == tmp->addr.point)) {
			found = TRUE;
			/*
			 * Refresh last call status
			 */
			calllist[i].cst = tmp->cst;
		    }
		}
		if (!found) {
		    for (i = 0; i < MAXTASKS; i++) {
			if (!calllist[i].addr.zone) {
			    tasklog('c', "Adding %s to calllist slot %d", ascfnode(tmp->addr, 0x1f), i);
			    calllist[i].addr = tmp->addr;
			    calllist[i].cst = tmp->cst;
			    calllist[i].callmode = tmp->callmode;
			    calllist[i].moflags  = tmp->moflags;
			    calllist[i].diflags  = tmp->diflags;
			    calllist[i].ipflags  = tmp->ipflags;
			    break;
			}
		    }
		}
	    }
	}
	tasklog('o', "%d systems to call", call_work);
    } else {
	if (s_scanout)
	    sem_set((char *)"scanout", FALSE);
    }

    /*
     * Check if we need to remove the do_inet semafore
     */
    if (!inet_calls && s_do_inet) {
	tasklog('c', "Removing do_inet semafore");
	s_do_inet = FALSE;
	if (IsSema((char *)"do_inet")) {
	    RemoveSema((char *)"do_inet");
	}
    }
    
    call_work = 0;
    for (i = 0; i < MAXTASKS; i++) {
	if (calllist[i].addr.zone) {
	    if (!call_work) {
		tasklog('c', "Slot Call  Pid   Try Status  Mode    Modem    ISDN     TCP/IP   Address");
		tasklog('c', "---- ----- ----- --- ------- ------- -------- -------- -------- ----------------");
	    }
	    call_work++;
	    tasklog('c', "%4d %s %5d %3d %s %s %08x %08x %08x %s", i, calllist[i].calling?"true ":"false", calllist[i].taskpid,
		calllist[i].cst.tryno, callstatus(calllist[i].cst.trystat), callmode(calllist[i].callmode),
		calllist[i].moflags, calllist[i].diflags, calllist[i].ipflags, ascfnode(calllist[i].addr, 0x1f));
	}
    }

    return call_work;
}



/*
 *  Launch an external program in the background.
 *  On success add it to the tasklist and return
 *  the pid. Set the pause timer.
 */
pid_t launch(char *cmd, char *opts, char *name, int tasktype)
{
	char	buf[PATH_MAX];
	char	*vector[16];
	int	i, rc = 0;
	pid_t	pid = 0;

	if (checktasks(0) >= MAXTASKS) {
		tasklog('?', "Launch: can't execute %s, maximum tasks reached", cmd);
		return 0;
	}

	if (opts == NULL)
		sprintf(buf, "%s", cmd);
	else
		sprintf(buf, "%s %s", cmd, opts);

	i = 0;
	vector[i++] = strtok(buf," \t\n\0");
	while ((vector[i++] = strtok(NULL," \t\n")) && (i<16));
	vector[15] = NULL;

	if (file_exist(vector[0], X_OK)) {
		tasklog('?', "Launch: can't execute %s, command not found", vector[0]);
		return 0;
	}

	pid = fork();
	switch (pid) {
	case -1:
		tasklog('?', "$Launch: error, can't fork grandchild");
		return 0;
	case 0:
		/* From Paul Vixies cron: */
		(void)setsid(); /* It doesn't seem to help */
		close(0);
		if (open("/dev/null", O_RDONLY) != 0) {
			tasklog('?', "$Launch: \"%s\": reopen of stdin to /dev/null failed", buf);
			_exit(-1);
		}
		close(1);
		if (open("/dev/null", O_WRONLY | O_APPEND | O_CREAT,0600) != 1) {
			tasklog('?', "$Launch: \"%s\": reopen of stdout to /dev/null failed", buf);
			_exit(-1);
		}
		close(2);
		if (open("/dev/null", O_WRONLY | O_APPEND | O_CREAT,0600) != 2) {
			tasklog('?', "$Launch: \"%s\": reopen of stderr to /dev/null failed", buf);
			_exit(-1);
		}
		errno = 0;
		rc = execv(vector[0],vector);
		tasklog('?', "$Launch: execv \"%s\" failed, returned %d", cmd, rc);
		_exit(-1);
	default:
		/* grandchild's daddy's process */
		break;
	}

	/*
	 *  Add it to the tasklist.
	 */
	for (i = 0; i < MAXTASKS; i++) {
		if (strlen(task[i].name) == 0) {
			strcpy(task[i].name, name);
			strcpy(task[i].cmd, cmd);
			if (opts)
				strcpy(task[i].opts, opts);
			task[i].pid = pid;
			task[i].status = 0;
			task[i].running = TRUE;
			task[i].rc = 0;
			task[i].tasktype = tasktype;
			break;
		}
	}

	ptimer = PAUSETIME;

	if (opts)
		tasklog('+', "Launch: task %d \"%s %s\" success, pid=%d", i, cmd, opts, pid);
	else
		tasklog('+', "Launch: task %d \"%s\" success, pid=%d", i, cmd, pid);
	return pid;
}



/*
 *  Count specific running tasks
 */
int runtasktype(int tasktype)
{
	int	i, count = 0;

	for (i = 0; i < MAXTASKS; i++) {
		if (strlen(task[i].name) && task[i].running && (task[i].tasktype == tasktype))
			count++;
	}
	return count;
}



/*
 *  Check all running tasks registered in the tasklist.
 *  Report programs that are stopped. If signal is set
 *  then send that signal.
 */
int checktasks(int onsig)
{
	int	i, j, rc, count = 0, first = TRUE, status, do_outstat = FALSE;

	for (i = 0; i < MAXTASKS; i++) {
		if (strlen(task[i].name)) {

			if (onsig) {
				if (kill(task[i].pid, onsig) == 0)
					tasklog('+', "%s to %s (pid %d) succeeded", SigName[onsig], task[i].name, task[i].pid);
				else
					tasklog('+', "%s to %s (pid %d) failed", SigName[onsig], task[i].name, task[i].pid);
			}

			task[i].rc = wait4(task[i].pid, &status, WNOHANG | WUNTRACED, NULL);
			if (task[i].rc) {
				task[i].running = FALSE;
				if (task[i].tasktype == CM_POTS || task[i].tasktype == CM_ISDN || task[i].tasktype == CM_INET)
					do_outstat = TRUE;
				ptimer = PAUSETIME;
			}

			if (first && task[i].rc) {
				first = FALSE;
				tasklog('t', "Task             Type      pid stat status      rc    status");
				tasklog('t', "---------------- ------- ----- ---- ----------- ----- --------");
				for (j = 0; j < MAXTASKS; j++)
					if (strlen(task[j].name))
						tasklog('t', "%-16s %s %5d %s %-11d %5d %08x", task[j].name, 
							callmode(task[j].tasktype), task[j].pid, task[j].running?"runs":"stop", 
							task[j].status, task[j].rc, task[j].status);
			}

			switch (task[i].rc) {
			case -1:
				if (errno == ECHILD)
					tasklog('+', "Task %d \"%s\" is ready", i, task[i].name);
				else
					tasklog('+', "Task %d \"%s\" is ready, error: %s", i, task[i].name, strerror(errno));
				break;
			case 0:
				/*
				 * Update last known status when running.
				 */
				task[i].status = status;
				count++;
				break;
			default:
				tasklog('+', "errno=%d %s", errno, strerror(errno));
				if (WIFEXITED(task[i].status)) {
					rc = WEXITSTATUS(task[i].status);
					if (rc)
						tasklog('+', "Task %s is ready, error=%d", task[i].name, rc);
					else
						tasklog('+', "Task %s is ready", task[i].name);
				} else if (WIFSIGNALED(task[i].status)) {
					rc = WTERMSIG(task[i].status);
					if (rc <= 31)
						tasklog('+', "Task %s terminated on signal %s (%d)", task[i].name, SigName[rc], rc);
					else
						tasklog('+', "Task %s terminated with error nr %d", task[i].name, rc);
				} else if (WIFSTOPPED(task[i].status)) {
					rc = WSTOPSIG(task[i].status);
					tasklog('+', "Task %s stopped on signal %s (%d)", task[i].name, SigName[rc], rc);
				} else {
					tasklog('+', "FIXME: 1");
				}
				break;
			}

			if (!task[i].running) {
			    for (j = 0; j < MAXTASKS; j++) {
				if (calllist[j].taskpid == task[i].pid) {
				    calllist[j].calling = FALSE;
				    calllist[j].taskpid = 0;
				}
			    }
			    memset(&task[i], 0, sizeof(onetask));
			}
		}
	}

	if (do_outstat) {
		outstat();
		check_calllist();
	}

	return count;
}



void die(int onsig)
{
	int	i, count;

	signal(onsig, SIG_IGN);
	tasklog('+', "Shutting down on signal %s", SigName[onsig]);

	/*
	 *  First check if there are tasks running, if so try to stop them
	 */
	if ((count = checktasks(0))) {
		tasklog('+', "There are %d tasks running, sending SIGTERM", count);
		checktasks(SIGTERM);
		for (i = 0; i < 15; i++) {
			sleep(1);
			count = checktasks(0);
			if (count == 0)
				break;
		}
		if (count) {
			/*
			 *  There are some diehards running...
			 */
			tasklog('+', "There are %d tasks running, sending SIGKILL", count);
			count = checktasks(SIGKILL);
		}
		if (count) {
			sleep(1);
			count = checktasks(0);
			if (count)
				tasklog('?', "Still %d tasks running, giving up", count);
		}
	}

	ulocktask();
	if (sock != -1)
		close(sock);
	if (ping_isocket != -1)
		close(ping_isocket);
	if (!file_exist(spath, R_OK)) {
		unlink(spath);
	}
	tasklog(' ', "MBTASK finished");
	exit(onsig);
}



/*
 *  Put a lock on this program.
 */
int locktask(char *root)
{
	char    Tmpfile[81];
	FILE    *fp;
	pid_t   oldpid;

	sprintf(Tmpfile, "%s/var/", root);
	strcpy(lockfile, Tmpfile);
	sprintf(Tmpfile + strlen(Tmpfile), "%s%u", TMPNAME, getpid());
	sprintf(lockfile + strlen(lockfile), "%s", LCKNAME);

	if ((fp = fopen(Tmpfile, "w")) == NULL) {
		perror("mbtask");
		printf("Can't create lockfile \"%s\"\n", Tmpfile);
		return 1;
	}
	fprintf(fp, "%10u\n", getpid());
	fclose(fp);

	while (TRUE) {
		if (link(Tmpfile, lockfile) == 0) {
			unlink(Tmpfile);
			return 0;
		}
		if ((fp = fopen(lockfile, "r")) == NULL) {
			perror("mbtask");
			printf("Can't open lockfile \"%s\"\n", Tmpfile);
			unlink(Tmpfile);
			return 1;
		}
		if (fscanf(fp, "%u", &oldpid) != 1) {
			perror("mbtask");
			printf("Can't read old pid from \"%s\"\n", Tmpfile);
			fclose(fp);
			unlink(Tmpfile);
			return 1;
		}
		fclose(fp);
		if (kill(oldpid,0) == -1) {
			if (errno == ESRCH) {
				printf("Stale lock found for pid %u\n", oldpid);
				unlink(lockfile);
				/* no return, try lock again */  
			} else {
				perror("mbtask");
				printf("Kill for %u failed\n",oldpid);
				unlink(Tmpfile);
				return 1;
			}
		} else {
			printf("Another mbtask is already running, pid=%u\n", oldpid);
			unlink(Tmpfile);
			return 1;
		}
	}
}



void ulocktask(void)
{
	if (lockfile)
		(void)unlink(lockfile);
}


/* different names, same thing... be careful, as these are macros... */
#if defined(__FreeBSD__) || defined(__NetBSD__)
# define icmphdr   icmp
# define iphdr     ip
# define ip_saddr  ip_src.s_addr
# define ip_daddr  ip_dst.s_addr
#else
# define ip_saddr  saddr
# define ip_daddr  daddr
# define ip_hl     ihl
# define ip_p      protocol
#endif


#ifdef __linux__
# define icmp_type  type
# define icmp_code  code
# define icmp_cksum checksum
# ifdef icmp_id
#  undef icmp_id
# endif
# define icmp_id    un.echo.id
# ifdef icmp_seq
#  undef icmp_seq
# endif
# define icmp_seq   un.echo.sequence
#endif

#if defined(__FreeBSD__) || defined(__NetBSD__)
# define ICMP_DEST_UNREACH   ICMP_UNREACH
# define ICMP_TIME_EXCEEDED ICMP_TIMXCEED    
#endif

#define ICMP_BASEHDR_LEN  8
#define ICMP4_ECHO_LEN    ICMP_BASEHDR_LEN



/*
 * Takes a packet as send out and a recieved ICMP packet and looks whether the ICMP packet is 
 * an error reply on the sent-out one. packet is only the packet (without IP header).
 * errmsg includes an IP header.
 * to is the destination address of the original packet (the only thing that is actually
 * compared of the IP header). The RFC sais that we get at least 8 bytes of the offending packet.
 * We do not compare more, as this is all we need.
 */
static int icmp4_errcmp(char *packet, int plen, struct in_addr *to, char *errmsg, int elen, int errtype)
{
	struct iphdr	iph;
	struct icmphdr	icmph;
	struct iphdr	eiph;
	char		*data;

	/* XXX: lots of memcpy to avoid unaligned accesses on alpha */
	if (elen < sizeof(struct iphdr))
                return 0;
	memcpy(&iph, errmsg, sizeof(iph));
	if (iph.ip_p != IPPROTO_ICMP || elen < iph.ip_hl * 4 + ICMP_BASEHDR_LEN + sizeof(eiph))
		return 0;
	memcpy(&icmph, errmsg + iph.ip_hl * 4, ICMP_BASEHDR_LEN);
	memcpy(&eiph, errmsg + iph.ip_hl * 4 + ICMP_BASEHDR_LEN, sizeof(eiph));
	if (elen < iph.ip_hl * 4 + ICMP_BASEHDR_LEN + eiph.ip_hl * 4 + 8)
		return 0;
	data = errmsg + iph.ip_hl * 4 + ICMP_BASEHDR_LEN + eiph.ip_hl * 4;
	return icmph.icmp_type == errtype && memcmp(&to->s_addr, &eiph.ip_daddr, sizeof(to->s_addr)) == 0 && 
		memcmp(data, packet, plen < 8 ?plen:8) == 0;
}



unsigned short get_rand16(void)
{
	return random()&0xffff;
}


short			p_sequence = 0;
unsigned short          id;
struct icmphdr          icmpd;
struct sockaddr_in      to;

/*
 * IPv4/ICMPv4 ping. Called from ping (see below)
 */
int ping_send(struct in_addr addr)
{
	int			len;
	int			isock;
#ifdef __linux__
	struct icmp_filter	f;
#else
	struct protoent		*pe;
	int			SOL_IP;
#endif
	unsigned long		sum;
	unsigned short		*ptr;

#ifndef __linux__
        if (!(pe = getprotobyname("ip"))) {
                tasklog('?', "icmp ping: getprotobyname() failed: %s", strerror(errno));
                return -1;
        }
        SOL_IP = pe->p_proto;
#endif

	isock = ping_isocket;
	p_sequence = 1;
	id = (unsigned short)get_rand16(); /* randomize a ping id */

#ifdef __linux__
	/* Fancy ICMP filering -- only on Linux (as far is I know) */
        
	/* In fact, there should be macros for treating icmp_filter, but I haven't found them in Linux 2.2.15.
	 * So, set it manually and unportable ;-) */
	/* This filter lets ECHO_REPLY (0), DEST_UNREACH(3) and TIME_EXCEEDED(11) pass. */
	/* !(0000 1000 0000 1001) = 0xff ff f7 f6 */
	f.data=0xfffff7f6;
	if (setsockopt(isock, SOL_RAW, ICMP_FILTER, &f, sizeof(f)) == -1) {
		if (icmp_errs < ICMP_MAX_ERRS)
			tasklog('?', "$icmp ping: setsockopt() failed %d", isock);
		return -1;
	}
#endif

	icmpd.icmp_type  = ICMP_ECHO;
	icmpd.icmp_code  = 0;
	icmpd.icmp_cksum = 0;
	icmpd.icmp_id    = htons((short)id);
	icmpd.icmp_seq   = htons(p_sequence);

       	/* Checksumming - Algorithm taken from nmap. Thanks... */

	ptr = (unsigned short *)&icmpd;
	sum = 0;

	for (len = 0; len < 4; len++) {
		sum += *ptr++;
	}
	sum = (sum >> 16) + (sum & 0xffff);
	sum += (sum >> 16);
	icmpd.icmp_cksum = ~sum;

	memset(&to, 0, sizeof(to));
	to.sin_family = AF_INET;
	to.sin_port   = 0;
	to.sin_addr   = addr;
	SET_SOCKA_LEN4(to);
	if (sendto(isock, &icmpd, ICMP4_ECHO_LEN, 0, (struct sockaddr *)&to, sizeof(to)) == -1) {
//		if (icmp_errs < ICMP_MAX_ERRS)
//			tasklog('?', "$icmp ping: sendto()");
		return -2;
	}
	return 0;
}



int ping_receive(struct in_addr addr)
{
	char                    buf[1024]; 
	int                     isock;
        int                     len;
        struct sockaddr_in      ffrom;
        struct icmphdr          icmpp;
        struct iphdr            iph;
	socklen_t               sl;        
	struct pollfd           pfd;

	isock = ping_isocket;

	pfd.fd = isock;
	pfd.events = POLLIN;
	/*
 	 *  10 mSec is enough, this function is called at regular intervals.
	 */
	if (poll(&pfd, 1, 10) < 0) {
		if (icmp_errs < ICMP_MAX_ERRS)
			tasklog('?', "$poll/select failed");
		return -3; 
	}

	if (pfd.revents & POLLIN || pfd.revents & POLLERR || pfd.revents & POLLHUP || pfd.revents & POLLNVAL) {
		sl = sizeof(ffrom);
		if ((len = recvfrom(isock, &buf, sizeof(buf), 0,(struct sockaddr *)&ffrom, &sl)) != -1) {
			if (len > sizeof(struct iphdr)) {
				memcpy(&iph, buf, sizeof(iph));
				if (len - iph.ip_hl * 4 >= ICMP_BASEHDR_LEN) {
					memcpy(&icmpp, ((unsigned long int *)buf)+iph.ip_hl, sizeof(icmpp));
					if (iph.ip_saddr == addr.s_addr && 
					    icmpp.icmp_type == ICMP_ECHOREPLY &&
					    ntohs(icmpp.icmp_id) == id && 
					    ntohs(icmpp.icmp_seq) <= p_sequence) {
						return 0;
					} else {
						/* No regular echo reply. Maybe an error? */
						if (icmp4_errcmp((char *)&icmpd, ICMP4_ECHO_LEN, 
						    &to.sin_addr, buf, len, ICMP_DEST_UNREACH) ||
						    icmp4_errcmp((char *)&icmpd, ICMP4_ECHO_LEN, 
						    &to.sin_addr, buf, len, ICMP_TIME_EXCEEDED)) {
							return -4;
						}
					}
				}
			}
		} else {
			return -5; /* error */
		}
	}
	return -6; /* no answer */
}



/*
 *  External Semafore Checks
 */
void test_sema(char *);
void test_sema(char *sema)
{
	if (IsSema(sema)) {
		RemoveSema(sema);
		tasklog('s', "Semafore %s detected", sema);
		sem_set(sema, TRUE);
	}
}



/*
 *  Check semafore's, system status flags etc. This is called
 *  each second to test for condition changes.
 */
void check_sema(void);
void check_sema(void)
{
	/*
	 * Check UPS status.
	 */
        if (IsSema((char *)"upsalarm")) {
                if (!UPSalarm)
                        tasklog('!', "UPS: power failure");
		UPSalarm = TRUE;
	} else {
                if (UPSalarm)
                        tasklog('!', "UPS: the power is back");
		UPSalarm = FALSE; 
	}
	if (IsSema((char *)"upsdown")) {
		tasklog('!', "UPS: power failure, starting shutdown");
		/*
		 *  Since the upsdown semafore is permanent, the system WILL go down
		 *  there is no point for this program to stay. Signal all tasks and stop.
		 */
		die(SIGTERM);
	}

	/*
	 *  Check Zone Mail Hour
	 */
	get_zmh();

	/*
	 *  Semafore's that still can be detected, usefull for
	 *  external programs that create them.
	 */
	test_sema((char *)"newnews");
	test_sema((char *)"mailout");
	test_sema((char *)"mailin");
	test_sema((char *)"scanout");
}



void scheduler(void)
{
    struct passwd   *pw;
    int		    running = 0, rc, i, rlen, found;
    static int      LOADhi = FALSE, oldmin = 70, olddo = 70, oldsec = 70;
    char            *cmd = NULL, opts[41];
    static char	    doing[32], buf[2048];
    time_t          now;
    struct tm       *tm, *utm;
#if defined(__linux__)
    FILE	    *fp;
#endif
    struct pollfd   pfd;
    struct in_addr  paddr;
    int		    call_work;
    static int	    call_entry = MAXTASKS;
    double	    loadavg[3];

    InitFidonet();

    /*
     * Registrate this server for mbmon in slot 0.
     */
    reginfo[0].pid = getpid();
    strcpy(reginfo[0].tty,   "-");
    strcpy(reginfo[0].uname, "mbse");
    strcpy(reginfo[0].prg,   "mbtask");
    strcpy(reginfo[0].city,  "localhost");
    strcpy(reginfo[0].doing, "Start");
    reginfo[0].started = time(NULL);

    Processing = TRUE;
    TouchSema((char *)"mbtask.last");
    pw = getpwuid(getuid());

    /*
     * Setup UNIX Datagram socket
     */
    if ((sock = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {
	tasklog('?', "$Can't create socket");
	die(1);
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sun_family = AF_UNIX;
    strcpy(servaddr.sun_path, spath);

    if (bind(sock, &servaddr, sizeof(servaddr)) < 0) {
	close(sock);
	sock = -1;
	tasklog('?', "$Can't bind socket %s", spath);
	die(1);
    }

    pingresult[1] = TRUE;
    pingresult[2] = TRUE;

    /*
     * The flag masterinit is set if a new config.data is created, this
     * is true if mbtask is started the very first time. Then we run
     * mbsetup init to create the default databases.
     */
    if (masterinit) {
	cmd = xstrcpy(pw->pw_dir);
	cmd = xstrcat(cmd, (char *)"/bin/mbsetup");
	launch(cmd, (char *)"init", (char *)"mbsetup", MBINIT);
	free(cmd);
	sleep(2);
	masterinit = FALSE;
    }

    initnl();
    sem_set((char *)"scanout", TRUE);
	
    /*
     * Enter the mainloop (forever)
     */
    do {
	/*
	 *  Poll UNIX Datagram socket until the defined timeout of one second.
	 *  This means we listen of a MBSE BBS client program has something
	 *  to tell.
	 */
	pfd.fd = sock;
	pfd.events = POLLIN | POLLPRI;
	pfd.revents = 0;
	rc = poll(&pfd, 1, 1000);
	if (rc == -1) {
	    /*
	     *  Poll can be interrupted by a finished child so that's not a real error.
	     */
	    if (errno != EINTR) {
		tasklog('?', "$poll() rc=%d sock=%d, events=%04x", rc, sock, pfd.revents);
	    }
	} else if (rc) {
	    if (pfd.revents & POLLIN) {
		/*
		 * Process the clients request
		 */
		memset(&buf, 0, sizeof(buf));
		fromlen = sizeof(from);
		rlen = recvfrom(sock, buf, sizeof(buf) -1, 0, &from, &fromlen);
		do_cmd(buf);
	    } else {
		tasklog('-', "Return poll rc=%d, events=%04x", rc, pfd.revents);
	    }
	}

	/*
	 * Check all registered connections and semafore's
	 */
	reg_check();
	check_sema();

	/*
	 * Check the systems load average. FIXME: doesn't work in FreeBSD !!!
	 */
	Load = loadavg[0] = loadavg[1] = loadavg[2] = 0.0;
#if defined(__FreeBSD__) || defined(__NetBSD__)
	if (getloadavg(loadavg, 3) == 3) {
	    Load = loadavg[0];
	}
#elif defined(__linux__)
	if ((fp = fopen((char *)"/proc/loadavg", "r"))) {
	    if (fscanf(fp, "%lf %lf %lf", &loadavg[0], &loadavg[1], &loadavg[2]) == 3) {
		Load = loadavg[0];
	    } else {
		tasklog('-', "error");
	    }
	    fclose(fp);
	}
#endif
	if (Load >= TCFG.maxload) {
	    if (!LOADhi) {
		tasklog('!', "System load too high: %2.2f (%2.2f)", Load, TCFG.maxload);
		LOADhi = TRUE;
	    }
	} else {
	    if (LOADhi) {
		tasklog('!', "System load normal: %2.2f (%2.2f)", Load, TCFG.maxload);
		LOADhi = FALSE;
	    }
	}

	/*
	 * Report to the system monitor. 
	 */
	memset(&doing, 0, sizeof(doing));
	if ((running = checktasks(0)))
	    sprintf(doing, "Run %d tasks", running);
	else if (UPSalarm)
	    sprintf(doing, "UPS alarm");
	else if (!s_bbsopen)
	    sprintf(doing, "BBS is closed");
	else if (Processing)
	    sprintf(doing, "Waiting (%d)", oldmin);
	else
	    sprintf(doing, "Overload %2.2f", Load);

	sprintf(reginfo[0].doing, "%s", doing);
	reginfo[0].lastcon = time(NULL);

	/*
	 *  Touch the mbtask.last semafore to prove this daemon
	 *  is actually running.
	 *  Reload configuration data if some file is changed.
	 */
	now = time(NULL);
	tm = localtime(&now);
	utm = gmtime(&now);
	if (tm->tm_min != olddo) {
	    /*
	     * Each minute we execute this part
	     */
	    olddo = tm->tm_min;
	    TouchSema((char *)"mbtask.last");
	    if (file_time(tcfgfn) != tcfg_time) {
		tasklog('+', "Task configuration changed, reloading");
		load_taskcfg();
		sem_set((char *)"scanout", TRUE);
	    }
	    if (file_time(cfgfn) != cfg_time) {
		tasklog('+', "Main configuration changed, reloading");
		load_maincfg();
		sem_set((char *)"scanout", TRUE);
	    }
	    if (file_time(ttyfn) != tty_time) {
		tasklog('+', "Ports configuration changed, reloading");
		load_ports();
		sem_set((char *)"scanout", TRUE);
	    }

	    /*
	     * If the next event time is reached, rescan the outbound
	     */
	    if ((utm->tm_hour == nxt_hour) && (utm->tm_min == nxt_min)) {
		tasklog('+', "It is now %02d:%02d UTC, starting new event", utm->tm_hour, utm->tm_min);
		sem_set((char *)"scanout", TRUE);
	    }
	}

	if (s_bbsopen && !UPSalarm && !LOADhi) {

	    /*
	     * Check Pause Timer, make sure it's only checked
	     * once each second.
	     */
	    if (tm->tm_sec != oldsec) {
		oldsec = tm->tm_sec;
		if (ptimer)
		    ptimer--;
	    }

	    if (!Processing) {
		tasklog('+', "Resuming normal operations");
		Processing = TRUE;
	    }

	    /*
	     *  Here we run all normal operations.
	     */
	    running = checktasks(0);

	    if (s_mailout && (!ptimer) && (!runtasktype(MBFIDO))) {
		launch(TCFG.cmd_mailout, NULL, (char *)"mailout", MBFIDO);
		running = checktasks(0);
		s_mailout = FALSE; 
	    }

	    if (s_mailin && (!ptimer) && (!runtasktype(MBFIDO))) {
		launch(TCFG.cmd_mailin, NULL, (char *)"mailin", MBFIDO);
		running = checktasks(0);
		s_mailin = FALSE;
	    }

	    if (s_newnews && (!ptimer) && (!runtasktype(MBFIDO))) {
		launch(TCFG.cmd_newnews, NULL, (char *)"newnews", MBFIDO);
		running = checktasks(0);
		s_newnews = FALSE; 
	    }

	    /*
	     *  Only run the nodelist compiler if nothing else
	     *  is running. There's no hurry to compile the
	     *  new lists. If more then one compiler is defined,
	     *  start them in parallel.
	     */
	    if (s_index && (!ptimer) && (!running)) {
		if (strlen(TCFG.cmd_mbindex1))
		    launch(TCFG.cmd_mbindex1, NULL, (char *)"compiler 1", MBINDEX);
		if (strlen(TCFG.cmd_mbindex2))
		    launch(TCFG.cmd_mbindex2, NULL, (char *)"compiler 2", MBINDEX);
		if (strlen(TCFG.cmd_mbindex3))
		    launch(TCFG.cmd_mbindex3, NULL, (char *)"compiler 3", MBINDEX);
		running = checktasks(0);
		s_index = FALSE;
	    }

	    /*
	     *  Linking messages is also only done when there is
	     *  nothing else to do.
	     */
	    if (s_msglink && (!ptimer) && (!running)) {
		launch(TCFG.cmd_msglink, NULL, (char *)"msglink", MBFIDO);
		running = checktasks(0);
		s_msglink = FALSE;
	    }

	    /*
	     *  Creating filerequest indexes, also only if nothing to do.
	     */
	    if (s_reqindex && (!ptimer) && (!running)) {
		launch(TCFG.cmd_reqindex, NULL, (char *)"reqindex", MBFILE);
		running = checktasks(0);
		s_reqindex = FALSE;
	    }

	    if ((tm->tm_sec / SLOWRUN) != oldmin) {

		/*
		 *  These tasks run once per 20 seconds.
		 */
		oldmin = tm->tm_sec / SLOWRUN;

		/*
		 *  If the previous pingstat is still P_SENT, then we now consider it a timeout.
		 */
		if (pingstate == P_SENT) {
		    pingresult[pingnr] = FALSE;
		    icmp_errs++;
		    if (icmp_errs < ICMP_MAX_ERRS)
			tasklog('p', "ping %s seq=%d timeout", pingaddress, p_sequence);
		}

		/*
		 *  Check internet connection with ICMP ping
		 */
		rc = 0;
		if (pingnr == 1) {
		    pingnr = 2;
		    if (strlen(TCFG.isp_ping2)) {
			sprintf(pingaddress, "%s", TCFG.isp_ping2);
		    } else {
			pingstate = P_NONE;
		    }
		} else {
		    pingnr = 1;
		    if (strlen(TCFG.isp_ping1)) {
			sprintf(pingaddress, "%s", TCFG.isp_ping1);
		    } else {
			pingstate = P_NONE;
		    }
		}

		if (inet_aton(pingaddress, &paddr)) {
		    rc = ping_send(paddr);
		    if (rc) {
			if (icmp_errs++ < ICMP_MAX_ERRS)
			    tasklog('?', "ping send %s rc=%d", pingaddress, rc);
			pingstate = P_FAIL;
			pingresult[pingnr] = FALSE;
		    } else {
			pingstate = P_SENT;
		    }
		} else {
		    if (icmp_errs++ < ICMP_MAX_ERRS)
			tasklog('?', "Ping address %d is invalid \"%s\"", pingnr, pingaddress);
		    pingstate = P_NONE;
		}

		if (pingresult[1] == FALSE && pingresult[2] == FALSE) {
		    icmp_errs++;
		    if (internet) {
			tasklog('!', "Internet connection is down");
			internet = FALSE;
			sem_set((char *)"scanout", TRUE);
		    }
		} else {
		    if (!internet) {
			tasklog('!', "Internet connection is up");
			internet = TRUE;
			sem_set((char *)"scanout", TRUE);
		    }
		    icmp_errs = 0;
		}

		/*
		 * Update outbound status if needed.
		 */
		if (s_scanout) {
		    outstat();
		}
		call_work = check_calllist();

		/*
		 * Launch the systems to call, start one system each time.
		 * Set the safety counter to MAXTASKS + 1, this forces that
		 * the counter really will advance to the next node in case
		 * of failing sessions.
		 */
		i = MAXTASKS + 1;
		found = FALSE;
		if (call_work) {
		    while (TRUE) {
			/*
			 * Rotate the call entries
			 */
			if (call_entry == MAXTASKS)
			    call_entry = 0;
			else
			    call_entry++;
//			tasklog('c', "Call entry rotaded to %d", call_entry);
			/*
			 * If a valid entry, and not yet calling, and the retry time is reached,
			 * then launch a callprocess for this node.
			 */
//			if (calllist[call_entry].addr.zone && !calllist[call_entry].calling) {
//			    tasklog('o', "trytime %lu, now %lu", calllist[call_entry].cst.trytime, now);
//			}
			if (calllist[call_entry].addr.zone && !calllist[call_entry].calling && 
				(calllist[call_entry].cst.trytime < now)) {
			    if ((calllist[call_entry].callmode == CM_INET) && (runtasktype(CM_INET) < TCFG.max_tcp)) {
				found = TRUE;
				break;
			    }
			    if ((calllist[call_entry].callmode == CM_ISDN) && (runtasktype(CM_ISDN) < TCFG.max_isdn)) {
				found = TRUE;
				break;
			    }
			    if ((calllist[call_entry].callmode == CM_POTS) && (runtasktype(CM_POTS) < TCFG.max_pots)) {
				found = TRUE;
				break;
			    }
			}
			/*
			 * Safety counter, if all systems are already calling, we should
			 * never break out of this loop anymore.
			 */
			i--;
			if (!i)
			    break;
		    }
		    if (found) {
//			tasklog('c', "Should launch slot %d node %s", call_entry, ascfnode(calllist[call_entry].addr, 0x1f));
			cmd = xstrcpy(pw->pw_dir);
			cmd = xstrcat(cmd, (char *)"/bin/mbcico");
			sprintf(opts, "f%u.n%u.z%u", calllist[call_entry].addr.node, calllist[call_entry].addr.net,
				calllist[call_entry].addr.zone);
			calllist[call_entry].taskpid = launch(cmd, opts, (char *)"mbcico", calllist[call_entry].callmode);
			if (calllist[call_entry].taskpid)
			    calllist[call_entry].calling = TRUE;
			running = checktasks(0);
			check_calllist();
			free(cmd);
			cmd = NULL;
		    }
		}
	    }

	    /*
	     * PING state changes
	     */
            switch (pingstate) {
		case P_NONE:    pingresult[pingnr] = TRUE;
				break;
		case P_SENT:    rc = ping_receive(paddr);
				if (!rc) {
				    pingstate = P_OK;
				    pingresult[pingnr] = TRUE;
				} else {
				    if (rc != -6)
					tasklog('p', "ping recv %s id=%d rc=%d", pingaddress, id, rc);
				}
				break;
            }

	} else {
	    if (Processing) {
		tasklog('+', "Suspending operations");
		Processing = FALSE;
	    }
	}
    } while (TRUE);
}



int main(int argc, char **argv)
{
        struct passwd   *pw;
        int             i;
        pid_t           frk;
        FILE            *fp;

       /*
         * Print copyright notices and setup logging.
         */
        printf("MBTASK: MBSE BBS v%s Task Manager Daemon\n", VERSION);
        printf("        %s\n\n", COPYRIGHT);

        /*
         *  Catch all the signals we can, and ignore the rest. Note that SIGKILL can't be ignored
         *  but that's live. This daemon should only be stopped by SIGTERM.
         */
        for(i = 0; i < NSIG; i++) {
                if ((i == SIGHUP) || (i == SIGINT) || (i == SIGBUS) || (i == SIGILL) || (i == SIGSEGV) || (i == SIGTERM))
                        signal(i, (void (*))die);
                else
                        signal(i, SIG_IGN);
        }

	/*
	 *  Create the ping socket while we are still root.
	 */
	if ((ping_isocket = socket(PF_INET, SOCK_RAW, IPPROTO_ICMP)) == -1) {
		perror("");
		printf("socket init failed, is mbtask not installed setuid root?\n");
		exit(1);
	}

	/*
	 *  mbtask is setuid root, drop privileges to user mbse.
	 *  This will stay forever like this, no need to become
	 *  root again. The child can't even become root anymore.
	 */
        pw = getpwnam((char *)"mbse");
	if (setuid(pw->pw_uid)) {
		perror("");
		printf("can't setuid to mbse\n");
		close(ping_isocket);
		exit(1);
	}
	if (setgid(pw->pw_gid)) {
		perror("");
		printf("can't setgid to bbs\n");
		close(ping_isocket);
		exit(1);
	}

	umask(007);
        if (locktask(pw->pw_dir)) {
		close(ping_isocket);
                exit(1);
        }

	sprintf(cfgfn, "%s/etc/config.data", getenv("MBSE_ROOT"));
	load_maincfg();

        tasklog(' ', " ");
        tasklog(' ', "MBTASK v%s", VERSION);
	sprintf(tcfgfn, "%s/etc/task.data", getenv("MBSE_ROOT"));
        load_taskcfg();
        status_init();

        memset(&task, 0, sizeof(task));
	memset(&reginfo, 0, sizeof(reginfo));
	memset(&calllist, 0, sizeof(calllist));
	sprintf(spath, "%s/tmp/mbtask", getenv("MBSE_ROOT"));

	sprintf(ttyfn, "%s/etc/ttyinfo.data", getenv("MBSE_ROOT"));
	load_ports();

	/*
	 * Now that init is complete and this program is locked, it is
	 * safe to remove a stale socket if it is there after a crash.
	 */
        if (!file_exist(spath, R_OK))
                unlink(spath);

        /*
         * Server initialization is complete. Now we can fork the 
         * daemon and return to the user. We need to do a setpgrp
         * so that the daemon will no longer be assosiated with the
         * users control terminal. This is done before the fork, so
         * that the child will not be a process group leader. Otherwise,
         * if the child were to open a terminal, it would become
         * associated with that terminal as its control terminal.
         */
	if ((pgrp = setpgid(0, 0)) == -1) {
		tasklog('?', "$setpgid failed");
		die(0);
	}

	frk = fork();
        switch (frk) {
        case -1:
                tasklog('?', "$Unable to fork daemon");
                die(0);
        case 0:
                /*
                 *  Starting the deamon child process here. 
                 */
                fclose(stdin);
		fclose(stdout);
                fclose(stderr);
                scheduler();
		/* Not reached */
        default:
                /*
                 * Here we detach this process and let the child
                 * run the deamon process. Put the child's pid
                 * in the lockfile before leaving.
                 */
                if ((fp = fopen(lockfile, "w"))) {
                        fprintf(fp, "%10u\n", frk);
                        fclose(fp);
                }
                tasklog('+', "Starting daemon with pid %d", frk);
                exit(0);
        }

        /*
         *  Not reached
         */
        return 0;
}