2266 lines
61 KiB
C
2266 lines
61 KiB
C
/************************************************************************/
|
|
/* */
|
|
/* ***** ***** */
|
|
/* ***** ***** */
|
|
/* ***** ***** */
|
|
/* ***** ***** */
|
|
/* *************** *************** */
|
|
/* ***************** ***************** */
|
|
/* *************** *************** */
|
|
/* ***** ***** TheNetNode */
|
|
/* ***** ***** Portable */
|
|
/* ***** ***** Network */
|
|
/* ***** ***** Software */
|
|
/* */
|
|
/* File os/linux/linux.c (maintained by: DF6LN) */
|
|
/* */
|
|
/* This file is part of "TheNetNode" - Software Package */
|
|
/* */
|
|
/* Copyright (C) 1998 - 2008 NORD><LINK e.V. Braunschweig */
|
|
/* */
|
|
/* This program is free software; you can redistribute it and/or modify */
|
|
/* it under the terms of the NORD><LINK ALAS (Allgemeine Lizenz fuer */
|
|
/* Amateurfunk Software) as published by Hans Georg Giese (DF2AU) */
|
|
/* on 13/Oct/1992; either version 1, or (at your option) any later */
|
|
/* version. */
|
|
/* */
|
|
/* This program is distributed WITHOUT ANY WARRANTY only for further */
|
|
/* development and learning purposes. See the ALAS (Allgemeine Lizenz */
|
|
/* fuer Amateurfunk Software). */
|
|
/* */
|
|
/* You should have received a copy of the NORD><LINK ALAS (Allgemeine */
|
|
/* Lizenz fuer Amateurfunk Software) along with this program; if not, */
|
|
/* write to NORD><LINK e.V., Hinter dem Berge 5, D-38108 Braunschweig */
|
|
/* */
|
|
/* Dieses Programm ist PUBLIC DOMAIN, mit den Einschraenkungen durch */
|
|
/* die ALAS (Allgemeine Lizenz fuer Amateurfunk Software), entweder */
|
|
/* Version 1, veroeffentlicht von Hans Georg Giese (DF2AU), */
|
|
/* am 13.Oct.1992, oder (wenn gewuenscht) jede spaetere Version. */
|
|
/* */
|
|
/* Dieses Programm wird unter Haftungsausschluss vertrieben, aus- */
|
|
/* schliesslich fuer Weiterentwicklungs- und Lehrzwecke. Naeheres */
|
|
/* koennen Sie der ALAS (Allgemeine Lizenz fuer Amateurfunk Software) */
|
|
/* entnehmen. */
|
|
/* */
|
|
/* Sollte dieser Software keine ALAS (Allgemeine Lizenz fuer Amateur- */
|
|
/* funk Software) beigelegen haben, wenden Sie sich bitte an */
|
|
/* NORD><LINK e.V., Hinter dem Berge 5, D-38108 Braunschweig */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
#define _TNN_LINUX_C
|
|
|
|
#include "tnn.h"
|
|
|
|
static struct hostqueue *hostq_root;
|
|
static struct hostqueue *hostq_last;
|
|
|
|
static struct termios oconin_termios;
|
|
static struct termios nconin_termios;
|
|
static struct termios oconout_termios;
|
|
static struct termios nconout_termios;
|
|
|
|
static struct timeval tv;
|
|
static struct timezone tz;
|
|
|
|
static struct timeval tv_old;
|
|
static struct sockaddr_un serv_addr;
|
|
|
|
static int hostq_len;
|
|
static int servlen;
|
|
static int consockfd;
|
|
static int sockfd;
|
|
|
|
#ifndef NO_WATCHDOG
|
|
static int wdpid[2];
|
|
static int watch_dog[2];
|
|
#endif
|
|
|
|
UBYTE console_type = CONS_TERM_DO_SETUP;
|
|
|
|
#ifndef NO_WATCHDOG
|
|
static void watchdog_init(void);
|
|
#endif
|
|
#ifdef DEBUG_MODUS
|
|
static void sigterm(int);
|
|
#endif
|
|
static void host_to_queue(char *, int);
|
|
static void setfiletime(struct ffblk *);
|
|
|
|
static float load[3];
|
|
static float sys_load = 0;
|
|
static int tnn_load;
|
|
|
|
BOOLEAN unlock;
|
|
/* BOOLEAN use_socket; */
|
|
|
|
char tnn_socket[MAXPATH];
|
|
char start_name[MAXPATH];
|
|
char stop_name[MAXPATH];
|
|
|
|
UWORD maxrounds = 1; /* 1 = 100 Runden (default, wenn kein */
|
|
/* "rounds"-Eintrag in tnn.ini */
|
|
/*
|
|
String in Kleinbuchstaben umwandeln - aus DJGPP GNU-Paket fuer MS-DOS
|
|
von D.J. Delorie
|
|
*/
|
|
|
|
char *
|
|
strlwr(char *s)
|
|
{
|
|
char *p = s;
|
|
while (*s)
|
|
{
|
|
if ((*s >= 'A') && (*s <= 'Z'))
|
|
*s += 'a'-'A';
|
|
s++;
|
|
}
|
|
return(p);
|
|
}
|
|
|
|
|
|
/*
|
|
String in Grossbuchstaben umwandeln - aus DJGPP GNU-Paket fuer MS-DOS
|
|
von D.J. Delorie
|
|
*/
|
|
|
|
char *
|
|
strupr(char *s)
|
|
{
|
|
char *p = s;
|
|
while (*s)
|
|
{
|
|
if ((*s >= 'a') && (*s <= 'z'))
|
|
*s += 'A'-'a';
|
|
s++;
|
|
}
|
|
return(p);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Als Ersatz fuer die Funktionen "findfirst" und "findnext" (bei DOS) */
|
|
/* werden die Funktionen "xfindfirst" und "xfindnext" verwendet. Hier */
|
|
/* wird nur der fuer TNN benoetigte Teil in die Struktur ffblk einge- */
|
|
/* tragen. Der zuletzt gefundene Filename muss in ffblk->ff_name erhal- */
|
|
/* ten bleiben, weil dieser beim Aufruf von "xfindnext" gesucht wird. */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
int
|
|
xfindfirst(const char *pathname, struct ffblk *ffblk, int attrib)
|
|
{
|
|
char *fnpoi;
|
|
DIR *dp;
|
|
struct dirent *dirp;
|
|
int retval;
|
|
|
|
strcpy(ffblk->ff_path, pathname); /* Filename incl. Pfad */
|
|
normfname(ffblk->ff_path); /* '\\' -> '/' */
|
|
fnpoi = strrchr(ffblk->ff_path, '/'); /* Pfad angegeben? */
|
|
if (fnpoi == NULL) /* - nein .. */
|
|
{
|
|
strcpy(ffblk->ff_find, ffblk->ff_path); /* Filename kopieren */
|
|
strcpy(ffblk->ff_path, textpath); /* default: textpath */
|
|
}
|
|
else /* mit Pfad */
|
|
{
|
|
if (fnpoi == ffblk->ff_path+strlen(ffblk->ff_path)) /* ohne Name */
|
|
return(-1); /* Unsinn */
|
|
strcpy(ffblk->ff_find, ++fnpoi); /* nur Filename */
|
|
*fnpoi = NUL; /* Filename im Pfad loeschen */
|
|
}
|
|
|
|
if ((dp = opendir(ffblk->ff_path)) == NULL) /* Directory vorhanden? */
|
|
return(-1);
|
|
retval = -1; /* default: nix gefunden */
|
|
while ((dirp = readdir(dp)) != NULL) /* Eintrag vorhanden? */
|
|
{
|
|
if ((fnmatch(ffblk->ff_find, dirp->d_name,
|
|
FNM_PATHNAME|FNM_PERIOD) != 0))
|
|
continue;
|
|
strcpy(ffblk->ff_name, dirp->d_name);
|
|
setfiletime(ffblk);
|
|
retval = 0;
|
|
break;
|
|
}
|
|
closedir(dp);
|
|
return(retval);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Erst den zuletzt gefundenen Eintrag suchen (steht in ffblk->ff_name) */
|
|
/* und den darauffolgenden passenden Eintrag zurueckmelden. */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
int
|
|
xfindnext(struct ffblk *ffblk)
|
|
{
|
|
DIR *dp;
|
|
struct dirent *dirp;
|
|
int retval;
|
|
|
|
if ((dp = opendir(ffblk->ff_path)) == NULL) return(-1);
|
|
retval = -1; /* default: nix gefunden */
|
|
while ((dirp = readdir(dp)) != NULL)
|
|
{
|
|
if ((fnmatch(ffblk->ff_name, dirp->d_name,
|
|
FNM_PATHNAME|FNM_PERIOD) != 0))
|
|
continue;
|
|
retval = 1;
|
|
break;
|
|
}
|
|
if (retval == 1)
|
|
{
|
|
retval = -1; /* default: nix gefunden */
|
|
while ((dirp = readdir(dp)) != NULL)
|
|
{
|
|
if ((fnmatch(ffblk->ff_find, dirp->d_name,
|
|
FNM_PATHNAME|FNM_PERIOD) != 0))
|
|
continue;
|
|
strcpy(ffblk->ff_name, dirp->d_name);
|
|
setfiletime(ffblk);
|
|
retval = 0;
|
|
break;
|
|
}
|
|
}
|
|
closedir(dp);
|
|
return(retval);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Bei xfindfirst und xfindnext Datum und Uhrzeit im Fileblock setzen */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
static void
|
|
setfiletime(struct ffblk *ffblk)
|
|
{
|
|
struct stat filestat;
|
|
struct tm *filetime;
|
|
char fn[MAXPATH];
|
|
|
|
sprintf(fn, "%s%s", ffblk->ff_path, ffblk->ff_name);
|
|
stat(fn, &filestat);
|
|
filetime = gmtime(&filestat.st_mtime);
|
|
ffblk->ff_ftime = ((filetime->tm_sec / 2) & 0x1f)
|
|
+ ((filetime->tm_min & 0x3f) << 5)
|
|
+ ((filetime->tm_hour & 0x1f) << 11);
|
|
ffblk->ff_fdate = (filetime->tm_mday & 0x1f)
|
|
+ (((filetime->tm_mon & 0x0f) + 1) << 5)
|
|
+ (((filetime->tm_year - 80) & 0x7f) << 9);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Temporaeren Filenamen generieren und pruefen auf Verwendbarkeit, */
|
|
/* d.h. Grossbuchstaben sind nicht erlaubt, damit die Datei bei ccpread */
|
|
/* gefunden wird. */
|
|
/* */
|
|
/* 31.3.02 DG9OBU auf Verwendung von mkstemp() umgestellt */
|
|
/************************************************************************/
|
|
|
|
char *
|
|
xtempnam(const char *directory, const char *prefix)
|
|
{
|
|
char *fn = NULL;
|
|
size_t i;
|
|
register int x;
|
|
|
|
const char* sixx = "XXXXXX\000";
|
|
|
|
char namebuf[PATH_MAX];
|
|
char xe[128];
|
|
|
|
/* den Dateinamen erstellen, prefix und sechs X fuer mkstemp() */
|
|
memset(xe, 0, sizeof(xe));
|
|
strcpy(xe, prefix);
|
|
strcat(xe, sixx);
|
|
|
|
/* solange bis brauchbarer Filename gefunden */
|
|
while (fn == NULL)
|
|
{
|
|
/* Namen zusammenbauen */
|
|
memset(namebuf, 0, sizeof(namebuf));
|
|
strcpy(namebuf, directory);
|
|
strcat(namebuf, xe);
|
|
|
|
/* File generieren */
|
|
if ((x = mkstemp(&namebuf[0])) > 0)
|
|
{
|
|
/* und gleich wieder schliessen und loeschen */
|
|
close(x);
|
|
unlink(&namebuf[0]);
|
|
|
|
/* Namen pruefen */
|
|
for (i = 0; i < strlen(&namebuf[0]); ++i) /* Filenamen untersuchen */
|
|
if (namebuf[i] != tolower(namebuf[i])) /* Grossbuchstabe geht nicht */
|
|
break;
|
|
|
|
/* wenn Namenspruefung erfolgreich war, dann Namen melden */
|
|
if (i == strlen(namebuf))
|
|
{
|
|
fn = malloc(PATH_MAX);
|
|
strcpy(fn, &namebuf[0]);
|
|
return(fn);
|
|
}
|
|
}
|
|
else break;
|
|
}
|
|
|
|
/* nicht erfolgreich */
|
|
return(NULL);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Ermitteln des freien Festplattenplatzes in Bytes. */
|
|
/* */
|
|
/* Damit es fuer grosse Festplatten keinen Ueberlauf gibt (Rueckgabe */
|
|
/* ist vom Typ LONG), wird ab 1GB freiem Speicher immer 1GB zurueck- */
|
|
/* gemeldet - sieht da jemand Probleme? */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
LONG
|
|
getdiskfree(char *path)
|
|
{
|
|
FILE *fp;
|
|
char str[100];
|
|
ULONG frei = 0L;
|
|
|
|
sprintf(str, "df %s", path);
|
|
|
|
if ((fp = popen(str, "r")) != NULL)
|
|
{
|
|
fgets(str, 100, fp);
|
|
fgets(str, 100, fp);
|
|
pclose(fp);
|
|
sscanf(str, "%*s %*s %*s %lu", &frei);
|
|
|
|
if (frei >= 1024 * 1024 * 1024)
|
|
frei = (1024 * 1024 * 1024);
|
|
else
|
|
frei = (frei * 1024);
|
|
}
|
|
|
|
return (frei);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Fuer das erweiterte AUTOBIN-Protokoll wird die File-Zeit in einem */
|
|
/* Bitfeld gespeichert (s. Doku zu DPBOX), wie es BC++ bei dem Befehl */
|
|
/* getftime verwendet. Hier wird die Linux-Zeit der letzten Aenderung */
|
|
/* verwendet. */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
int getftime(int handle, struct ftime *ftimep)
|
|
{
|
|
struct stat filestat;
|
|
struct tm *filetime;
|
|
|
|
if (fstat(handle, &filestat) == -1)
|
|
return(-1);
|
|
|
|
filetime = gmtime(&filestat.st_mtime);
|
|
|
|
ftimep->ft_tsec = filetime->tm_sec / 2;
|
|
ftimep->ft_min = filetime->tm_min;
|
|
ftimep->ft_hour = filetime->tm_hour;
|
|
ftimep->ft_day = filetime->tm_mday;
|
|
ftimep->ft_month = filetime->tm_mon + 1;
|
|
ftimep->ft_year = filetime->tm_year - 80;
|
|
|
|
return(0);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Fuer DOS-Kompatibilitaet - Programm starten und Exit-Code des */
|
|
/* Programms zurueckgeben */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
int
|
|
spawnl(int mode, const char *path, const char *arg0, const char *arg1,
|
|
const char *arg2, const char *arg3, const char *arg4, const char *arg5)
|
|
{
|
|
pid_t pid;
|
|
int status;
|
|
|
|
if (mode != P_WAIT)
|
|
{
|
|
errno = EINVAL;
|
|
return (-1);
|
|
}
|
|
|
|
if ((pid = fork()) < 0)
|
|
{
|
|
errno = ENOMEM;
|
|
return (-1);
|
|
}
|
|
else
|
|
{
|
|
if (pid == 0)
|
|
{
|
|
if (execl(path, arg0, arg1, arg2, arg3, arg4, arg5, NULL) == -1)
|
|
{
|
|
exit(-1);
|
|
}
|
|
}
|
|
}
|
|
|
|
waitpid(pid, &status, 0);
|
|
return(status);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Groesse des freien RAM feststellen (wenig aussagekraeftig durch */
|
|
/* SWAP-Partition). Schlaegt der Aufruf fehl, wird 0 gemeldet. */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
ULONG
|
|
coreleft(void)
|
|
{
|
|
FILE *fp;
|
|
char str[100];
|
|
ULONG frei = 0L;
|
|
|
|
if ((fp = popen("free -b", "r")) != NULL)
|
|
{
|
|
fgets(str, 100, fp);
|
|
fgets(str, 100, fp);
|
|
pclose(fp);
|
|
sscanf(str, "%*s %*s %*s %lu", &frei);
|
|
}
|
|
return(frei);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Befehlszeile auf Zeichen pruefen, die von der Shell ausgewertet */
|
|
/* werden. Diese werden entwertet durch ein vorangesetztes '\\'. */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
void
|
|
security_check(char *cmd)
|
|
{
|
|
char *cmdpoi = cmd;
|
|
char tmpcmd[MAXPATH];
|
|
register int i = 0;
|
|
char ch;
|
|
|
|
for (; i < MAXPATH - 2; ++i)
|
|
{
|
|
ch = *cmdpoi++;
|
|
if (ch == NUL)
|
|
break;
|
|
if (strchr("*?\\|&;()<>$'`{}[]^#\"", ch) != NULL)
|
|
tmpcmd[i++] = '\\';
|
|
tmpcmd[i] = ch;
|
|
|
|
}
|
|
|
|
tmpcmd[i] = NUL;
|
|
strcpy(cmd, tmpcmd);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* 10ms-Ticker updaten */
|
|
/* */
|
|
/************************************************************************/
|
|
void
|
|
update_timer(void)
|
|
{
|
|
fd_set rmask;
|
|
struct timeval timevalue;
|
|
int max_fd = 0;
|
|
int count;
|
|
register int i;
|
|
int len;
|
|
char buffer[1024];
|
|
socklen_t clilen;
|
|
struct sockaddr_un cli_addr;
|
|
static UWORD roundcounter = 1;
|
|
#ifndef NO_WATCHDOG
|
|
int lasttic10 = tic10;
|
|
#endif
|
|
#ifdef KERNELIF
|
|
int kif_fd = -1;
|
|
#endif
|
|
|
|
gettimeofday(&tv, &tz);
|
|
|
|
tic10 = (tv.tv_sec - tv_old.tv_sec) * 100 +
|
|
(tv.tv_usec - tv_old.tv_usec) / 10000;
|
|
|
|
#ifndef NO_WATCHDOG
|
|
if (tic10 - lasttic10)
|
|
if (write(watch_dog[1], "\0", 1) != 1)
|
|
{
|
|
exit(1);
|
|
}
|
|
#endif
|
|
|
|
FD_ZERO(&rmask);
|
|
|
|
/* Behandlung der Konsole bzw. Socket-Verbindung */
|
|
switch (console_type)
|
|
{
|
|
/* Ein/Ausgabe ueber normales Terminal */
|
|
case CONS_TERM_RUNNING:
|
|
FD_SET(0, &rmask); /* Eingabe Console */
|
|
max_fd = 1;
|
|
break;
|
|
|
|
/* Ein/Ausgabe ueber Socket, aber noch nicht verbunden */
|
|
case CONS_SOCKET_WAITING:
|
|
FD_SET(sockfd, &rmask);
|
|
if (sockfd > max_fd - 1)
|
|
max_fd = sockfd + 1;
|
|
break;
|
|
|
|
/* Ein/Ausgabe ueber verbundenen Socket */
|
|
case CONS_SOCKET_CONNECTED:
|
|
FD_SET(consockfd, &rmask);
|
|
if (consockfd > max_fd - 1)
|
|
max_fd = consockfd + 1;
|
|
break;
|
|
|
|
/* Alles andere ... */
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/*
|
|
|
|
if (!use_socket)
|
|
{
|
|
|
|
FD_SET(0, &rmask);
|
|
max_fd = 1;
|
|
}
|
|
else
|
|
{
|
|
if (!soc_con)
|
|
{
|
|
FD_SET(sockfd, &rmask);
|
|
if (sockfd > max_fd - 1)
|
|
max_fd = sockfd + 1;
|
|
}
|
|
else
|
|
{
|
|
|
|
FD_SET(consockfd, &rmask);
|
|
if (consockfd > max_fd - 1)
|
|
max_fd = consockfd + 1;
|
|
}
|
|
}
|
|
*/
|
|
|
|
if (kiss_active)
|
|
{
|
|
for (i = 0; i < L1PNUM; ++i)
|
|
{
|
|
if (l1port[i].kisslink < 0)
|
|
continue;
|
|
|
|
#ifdef VANESSA
|
|
if (l1port[i].kisstype == KISS_VAN)
|
|
continue;
|
|
#endif
|
|
#ifdef AX_IPX
|
|
if (l1port[i].kisstype == KISS_IPX)
|
|
continue;
|
|
#endif
|
|
#ifdef AX25IP
|
|
if (l1port[i].kisstype == KISS_AXIP)
|
|
continue;
|
|
#endif
|
|
#ifdef KERNELIF
|
|
if ( (l1port[i].kisstype == KISS_KAX25)
|
|
|| (l1port[i].kisstype == KISS_KAX25KJD))
|
|
continue;
|
|
#endif
|
|
#ifdef SIXPACK
|
|
if (l1port[i].kisstype == KISS_6PACK)
|
|
continue;
|
|
#endif
|
|
|
|
if (l1port[i].port_active)
|
|
{
|
|
FD_SET(l1port[i].kisslink, &rmask);
|
|
if (l1port[i].kisslink > max_fd -1)
|
|
max_fd = l1port[i].kisslink + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef KERNELIF
|
|
/* IP-Interface Filedescriptor ermitteln */
|
|
if ((kif_fd = ifip_active()) != -1) /* ein aktives Kernelinterface */
|
|
{
|
|
FD_SET(kif_fd, &rmask);
|
|
if (kif_fd > max_fd - 1)
|
|
max_fd = kif_fd + 1;
|
|
}
|
|
#endif
|
|
|
|
/* fuer alle Interfaces die benutzten Filedescriptoren fuer select() */
|
|
/* ermitteln und eintragen */
|
|
for (i = 0; i < L1PNUM; ++i)
|
|
{
|
|
/* nur aktive Ports bearbeiten */
|
|
if ( (l1port[i].kisslink < 0) || (l1port[i].port_active != TRUE)
|
|
#ifdef SIXPACK
|
|
|| (l1port[i].kisstype == KISS_6PACK) /* der hat hier nichts zu suchen */
|
|
#endif
|
|
)
|
|
continue;
|
|
|
|
|
|
/* Interfacetypen durchgehen */
|
|
if (
|
|
#ifdef KERNELIF
|
|
(l1port[i].kisstype == KISS_KAX25)
|
|
|| (l1port[i].kisstype == KISS_KAX25KJD)
|
|
#endif
|
|
#if defined(KERNELIF) && defined(AX_IPX)
|
|
||
|
|
#endif
|
|
#ifdef AX_IPX
|
|
(l1port[i].kisstype == KISS_IPX)
|
|
#endif
|
|
)
|
|
{
|
|
FD_SET(l1port[i].kisslink, &rmask);
|
|
if (l1port[i].kisslink > max_fd -1)
|
|
max_fd = l1port[i].kisslink + 1;
|
|
}
|
|
} /* for(...) */
|
|
|
|
timevalue.tv_usec = 10000;
|
|
timevalue.tv_sec = 0;
|
|
|
|
if (++roundcounter < maxrounds) /* schon genug Runden vergangen? */
|
|
timevalue.tv_usec = 0;
|
|
else
|
|
roundcounter = 0; /* Durchlaufzaehler ruecksetzen */
|
|
|
|
count = select(max_fd, &rmask, NULL, NULL, &timevalue);
|
|
|
|
if (count == -1)
|
|
return;
|
|
|
|
/* Konsolen/Socketverbindung bearbeiten */
|
|
switch (console_type)
|
|
{
|
|
/* Konsole ist ein Terminal */
|
|
case CONS_TERM_RUNNING:
|
|
/* Zeichen auf der Standardeingabe ? */
|
|
if (FD_ISSET(0, &rmask))
|
|
{
|
|
if ((len = read(0, buffer, 1024)) != -1)
|
|
host_to_queue(buffer, len);
|
|
else
|
|
{
|
|
/* Oh, oh, Fehler beim Lesen von der Konsole */
|
|
/* Es werden nun weitere Konsolenoperationen */
|
|
/* unterdrueckt. */
|
|
console_type = CONS_NO_CONSOLE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* Socket wartet auf Verbindung */
|
|
case CONS_SOCKET_WAITING:
|
|
/* Wartende Verbindung annehmen */
|
|
if (FD_ISSET(sockfd, &rmask))
|
|
{
|
|
clilen = sizeof(cli_addr);
|
|
consockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
|
|
if (consockfd >= 0)
|
|
console_type = CONS_SOCKET_CONNECTED;
|
|
}
|
|
break;
|
|
|
|
/* Daten von verbundenem Socket */
|
|
case CONS_SOCKET_CONNECTED:
|
|
if (FD_ISSET(consockfd, &rmask))
|
|
{
|
|
len = read(consockfd, buffer, 1024);
|
|
if ((len == -1) || (len == 0))
|
|
{
|
|
close(consockfd);
|
|
consockfd = -1;
|
|
console_type = CONS_SOCKET_WAITING;
|
|
}
|
|
else
|
|
host_to_queue(buffer, len);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/*
|
|
|
|
if (!use_socket)
|
|
{
|
|
if (FD_ISSET(0, &rmask))
|
|
if ((len = read(0, buffer, 1024)) != 0)
|
|
host_to_queue(buffer, len);
|
|
}
|
|
else
|
|
{
|
|
if (!soc_con)
|
|
{
|
|
if (FD_ISSET(sockfd, &rmask))
|
|
{
|
|
clilen = sizeof(cli_addr);
|
|
consockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
|
|
if (consockfd >= 0)
|
|
soc_con = TRUE;
|
|
}
|
|
}
|
|
else
|
|
if (FD_ISSET(consockfd, &rmask))
|
|
{
|
|
len = read(consockfd, buffer, 1024);
|
|
if ((len == -1) || (len == 0))
|
|
{
|
|
close(consockfd);
|
|
soc_con = FALSE;
|
|
}
|
|
else
|
|
host_to_queue(buffer, len);
|
|
}
|
|
}
|
|
*/
|
|
|
|
#ifdef KERNELIF
|
|
/* IP-Interface RX */
|
|
if ((kif_fd != -1) && (FD_ISSET(kif_fd, &rmask)))
|
|
ifip_frame_to_router();
|
|
#endif
|
|
|
|
/* alle Ports durchgehen */
|
|
for (i = 0; i < L1PNUM; ++i)
|
|
{
|
|
/* unbenutzte Ports nicht bearbeiten */
|
|
if ( (l1port[i].kisslink < 0) || (l1port[i].port_active != TRUE)
|
|
#ifdef SIXPACK
|
|
|| (l1port[i].kisstype == KISS_6PACK) /* der hat hier nichts zu suchen */
|
|
#endif
|
|
)
|
|
continue;
|
|
|
|
|
|
/* pruefen ob dieser Port einen lesbaren Filedescriptor hat */
|
|
if (FD_ISSET(l1port[i].kisslink, &rmask))
|
|
{
|
|
/* je nach Interfacetyp den richtigen RX aufrufen */
|
|
switch (l1port[i].kisstype)
|
|
{
|
|
#ifdef KERNELIF
|
|
/* Kernel-AX25-Port RX */
|
|
case KISS_KAX25 :
|
|
case KISS_KAX25KJD : ifax_rx(l1port[i].kisslink);
|
|
break;
|
|
#endif
|
|
#ifdef AX_IPX
|
|
/* AXIPX-RX */
|
|
case KISS_IPX : axipx_recv();
|
|
break;
|
|
#endif
|
|
default : continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (kiss_active)
|
|
{
|
|
for (i = 0; i < L1PNUM; ++i)
|
|
{
|
|
if (l1port[i].kisslink == -1)
|
|
continue;
|
|
#ifdef VANESSA
|
|
if (l1port[i].kisstype == KISS_VAN)
|
|
continue;
|
|
#endif
|
|
#ifdef AX_IPX
|
|
if (l1port[i].kisstype == KISS_IPX)
|
|
continue;
|
|
#endif
|
|
#ifdef AX25IP
|
|
if (l1port[i].kisstype == KISS_AXIP)
|
|
continue;
|
|
#endif
|
|
#ifdef KERNELIF
|
|
if ( (l1port[i].kisstype == KISS_KAX25)
|
|
|| (l1port[i].kisstype == KISS_KAX25KJD))
|
|
continue;
|
|
#endif
|
|
#ifdef SIXPACK
|
|
if (l1port[i].kisstype == KISS_6PACK)
|
|
continue;
|
|
#endif
|
|
if (l1port[i].port_active)
|
|
if (FD_ISSET(l1port[i].kisslink, &rmask))
|
|
if ((len = read(l1port[i].kisslink, buffer, 1024)) != 0)
|
|
framedata_to_queue(i, buffer, len);
|
|
}
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Rechner neu starten */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
void
|
|
reboot_system(void)
|
|
{
|
|
exit_all();
|
|
sync();
|
|
/* CRASH(); */
|
|
/*system("/sbin/shutdown -r now");*/
|
|
/* Hierher wird man wohl nur kommen, wenn tnn nicht als root gestartet */
|
|
/* wurde. Nun gibt es 2 Moeglichkeiten: entweder wir starten von vorne, */
|
|
/* weil die Resourcen ja breits freigegeben wurden, oder aber wir */
|
|
/* beenden das Programm, weil das ja mehr oder weniger gefordert wurde. */
|
|
/* Sinnvoller ist es wohl, wenn wir das Programm verlassen, in der */
|
|
/* Hoffnung, dass es danach regulaer von einem Batch erneut gestartet */
|
|
/* wird. Das ist jedenfalls besser, als nix zu tun. */
|
|
exit(1);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Shell-Befehl - Linux-spezifischer Teil: */
|
|
/* Das gewuenschte Programm wird als Hintergrundprozess gestartet. */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
BOOLEAN
|
|
tnnshell(char *cmdline)
|
|
{
|
|
char sysline[MAXPATH + 1];
|
|
|
|
char cFirstArg[MAXPATH + 1];
|
|
|
|
char *pFirstArg = NULL;
|
|
|
|
|
|
MBHEAD* mbp;
|
|
|
|
struct termios term;
|
|
|
|
/* In TNB-Files darf die interaktive Shell nicht verwendet werden */
|
|
if ((tnnb_aktiv == TRUE) && (strlen(cmdline) == 0))
|
|
{
|
|
putmsg("Interactive shell is not allowed in tnb-files !\r");
|
|
return (FALSE);
|
|
}
|
|
|
|
/* Haben wir eine Shell ? */
|
|
if (cShell[0] == 0)
|
|
{
|
|
putmsg("No shell set, use 'setshell' to set one !\r");
|
|
return (FALSE);
|
|
}
|
|
|
|
/* Initialisieren */
|
|
memset(sysline, 0, MAXPATH);
|
|
memset(cFirstArg, 0, MAXPATH);
|
|
memset(&term, 0, sizeof(struct termios));
|
|
|
|
term.c_iflag = ICRNL | IXOFF;
|
|
term.c_oflag = OPOST | ONOCR; /* ONLCR */
|
|
term.c_cflag = CS8 | CREAD | CLOCAL;
|
|
term.c_lflag = ISIG | ICANON;
|
|
|
|
/*
|
|
term.c_iflag = IGNCR | IXOFF;
|
|
term.c_oflag = OPOST | ONLCR | ONLRET | OCRNL;
|
|
term.c_cflag = CS8 | CREAD | CLOCAL;
|
|
term.c_lflag = ISIG | ICANON;
|
|
*/
|
|
|
|
term.c_cc[VINTR] = 3; /* ^C */
|
|
term.c_cc[VSUSP] = 26; /* ^Z */
|
|
term.c_cc[VQUIT] = 28;
|
|
term.c_cc[VERASE] = 8; /* ^H */
|
|
term.c_cc[VKILL] = 24; /* ^X */
|
|
term.c_cc[VEOF] = 4; /* ^D */
|
|
|
|
strncpy(sysline, cmdline, MAXPATH);
|
|
sysline[MAXPATH] = NUL; /* Sicher ist sicher ... */
|
|
|
|
/* Das erste Argument fuer exec bestimmen */
|
|
if ((pFirstArg = strrchr(cShell, '/')) == NULL)
|
|
{
|
|
pFirstArg = cShell;
|
|
}
|
|
else
|
|
{
|
|
++pFirstArg; /* wir wollen das erste Zeichen hinter dem "/" */
|
|
}
|
|
|
|
if (strlen(cmdline) == 0)
|
|
cFirstArg[0] = '-';
|
|
|
|
strcat(cFirstArg, pFirstArg);
|
|
|
|
/* neue Shell abforken */
|
|
if ((userpo->child_pid = forkpty(&userpo->child_fd, NULL, &term, NULL)) == -1)
|
|
{
|
|
/* forkpty() nicht moeglich */
|
|
userpo->child_pid = 0;
|
|
putmsg("Can't fork child process !\r");
|
|
return(FALSE);
|
|
}
|
|
else
|
|
{
|
|
if (userpo->child_pid == 0) /* Kind-Prozess (die Shell) */
|
|
{
|
|
if (strlen(cmdline) == 0)
|
|
{
|
|
execl(cShell, cFirstArg, NULL);
|
|
}
|
|
else
|
|
{
|
|
execl(cShell, cFirstArg, "-c", cmdline, NULL);
|
|
}
|
|
|
|
/* Wenn wir hier ankommen, dann ist wirklich was nicht ok ... */
|
|
exit(-1);
|
|
}
|
|
else /* Hauptprogramm */
|
|
{
|
|
/* Timeout und Interaktivitaet setzen je nach Shell-Typ */
|
|
/* Achtung, Timeout in 100ms-Schritten ! */
|
|
if (strlen(cmdline) == 0)
|
|
{
|
|
mbp = getmbp();
|
|
putprintf(mbp, "Invoking shell, type 'exit' to end your session.\r");
|
|
seteom(mbp);
|
|
userpo->child_timeout = 30000; /* 5 Min. Timeout */
|
|
userpo->child_iactive = TRUE; /* interaktive Shell */
|
|
}
|
|
else
|
|
{
|
|
userpo->child_timeout = 6000; /* 1 Min. Timeout */
|
|
userpo->child_iactive = FALSE; /* keine interaktive Shell */
|
|
}
|
|
|
|
userpo->status = US_EXTP; /* externes Programm laeuft */
|
|
return(TRUE);
|
|
}
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Pruefen, ob Kind-Prozesse beendet sind (vom Sysop gestartete externe */
|
|
/* Programme). Bei Zeitueberschreitung wird das Programm mit einer */
|
|
/* entsprechenden Fehlermeldung abgebrochen. */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
void
|
|
shellsrv(void)
|
|
{
|
|
pid_t c_pid;
|
|
|
|
MBHEAD* mbp;
|
|
|
|
for (userpo = (USRBLK *) usccpl.head;
|
|
userpo != (USRBLK *) &usccpl;
|
|
userpo = (USRBLK *) userpo->unext)
|
|
{
|
|
if (userpo->status != US_EXTP) /* externer Prozess aktiv? */
|
|
continue; /* nein .. */
|
|
|
|
if (userpo->child_pid == 0) /* externer Prozess aktiv? */
|
|
continue; /* nein .. */
|
|
|
|
c_pid = waitpid(userpo->child_pid, /* dieser Prozess beendet? */
|
|
NULL, WNOHANG);
|
|
|
|
/* Prozess noch nicht beendet */
|
|
if (c_pid == 0) /* noch nicht fertig? */
|
|
{
|
|
/* Timeout-Warnung fuer interaktive Shell */
|
|
if ((userpo->child_iactive == TRUE) && (userpo->child_timeout <= 6000))
|
|
{
|
|
MBHEAD* mbp;
|
|
|
|
switch (userpo->child_timeout)
|
|
{
|
|
case 1000 :
|
|
case 2000 :
|
|
case 3000 :
|
|
case 6000 : mbp = putals("WARNING: Your shell times out in ");
|
|
putprintf(mbp, "%u seconds !!!\r", (userpo->child_timeout / 100));
|
|
seteom(mbp);
|
|
break;
|
|
|
|
default : break;
|
|
}
|
|
}
|
|
|
|
/* Shell-Timeout */
|
|
if (--userpo->child_timeout == 0) /* zu lange inaktiv? */
|
|
{
|
|
kill(-(userpo->child_pid), SIGKILL); /* Abbruch (Watchdog) */
|
|
c_pid = waitpid(userpo->child_pid, /* Prozess-Status holen */
|
|
NULL, 0); /* sonst gips 'n Zombie */
|
|
userpo->child_pid = 0;
|
|
putmsg("SHELL SESSION ABORTED (TIMEOUT)\r");
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
shell_to_user();
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/* Shell ist geschlossen */
|
|
if (userpo->child_fd != -1)
|
|
{
|
|
if (c_pid > 0)
|
|
shell_to_user(); /* Letzte Daten abholen */
|
|
|
|
/* Shell nun schon geschlossen ? */
|
|
if (userpo->child_fd != -1)
|
|
{
|
|
close(userpo->child_fd);
|
|
userpo->child_fd = -1;
|
|
}
|
|
}
|
|
|
|
userpo->child_pid = 0; /* Prozess ist fertig */
|
|
userpo->child_timeout = 0;
|
|
userpo->child_iactive = FALSE;
|
|
userpo->status = US_CCP;
|
|
|
|
/* und ab die Post ... */
|
|
mbp = getmbp();
|
|
prompt(mbp);
|
|
seteom(mbp);
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Daten von der Shell abholen und zum User bringen */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
void
|
|
shell_to_user(void)
|
|
{
|
|
fd_set rset;
|
|
|
|
struct timeval tvalue;
|
|
|
|
int i;
|
|
|
|
UBYTE usrtype;
|
|
|
|
/* nur gueltige Descriptoren */
|
|
if (userpo->child_fd == -1)
|
|
return;
|
|
|
|
/* Pruefen, ob die Verbindung noch Daten aufnehmen kann, ist eine L2/L4- */
|
|
/* Verbindung zu voll, dann keine neuen Pakete generieren. An die Hostkonsole wird */
|
|
/* ungebremst ausgegeben. */
|
|
usrtype = g_utyp(userpo->uid);
|
|
|
|
if ( ((usrtype == L2_USER) || (usrtype == L4_USER))
|
|
&& (((LNKBLK *)g_ulink(userpo->uid))->tosend > 100)
|
|
)
|
|
return;
|
|
|
|
FD_ZERO(&rset);
|
|
FD_SET(userpo->child_fd, &rset);
|
|
|
|
tvalue.tv_usec = 0;
|
|
tvalue.tv_sec = 0;
|
|
|
|
/* Daten holen */
|
|
if ((i = select((userpo->child_fd + 1), &rset, NULL, NULL, &tvalue)) < 0)
|
|
{
|
|
putmsg("ERROR while select()-ing descriptor !!!\r");
|
|
close(userpo->child_fd);
|
|
userpo->child_fd = -1;
|
|
userpo->child_timeout = 1; /* Aufraeumen macht shellsrv() */
|
|
}
|
|
else
|
|
{
|
|
/* Daten Shell -> User */
|
|
if ((i > 0) && (FD_ISSET(userpo->child_fd, &rset)))
|
|
{
|
|
unsigned char data[8192];
|
|
|
|
unsigned int uZaehler;
|
|
|
|
ssize_t rd;
|
|
|
|
|
|
MBHEAD* mbp;
|
|
|
|
if ((rd = read(userpo->child_fd, data, 8192)) == -1)
|
|
{
|
|
/* Ist der abgearbeitete Befehl ohne jegliche Rueckgabe, dann wird der Fehler 5 */
|
|
/* erzeugt. Im nicht-interaktiven Modus unterdruecken wir die Fehlermeldung, im */
|
|
/* interaktiven Modus wird er normal angezeigt. */
|
|
if ((errno == EIO) && (userpo->child_iactive == TRUE))
|
|
{
|
|
mbp = putals("");
|
|
putprintf(mbp, "ERROR %u while read()-ing descriptor !!! Shell terminated !\r", errno);
|
|
seteom(mbp);
|
|
}
|
|
close(userpo->child_fd);
|
|
userpo->child_fd = -1;
|
|
userpo->child_timeout = 1; /* Aufraeumen macht shellsrv() */
|
|
}
|
|
|
|
if (rd > 0)
|
|
{
|
|
mbp = getmbp();
|
|
|
|
for (uZaehler = 0; uZaehler < rd; ++uZaehler)
|
|
{
|
|
if (data[uZaehler] == 0x0D)
|
|
continue;
|
|
|
|
if (data[uZaehler] == 0x0A)
|
|
{
|
|
putchr(0x0D, mbp);
|
|
continue;
|
|
}
|
|
|
|
putchr(data[uZaehler], mbp);
|
|
}
|
|
|
|
seteom(mbp);
|
|
|
|
/* Timeout ruecksetzen */
|
|
if (userpo->child_iactive == TRUE)
|
|
userpo->child_timeout = 30000;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* User-Eingabe in mhdp verarbeiten */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
BOOLEAN
|
|
l7tosh(MBHEAD *mhdp)
|
|
{
|
|
if (userpo->status == US_EXTP) /* externer Prozess aktiv? */
|
|
{
|
|
if (userpo->child_iactive == FALSE)
|
|
{
|
|
dealmb(mhdp); /* Abbruchzeile ignorieren */
|
|
userpo->mbhd = NULL;
|
|
kill(-(userpo->child_pid), SIGKILL); /* Abbruch (Watchdog) */
|
|
waitpid(userpo->child_pid, /* Prozess-Status holen */
|
|
NULL, 0); /* sonst gips 'n Zombie */
|
|
putmsg("SHELL ABORTED by User\r");
|
|
userpo->child_pid = 0; /* Prozess ist fertig */
|
|
userpo->child_fd = -1;
|
|
userpo->child_iactive = FALSE;
|
|
userpo->child_timeout = 0;
|
|
userpo->status = US_CCP;
|
|
return(TRUE);
|
|
}
|
|
else
|
|
{
|
|
struct timeval tvalue;
|
|
int i;
|
|
|
|
fd_set wset;
|
|
|
|
FD_ZERO(&wset);
|
|
FD_SET(userpo->child_fd, &wset);
|
|
|
|
tvalue.tv_usec = 0;
|
|
tvalue.tv_sec = 0;
|
|
|
|
if ((i = select((userpo->child_fd + 1), NULL, &wset, NULL, &tvalue)) < 0)
|
|
{
|
|
putmsg("ERROR while select()-ing descriptor !!!)\r");
|
|
userpo->child_fd = -1;
|
|
userpo->child_timeout = 1; /* Aufraeumen macht shellsrv() */
|
|
}
|
|
else
|
|
{
|
|
/* Daten User -> Shell */
|
|
if ((i > 0) && (FD_ISSET(userpo->child_fd, &wset) && (mhdp->mbgc < mhdp->mbpc)))
|
|
{
|
|
unsigned char data[1024];
|
|
unsigned int uBufSize = 0;
|
|
|
|
while (mhdp->mbgc < mhdp->mbpc)
|
|
data[uBufSize++] = getchr(mhdp);
|
|
|
|
/* Daten zum Shell-Child schicken */
|
|
if (write(userpo->child_fd, data, uBufSize) < 0)
|
|
{
|
|
/* Oh oh, das hat nicht geklappt */
|
|
userpo->child_fd = -1;
|
|
userpo->child_timeout = 1; /* Aufraeumen macht shellsrv() */
|
|
}
|
|
else
|
|
{
|
|
/* Timeout ruecksetzen */
|
|
if (userpo->child_iactive == TRUE)
|
|
userpo->child_timeout = 30000;
|
|
}
|
|
|
|
dealmb(mhdp);
|
|
userpo->mbhd = NULL;
|
|
}
|
|
}
|
|
}
|
|
return (TRUE);
|
|
}
|
|
return (FALSE);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Filenamen pruefen */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
BOOLEAN
|
|
good_file_name(const char *file)
|
|
{
|
|
if ( (strncmp("/bin/", file, 5) == 0)
|
|
|| (strncmp("/dev/", file, 5) == 0)
|
|
|| (strncmp("/proc/", file, 6) == 0)
|
|
|| (strncmp("/sbin/", file, 6) == 0)
|
|
|| (strncmp("/usr/bin/", file, 9) == 0)
|
|
|| (strncmp("/usr/sbin/", file, 10) == 0)
|
|
|| (strncmp("/usr/local/bin/", file, 16) == 0)
|
|
|| (strncmp("/usr/local/sbin/", file, 17) == 0))
|
|
return(FALSE);
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
void
|
|
tnnexec(char *file_name)
|
|
{
|
|
if (access(file_name, X_OK) == 0) /* nur ausfuehrbares Programm */
|
|
{
|
|
exit_all(); /* Resourcen freigeben */
|
|
execl(file_name, NULL, NULL); /* Programm starten */
|
|
/* Hierher darf man eigentlich nicht kommen! Daher verlassen wir das */
|
|
/* Programm in der Hoffnung, dass es danach regulaer von einem Batch */
|
|
/* erneut gestartet wird. */
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
void
|
|
init_console(void)
|
|
{
|
|
#ifdef L1TCPIP
|
|
/* Interface Initialisieren. */
|
|
InitIFC();
|
|
#endif /* L1TCPIP */
|
|
|
|
if (console_type == CONS_TERM_DO_SETUP)
|
|
{
|
|
setvbuf(stdout, NULL, _IONBF, 0); /* Ausgabe ungepuffert */
|
|
tcgetattr(fileno(stdin), &oconin_termios);
|
|
tcgetattr(fileno(stdout), &oconout_termios);
|
|
nconin_termios = oconin_termios;
|
|
nconin_termios.c_cc[VTIME] = 0;
|
|
nconin_termios.c_cc[VMIN] = 1;
|
|
nconin_termios.c_cc[VSTART] = -1;
|
|
nconin_termios.c_cc[VSTOP] = -1;
|
|
nconin_termios.c_iflag = IGNBRK;
|
|
nconin_termios.c_oflag = OPOST|ONLCR;
|
|
nconin_termios.c_lflag = 0;
|
|
nconin_termios.c_cflag = (CS8|CREAD|CLOCAL);
|
|
tcsetattr(fileno(stdin), TCSADRAIN, &nconin_termios);
|
|
nconout_termios = oconout_termios;
|
|
nconout_termios.c_cc[VTIME] = 0;
|
|
nconout_termios.c_cc[VMIN] = 1;
|
|
nconout_termios.c_cc[VSTART] = -1;
|
|
nconout_termios.c_cc[VSTOP] = -1;
|
|
nconout_termios.c_iflag = IGNBRK|ICRNL;
|
|
nconout_termios.c_oflag = OPOST|ONLCR|ONLRET|OCRNL;
|
|
nconout_termios.c_lflag = 0;
|
|
nconout_termios.c_cflag = (CS8|CREAD|CLOCAL);
|
|
tcsetattr(fileno(stdout), TCSAFLUSH, &nconout_termios);
|
|
|
|
consfile = stdout;
|
|
console_type = CONS_TERM_RUNNING;
|
|
}
|
|
else
|
|
consfile = NULL;
|
|
|
|
hostq_root = NULL;
|
|
hostq_last = NULL;
|
|
hostq_len = 0;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
void
|
|
exit_console(void)
|
|
{
|
|
struct hostqueue *hostq_ptr;
|
|
|
|
while (hostq_root != NULL)
|
|
{
|
|
hostq_ptr = hostq_root;
|
|
hostq_root = hostq_ptr->next;
|
|
free(hostq_ptr);
|
|
}
|
|
|
|
hostq_last = NULL;
|
|
hostq_len = 0;
|
|
exit_proc();
|
|
|
|
if (console_type != CONS_TERM_RUNNING)
|
|
return;
|
|
|
|
tcsetattr(1, TCSADRAIN, &oconout_termios);
|
|
tcsetattr(0, TCSADRAIN, &oconin_termios);
|
|
|
|
console_type = CONS_NO_CONSOLE;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
static void
|
|
alloc_hostqbuf(void)
|
|
{
|
|
struct hostqueue *hostq_ptr;
|
|
|
|
hostq_ptr = (struct hostqueue *) malloc(sizeof(struct hostqueue));
|
|
if (hostq_ptr == NULL)
|
|
{
|
|
exit_all();
|
|
exit(1);
|
|
}
|
|
|
|
hostq_ptr->first = 0;
|
|
hostq_ptr->last = 0;
|
|
hostq_ptr->next = NULL;
|
|
if (hostq_root == NULL)
|
|
{
|
|
hostq_root = hostq_ptr;
|
|
}
|
|
else
|
|
{
|
|
hostq_last->next = hostq_ptr;
|
|
hostq_last = hostq_ptr;
|
|
}
|
|
|
|
hostq_last = hostq_ptr;
|
|
}
|
|
|
|
/* put one character in host-queue */
|
|
|
|
static void
|
|
puthostq(char ch)
|
|
{
|
|
struct hostqueue *hostq_ptr;
|
|
|
|
if (hostq_root == NULL)
|
|
alloc_hostqbuf();
|
|
|
|
hostq_ptr = hostq_last;
|
|
|
|
if (hostq_ptr->last >= HOSTQ_BUFLEN)
|
|
{
|
|
alloc_hostqbuf();
|
|
hostq_ptr = hostq_last;
|
|
}
|
|
|
|
hostq_ptr->buffer[hostq_ptr->last] = ch;
|
|
hostq_ptr->last++;
|
|
hostq_len++;
|
|
}
|
|
|
|
/* get one character out of host-queue */
|
|
|
|
static char
|
|
gethostq(void)
|
|
{
|
|
struct hostqueue *hostq_ptr;
|
|
char ch;
|
|
|
|
if ((hostq_len == 0) || (hostq_root == NULL)) /* sanity check */
|
|
return(0);
|
|
|
|
hostq_ptr = hostq_root;
|
|
ch = hostq_ptr->buffer[hostq_ptr->first];
|
|
hostq_ptr->first++;
|
|
hostq_len--;
|
|
|
|
if ( (hostq_ptr->first == hostq_ptr->last)
|
|
|| (hostq_ptr->first == HOSTQ_BUFLEN))
|
|
{
|
|
if (hostq_ptr->next == NULL)
|
|
{
|
|
hostq_root = NULL;
|
|
hostq_last = NULL;
|
|
}
|
|
else
|
|
hostq_root = hostq_ptr->next;
|
|
|
|
free(hostq_ptr);
|
|
}
|
|
return(ch);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
void
|
|
hputc(char c)
|
|
{
|
|
int res;
|
|
|
|
if (tnb_ch)
|
|
{
|
|
if (consfile != NULL)
|
|
fputc(c, consfile);
|
|
|
|
return;
|
|
}
|
|
|
|
switch (console_type)
|
|
{
|
|
case CONS_SOCKET_CONNECTED:
|
|
|
|
res = write(consockfd, &c, 1);
|
|
|
|
if (res == -1)
|
|
{
|
|
close(consockfd);
|
|
consockfd = -1;
|
|
console_type = CONS_SOCKET_WAITING;
|
|
}
|
|
|
|
break;
|
|
|
|
case CONS_TERM_RUNNING:
|
|
|
|
if ((c == '\n') || (c == '\r'))
|
|
putchar(LF);
|
|
else
|
|
putchar(c);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
/* return if character available */
|
|
|
|
BOOLEAN
|
|
ishget(void)
|
|
{
|
|
return(hostq_len != 0);
|
|
}
|
|
|
|
/* return if output to console is stopped */
|
|
|
|
BOOLEAN
|
|
ishput(void)
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
/* get one character from console */
|
|
|
|
char
|
|
hgetc(void)
|
|
{
|
|
char ch = gethostq();
|
|
|
|
if (console_type == CONS_TERM_RUNNING)
|
|
if (ch == LF)
|
|
ch = CR;
|
|
|
|
return (ch);
|
|
}
|
|
|
|
/* put received characters in hostbuffer */
|
|
|
|
static void
|
|
host_to_queue(char *buffer, int len)
|
|
{
|
|
char *bufptr;
|
|
register int i = 0;
|
|
|
|
bufptr = buffer;
|
|
|
|
while (i < len)
|
|
{
|
|
puthostq(*bufptr);
|
|
++i;
|
|
bufptr++;
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
BOOLEAN
|
|
init_hardware(int argc, char *argv[])
|
|
{
|
|
char *pEnvShell = NULL;
|
|
int scanned = 1;
|
|
|
|
|
|
umask(0);
|
|
time(&sys_time);
|
|
|
|
/* Kommandozeilenparameter auswerten */
|
|
/* Den Verbose-Modus schon hier feststellen */
|
|
while (scanned < argc)
|
|
{
|
|
/* Parameter "-v" (ausfuehrlichere Meldungen) */
|
|
if (strcmp(argv[scanned], "-v") == 0)
|
|
{
|
|
bVerbose = TRUE;
|
|
}
|
|
++scanned;
|
|
}
|
|
|
|
VMSG("--- Verbose logging started !\n");
|
|
|
|
/* Shell loeschen */
|
|
memset(cShell, 0, sizeof(cShell));
|
|
|
|
VMSG("--- Determining shell-program ...\n");
|
|
|
|
/* Shell aus dem Environment holen */
|
|
if ((pEnvShell = getenv("SHELL")) == NULL)
|
|
fprintf(stderr, "Warning: SHELL not set, can't use external programs !!!\n");
|
|
else
|
|
{
|
|
/* Shell kopieren */
|
|
strncpy(cShell, pEnvShell, sizeof(cShell));
|
|
|
|
/* und sicherheitshalber abschliessen */
|
|
cShell[sizeof(cShell)] = 0;
|
|
VMSG("--- Shell is '%s'\n", cShell);
|
|
}
|
|
|
|
VMSG("--- Reading ini-file ...\n");
|
|
if (read_init_file(argc, argv))
|
|
return(TRUE);
|
|
|
|
VMSG("--- Entering pid-file checks ...\n");
|
|
if (!init_proc())
|
|
exit(1);
|
|
/*
|
|
if (tnn_errfile[0] != NUL)
|
|
{
|
|
}
|
|
*/
|
|
VMSG("--- Allocating mem for %ld buffers ...\n", tnn_buffers);
|
|
|
|
RAMBOT = (char *)malloc(tnn_buffers * sizeof(MAX_BUFFER));
|
|
RAMTOP = RAMBOT + tnn_buffers * sizeof(MAX_BUFFER);
|
|
|
|
if (RAMBOT == NULL)
|
|
{
|
|
VMSG("!!! Allocation mem for %ld buffers failed, trying to allocate for %u buffers now ...\n", tnn_buffers, TNN_BUFFERS);
|
|
RAMBOT = (char *)malloc(TNN_BUFFERS * sizeof(MAX_BUFFER));
|
|
RAMTOP = RAMBOT + TNN_BUFFERS * sizeof(MAX_BUFFER);
|
|
if (RAMBOT == NULL)
|
|
{
|
|
fprintf(stderr, "malloc for buffers failed\n");
|
|
exit(1);
|
|
}
|
|
else
|
|
tnn_buffers = TNN_BUFFERS;
|
|
}
|
|
|
|
if (kiss_active)
|
|
{
|
|
VMSG("--- Initializing KISS-interfaces ...\n");
|
|
if (init_kisslink())
|
|
{
|
|
free(RAMBOT);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
if (console_type == CONS_SOCKET_DO_SETUP)
|
|
{
|
|
VMSG("--- Initializing UNIX-socket interface ...\n");
|
|
if ((sockfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
|
|
{
|
|
fprintf(stderr, "Can't open socket !\n");
|
|
fprintf(stderr, "Error %u : %s\n", errno, strerror(errno));
|
|
fprintf(stderr, "Exiting.\n");
|
|
close(sockfd);
|
|
free(RAMBOT);
|
|
|
|
if (kiss_active)
|
|
exit_kisslink();
|
|
exit(1);
|
|
}
|
|
|
|
memset((char *) &serv_addr, 0, sizeof(serv_addr));
|
|
serv_addr.sun_family = AF_UNIX;
|
|
strcpy(serv_addr.sun_path, tnn_socket);
|
|
servlen = strlen(serv_addr.sun_path) + sizeof(serv_addr.sun_family);
|
|
unlink(serv_addr.sun_path);
|
|
|
|
if (bind(sockfd, (struct sockaddr *) &serv_addr, servlen) < 0)
|
|
{
|
|
fprintf(stderr, "Can't bind socket !\n");
|
|
fprintf(stderr, "Error %u : %s\n", errno, strerror(errno));
|
|
fprintf(stderr, "Exiting.\n");
|
|
close(sockfd);
|
|
free(RAMBOT);
|
|
|
|
if (kiss_active)
|
|
exit_kisslink();
|
|
exit(1);
|
|
}
|
|
|
|
if (listen(sockfd, 5) < 0)
|
|
{
|
|
fprintf(stderr, "Can't listen to socket !\n");
|
|
fprintf(stderr, "Error %u : %s\n", errno, strerror(errno));
|
|
fprintf(stderr, "Exiting.\n");
|
|
free(RAMBOT);
|
|
if (kiss_active)
|
|
exit_kisslink();
|
|
exit(1);
|
|
}
|
|
|
|
console_type = CONS_SOCKET_WAITING;
|
|
|
|
if (getppid() != 1)
|
|
{
|
|
if (fork() != 0)
|
|
{
|
|
/* Parent */
|
|
exit_proc(); /* eigenes PID-File loeschen */
|
|
exit(0);
|
|
}
|
|
else
|
|
{
|
|
sleep(1); /* warten, dass Parent sein PID-File loescht */
|
|
/* Child */
|
|
if (!init_proc())
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
#ifndef NO_WATCHDOG
|
|
VMSG("--- Initializing watchdog ...\n");
|
|
watchdog_init();
|
|
#endif
|
|
|
|
VMSG("--- Installing signal-handlers ...\n");
|
|
#ifdef DEBUG_MODUS
|
|
signal(SIGSEGV, sigsegv);
|
|
signal(SIGTERM, sigterm);
|
|
#endif
|
|
|
|
signal(SIGHUP, SIG_IGN);
|
|
signal(SIGTSTP, SIG_IGN);
|
|
signal(SIGTTIN, SIG_IGN);
|
|
signal(SIGTTOU, SIG_IGN);
|
|
signal(SIGPIPE, SIG_IGN);
|
|
|
|
gettimeofday(&tv, &tz);
|
|
tv_old = tv;
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
#ifndef NO_WATCHDOG
|
|
/************************************************************************/
|
|
/* */
|
|
/* Watchdog - ein vom TNN-Hauptprogramm unabhaengiger Prozess muss */
|
|
/* regelmaessig vom Hauptprogramm Daten erhalten. Bleiben diese Daten */
|
|
/* laenger als 60s aus, wird TNN beendet. */
|
|
/* */
|
|
/************************************************************************/
|
|
static void
|
|
watchdog_init(void)
|
|
{
|
|
pid_t pid;
|
|
time_t wdzeit;
|
|
time_t zeit;
|
|
int num;
|
|
int status;
|
|
char buf[1000];
|
|
|
|
VMSG("--- Initializing watchdog ...\n");
|
|
|
|
if (pipe(watch_dog) < 0)
|
|
{
|
|
fprintf(stderr, "Error %u while creating watchdog's pipe: %s\n", errno, strerror(errno));
|
|
fprintf(stderr, "Exiting.\n");
|
|
exit(1);
|
|
}
|
|
|
|
/* Descriptoren auf non-blocking einstellen */
|
|
num = fcntl(watch_dog[0], F_GETFL, 0);
|
|
num |= O_NONBLOCK;
|
|
fcntl(watch_dog[0], F_SETFL, num);
|
|
|
|
num = fcntl(watch_dog[1], F_GETFL, 0);
|
|
num |= O_NONBLOCK;
|
|
fcntl(watch_dog[1], F_SETFL, num);
|
|
|
|
/* Forken */
|
|
if ((pid = fork()) < 0)
|
|
{
|
|
fprintf(stderr, "Error %u while fork()-ing in watchdog: %s\n", errno, strerror(errno));
|
|
fprintf(stderr, "Exiting.\n");
|
|
exit(1);
|
|
}
|
|
else
|
|
{
|
|
/* Na wer sind wir denn ... */
|
|
if (pid == 0)
|
|
{
|
|
/* wir sind Child (das Hauptprogramm) */
|
|
wdpid[0] = getpid();
|
|
close(watch_dog[0]);
|
|
|
|
sleep(1);
|
|
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
/* und wir sind Parent (der Watchdog) */
|
|
wdpid[0] = pid; /* Child */
|
|
wdpid[1] = getpid(); /* Parent */
|
|
|
|
close(watch_dog[1]);
|
|
|
|
VMSG(" +-> main loop has pid %u\n", wdpid[0]);
|
|
VMSG(" +-> watchdog has pid %u\n", wdpid[1]);
|
|
|
|
signal(SIGHUP, SIG_IGN);
|
|
signal(SIGTSTP, SIG_IGN);
|
|
signal(SIGTTIN, SIG_IGN);
|
|
signal(SIGTTOU, SIG_IGN);
|
|
signal(SIGSEGV, sigsegv);
|
|
|
|
time(&zeit);
|
|
time(&wdzeit);
|
|
|
|
LOOP
|
|
{
|
|
/* Hat sich das Child beendet ? */
|
|
if (waitpid(wdpid[0], &status, WNOHANG))
|
|
{
|
|
/* Child hat sich beendet */
|
|
/* Es gibt nichts mehr zu killen, pid wegwerfen */
|
|
wdpid[0] = 0;
|
|
|
|
VMSG("!!! watchdog: child has exited !\n");
|
|
|
|
if (bVerbose == TRUE)
|
|
{
|
|
if (WIFEXITED(status))
|
|
VMSG(" +-> child exited with code %u\n", WEXITSTATUS(status));
|
|
|
|
if (WIFSIGNALED(status))
|
|
{
|
|
VMSG(" +-> child exited because of signal %u\n", WTERMSIG(status));
|
|
|
|
if (WCOREDUMP(status))
|
|
VMSG(" +-> child wrote a core dump !\n");
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
/* Child sollte laufen, dann schauen, ob es was geschickt hat */
|
|
num = read(watch_dog[0], &buf, sizeof(buf));
|
|
|
|
if ( (num == 0) /* schreibendes Ende der Pipe geschlossen */
|
|
|| ((num < 0) && (errno != EWOULDBLOCK))) /* sonstige Fehler */
|
|
break;
|
|
|
|
if (num > 0)
|
|
{
|
|
time(&wdzeit);
|
|
continue;
|
|
}
|
|
|
|
time(&zeit);
|
|
|
|
if ((zeit - wdzeit) > 60)
|
|
break;
|
|
|
|
sleep(1);
|
|
}
|
|
|
|
time(&wdzeit);
|
|
close(watch_dog[0]);
|
|
|
|
if (wdpid[0] != 0)
|
|
{
|
|
VMSG("!!! watchdog: child has exited abnormally !\n");
|
|
|
|
kill(-wdpid[0], SIGSEGV);
|
|
/* Falls aus irgendeinem Grund SIGSEGV nicht zum Programmende fuehrt, */
|
|
/* kommt ein SIGKILL hinterher. Damit wird sichergestellt, dass der */
|
|
/* Childprozess beendet wird. */
|
|
sleep(1);
|
|
kill(-wdpid[0], SIGKILL);
|
|
}
|
|
|
|
/* Hauptprogramm beenden */
|
|
exit(0);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
void
|
|
exit_hardware(void)
|
|
{
|
|
free(RAMBOT);
|
|
|
|
if (kiss_active)
|
|
exit_kisslink();
|
|
}
|
|
|
|
#ifdef DEBUG_MODUS
|
|
/************************************************************************/
|
|
/* Signalbehandlungsfunktion fuer das Signal SIGTERM */
|
|
/************************************************************************/
|
|
static void
|
|
sigterm(int signo)
|
|
{
|
|
signal(SIGTERM, SIG_IGN);
|
|
printf("sigterm\n");
|
|
quit_program(-1);
|
|
}
|
|
|
|
void
|
|
sigsegv(int signo)
|
|
{
|
|
signal(SIGSEGV, SIG_IGN);
|
|
#ifdef DEBUG_MODUS
|
|
printf("\nTheNetNode verursachte einen unbekannten Systemfehler!!!\n");
|
|
printf("Letzte Funktion war: %s\n", lastfunc);
|
|
#endif
|
|
quit_program(-1);
|
|
}
|
|
#endif
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
int
|
|
exit_all(void)
|
|
{
|
|
exit_mh(); /* MH-Liste sichern */
|
|
save_stat();
|
|
save_configuration();
|
|
personalmanager(SAVE, NULL, NULL); /* Pers. Daten fuer Convers */
|
|
|
|
/* noch laufende Shells killen */
|
|
for (userpo = (USRBLK *) usccpl.head;
|
|
userpo != (USRBLK *) &usccpl;
|
|
userpo = (USRBLK *) userpo->unext)
|
|
{
|
|
if (userpo->status != US_EXTP) /* externer Prozess aktiv? */
|
|
continue;
|
|
|
|
kill(-(userpo->child_pid), SIGKILL); /* Abbruch */
|
|
waitpid(userpo->child_pid, NULL, 0); /* Prozess-Status holen */
|
|
}
|
|
|
|
/* Buffer freigeben */
|
|
free(RAMBOT);
|
|
|
|
/* Ab hier stehen keine Buffer mehr zur Verfuegung, alles was mit Buffern */
|
|
/* zu tun hat, gibt nun nen Segfault ! */
|
|
|
|
if (console_type == CONS_SOCKET_CONNECTED)
|
|
{
|
|
close(consockfd);
|
|
consockfd = -1;
|
|
console_type = CONS_SOCKET_WAITING;
|
|
}
|
|
|
|
if (console_type == CONS_SOCKET_WAITING)
|
|
{
|
|
close(sockfd);
|
|
sockfd = -1;
|
|
}
|
|
else
|
|
exit_console();
|
|
|
|
if (kiss_active)
|
|
exit_kisslink();
|
|
|
|
exit_proc();
|
|
printf("\r\n");
|
|
return(0);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Systembelastung durch TNN berechnen */
|
|
/* diese Routine muss alle 10 Sekunden aufgerufen werden */
|
|
/* */
|
|
/************************************************************************/
|
|
void
|
|
calculate_load(void)
|
|
{
|
|
static long clktck = 0;
|
|
static int oldtime;
|
|
static float oldjiffies[2];
|
|
static pid_t tnnpid;
|
|
FILE *fp;
|
|
int utime;
|
|
int stime;
|
|
register int gtime;
|
|
char proc_name[80];
|
|
|
|
/* im ersten Durchlauf alles aufraeumen */
|
|
if (clktck == 0)
|
|
{
|
|
clktck = sysconf(_SC_CLK_TCK);
|
|
tnnpid = getpid();
|
|
oldjiffies[0] = 0;
|
|
oldjiffies[1] = 0;
|
|
oldtime = 0;
|
|
load[0] = 0;
|
|
load[1] = 0;
|
|
load[2] = 0;
|
|
}
|
|
|
|
sprintf(proc_name , "/proc/%d/stat", tnnpid);
|
|
|
|
/* stat-Datei von TNN oeffnen */
|
|
if ((fp = fopen(proc_name, "r")))
|
|
{
|
|
fscanf(fp, "%*d %*s %*c %*d %*d %*d %*d "
|
|
"%*d %*u %*u %*u %*u %*u %d %d",
|
|
&utime, &stime);
|
|
fclose(fp);
|
|
|
|
/* User- & System-Time addieren und in Sekunden umrechnen */
|
|
gtime = (utime + stime) - oldtime;
|
|
|
|
/* die letzten Zeiten fuer neue Berechnung merken */
|
|
oldtime = utime + stime;
|
|
|
|
/* Prozente ausrechnen */
|
|
tnn_load = ((gtime * 100) / (10 * clktck));
|
|
}
|
|
else
|
|
tnn_load = -1; /* Fehler ! */
|
|
|
|
/* Systemload aus /proc/loadavg lesen */
|
|
if ((fp = fopen("/proc/loadavg", "r")))
|
|
{
|
|
fscanf(fp, "%f %f %f %*s %*s", &load[0], &load[1], &load[2]);
|
|
fclose(fp);
|
|
}
|
|
else
|
|
load[0] = -1;
|
|
|
|
/* gesamte Systembelastung im letzten Messintervall errechnen */
|
|
if ((fp = fopen("/proc/uptime", "r")))
|
|
{
|
|
float actjiffies[2];
|
|
|
|
fscanf(fp, "%f %f", &actjiffies[0], &actjiffies[1]);
|
|
fclose(fp);
|
|
|
|
if (oldjiffies[0] != 0 && oldjiffies[1] != 0)
|
|
sys_load = 100 * (1 - ((actjiffies[1] - oldjiffies[1]) / (actjiffies[0] - oldjiffies[0])));
|
|
|
|
oldjiffies[0] = actjiffies[0];
|
|
oldjiffies[1] = actjiffies[1];
|
|
}
|
|
else
|
|
sys_load = -1;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Load-Werte ausgeben */
|
|
/* */
|
|
/************************************************************************/
|
|
void
|
|
print_load(MBHEAD *mbp)
|
|
{
|
|
ULONG user = 0;
|
|
ULONG sys = 0;
|
|
struct rusage sysusage;
|
|
|
|
if (tnn_load >= 0)
|
|
putprintf(mbp, "\r TNN-Load: %i%%", tnn_load);
|
|
else
|
|
putprintf(mbp, "\r TNN-Load: can't read from /proc !");
|
|
|
|
if (sys_load >= 0)
|
|
putprintf(mbp, "\r Sysload: %.2f%%", sys_load);
|
|
else
|
|
putprintf(mbp, "\r Sysload: can't read from /proc !");
|
|
|
|
/* IO-Last ausgeben (siehe auch man proc) */
|
|
if (load[0] >= 0)
|
|
putprintf(mbp, "\r Loadavg: %.2f %.2f %.2f",
|
|
load[0], load[1], load[2]);
|
|
else /* mhh...Kernel ohne /proc-System compiliert ? */
|
|
putprintf(mbp, "\r Loadavg: can't read from /proc/loadavg !");
|
|
|
|
/* verbrauchte Systemzeit ausgeben, wenn moeglich */
|
|
if (getrusage(RUSAGE_SELF, &sysusage) == 0)
|
|
{
|
|
user = (ULONG)sysusage.ru_utime.tv_sec * 1000L
|
|
+ sysusage.ru_utime.tv_usec / 1000L;
|
|
sys = (ULONG)sysusage.ru_stime.tv_sec * 1000L
|
|
+ sysusage.ru_stime.tv_usec / 1000L;
|
|
|
|
if (getrusage(RUSAGE_CHILDREN, &sysusage) == 0)
|
|
{
|
|
user += (ULONG) sysusage.ru_utime.tv_sec * 1000L
|
|
+ sysusage.ru_utime.tv_usec / 1000L;
|
|
sys += (ULONG) sysusage.ru_stime.tv_sec * 1000L
|
|
+ sysusage.ru_stime.tv_usec / 1000L;
|
|
}
|
|
|
|
if (user > 1000000L || sys > 1000000L)
|
|
putprintf(mbp, "\r CPU time used: user %lus, system %lus",
|
|
user / 1000L, sys / 1000L);
|
|
else
|
|
putprintf(mbp, "\r CPU time used: user %lums, system %lums",
|
|
user, sys);
|
|
}
|
|
}
|
|
|
|
/* ermoeglicht das Setzen einer anderen Shell */
|
|
void ccpsetshell(void)
|
|
{
|
|
MBHEAD *mbp;
|
|
char cBuf[512];
|
|
|
|
const size_t tBufSize = sizeof(cBuf);
|
|
|
|
register size_t tCmdlen = 0;
|
|
|
|
struct stat tFileStat;
|
|
|
|
/* Sysop will aendern und noch was in der Zeile da ? */
|
|
if (issyso())
|
|
{
|
|
/* Sind noch Usereingaben da ? */
|
|
if (skipsp(&clicnt, &clipoi))
|
|
{
|
|
/* Frischer Buffer */
|
|
memset(cBuf, 0, tBufSize);
|
|
|
|
/* Zeile lesen */
|
|
for (; tCmdlen < tBufSize; ++tCmdlen)
|
|
{
|
|
if ((!clicnt) || (*clipoi == ' '))
|
|
break;
|
|
clicnt--;
|
|
cBuf[tCmdlen] = (*clipoi++);
|
|
}
|
|
}
|
|
else /* Syntax anzeigen */
|
|
{
|
|
mbp = putals("usage:\r'setshell /path/to/shell' to set a new shell\r");
|
|
putprintf(mbp, "'setshell ?' to get the current setting\r");
|
|
prompt(mbp);
|
|
seteom(mbp);
|
|
return;
|
|
}
|
|
}
|
|
else /* kein Sysop */
|
|
{
|
|
invmsg();
|
|
return;
|
|
}
|
|
|
|
/* Aktuelle Einstellung anzeigen */
|
|
if ((tCmdlen == 1) && (cBuf[0] == '?'))
|
|
{
|
|
mbp = putals("");
|
|
putprintf(mbp, "current shell is : %s\r", cShell);
|
|
prompt(mbp);
|
|
seteom(mbp);
|
|
return;
|
|
}
|
|
|
|
/* Neue Shell grob ueberpruefen */
|
|
if (access(cBuf, F_OK) == -1) /* gibt es das File ? */
|
|
{
|
|
mbp = putals("");
|
|
putprintf(mbp, "error accessing file '%s': %s\r", cBuf, strerror(errno));
|
|
prompt(mbp);
|
|
seteom(mbp);
|
|
return;
|
|
}
|
|
|
|
/* Nur regulaere Dateien und Links erlaubt */
|
|
if (stat(cBuf, &tFileStat) == -1)
|
|
{
|
|
mbp = putals("");
|
|
putprintf(mbp, "can't get stats for '%s': %s\r", cBuf, strerror(errno));
|
|
prompt(mbp);
|
|
seteom(mbp);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
/* Pruefung */
|
|
if ( ((tFileStat.st_mode & S_IFDIR) == S_IFDIR) /* directory */
|
|
|| ((tFileStat.st_mode & S_IFSOCK) == S_IFSOCK) /* socket */
|
|
|| ((tFileStat.st_mode & S_IFBLK) == S_IFBLK) /* block device */
|
|
|| ((tFileStat.st_mode & S_IFCHR) == S_IFCHR) /* character device */
|
|
|| ((tFileStat.st_mode & S_IFIFO) == S_IFIFO) /* fifo */
|
|
)
|
|
{
|
|
mbp = putals("");
|
|
putprintf(mbp, "'%s' is not a file, can't use !\r", cBuf);
|
|
prompt(mbp);
|
|
seteom(mbp);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* Ausfuehrbar muss es auch noch sein */
|
|
if (access(cBuf, X_OK) == -1) /* nur ausfuehrbares Programm */
|
|
{
|
|
mbp = putals("");
|
|
putprintf(mbp, "file '%s' is NOT marked executable, not accepted !!!\r", cBuf);
|
|
prompt(mbp);
|
|
seteom(mbp);
|
|
return;
|
|
}
|
|
|
|
/* Uebernehmen */
|
|
strncpy(cShell, cBuf, min(sizeof(cShell), tBufSize));
|
|
mbp = putals("");
|
|
putprintf(mbp, "shell changed to : %s\r", cShell);
|
|
prompt(mbp);
|
|
seteom(mbp);
|
|
return;
|
|
}
|
|
|
|
#ifdef L1TCPIP
|
|
/* Pruefe auf TCPIP-Port's */
|
|
int CheckPortTCP(int port)
|
|
{
|
|
switch(kissmode(port))
|
|
{
|
|
#ifdef L1TELNET
|
|
case KISS_TELNET :
|
|
return(TRUE);
|
|
#endif /* L1TELNET */
|
|
|
|
#ifdef L1HTTPD
|
|
case KISS_HTTPD :
|
|
return(TRUE);
|
|
#endif /* L1HTTPD */
|
|
|
|
#ifdef L1IPCONV
|
|
case KISS_IPCONV :
|
|
return(TRUE);
|
|
#endif /* L1IPCONV */
|
|
|
|
#ifdef L1IRC
|
|
case KISS_IRC :
|
|
return(TRUE);
|
|
#endif /* L1IRC */
|
|
|
|
default :
|
|
return(FALSE);
|
|
}
|
|
|
|
return(FALSE);
|
|
}
|
|
#endif /* L1TCPIP */
|
|
|
|
/*
|
|
Dummy-Funktionen
|
|
*/
|
|
|
|
void
|
|
init_timer(void) {}
|
|
void
|
|
DIinc(void) {}
|
|
void
|
|
decEI(void) {}
|
|
void
|
|
exit_timer(void) {}
|
|
void
|
|
init_rs232(void) {}
|
|
|
|
/* End of os/linux/linux.c */
|