DeltaLima
/
TheNetNode-CB
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
TheNetNode-CB/src/l7ccp.c

3301 lines
97 KiB
C
Raw Permalink Blame History

/************************************************************************/
/* */
/* ***** ***** */
/* ***** ***** */
/* ***** ***** */
/* ***** ***** */
/* *************** *************** */
/* ***************** ***************** */
/* *************** *************** */
/* ***** ***** TheNetNode */
/* ***** ***** Portable */
/* ***** ***** Network */
/* ***** ***** Software */
/* */
/* File src/l7ccp.c (maintained by: ???) */
/* */
/* 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 */
/* */
/************************************************************************/
#include "tnn.h"
#ifdef ALIASCMD
extern CMDALIAS *aliaslist;
#endif
static BOOLEAN abort_sbin(MBHEAD *);
static void ccpcmd(void);
static BOOLEAN loadprm(void);
static void put_kMG(MBHEAD *, ULONG);
static void put_pktnum(MBHEAD *, ULONG, ULONG);
static void putptcinfo(PTCENT *, MBHEAD *);
static void l2user(MBHEAD *, WORD, const char *);
static void l4user(MBHEAD *, WORD, const char *);
static void ptcuser(MBHEAD *, WORD, const char *);
static void hostuser(MBHEAD *, WORD, const char *);
static BOOLEAN talk_to(char *, WORD);
static void percent(ULONG, ULONG, int, int, MBHEAD *);
#ifdef L1TCPIP
static void TcpipUser(MBHEAD *, WORD, const char *);
#endif /* L1TCPIP */
#ifdef MAKRO_FILE
static int update_userpo_file(USRBLK *user);
#endif
#ifdef __LINUX__
extern UBYTE console_type;
#endif
/************************************************************************/
/* Pruefen, ob die Autobinaer-Uebertragung abgebrochen werden soll */
/*----------------------------------------------------------------------*/
static BOOLEAN abort_sbin(MBHEAD *mbp)
{
if ((mbp->mbpc - mbp->mbgc) >= 4)
return(get32(mbp) != 0x234f4b23L); /* BC ist zu bloede fuer '#OK#' */
return(FALSE);
}
static void ccpcmd(void)
{
TRILLIAN result;
#ifdef ALIASCMD
CMDALIAS *ap;
char cmdtmp[256], *clipoi2;
int i;
#endif
cpyid(usrcal, calofs(UPLINK, userpo->uid));
#ifdef CONNECTMOD_SET_NODE
switch(g_utyp(userpo->uid)) /* Den User-Typ eines User anhand */
{ /* seiner UID feststellen. */
LNKBLK *l2_link; /* Zeiger auf L2-Ebene. */
CIRBLK *l4_link; /* Zeiger auf L4-Ebene. */
case L2_USER :
/* Den User-Link eines User anhand */
l2_link = g_ulink(userpo->uid); /* seiner UID feststellen. */
SetMyNode(l2_link->viaidl); /* Den Einstiegsknoten liefern, */
break;
case L4_USER:
/* Den User-Link eines User anhand */
l4_link = g_ulink(userpo->uid); /* seiner UID feststellen. */
cpyid(updigi,l4_link->upnod); /* Den Einstiegsknoten liefern, */
/* dafuer nehmen wir den Uplink Knoten. */
break;
/* damit der Compiler auch bei Optimierungen zufrieden ist ... */
default:
updigi[0] = '\0';
break;
}
#endif /* CONNECTMOD_SET_NODE */
if (ismemr()) { /* keine Arbeit ohne Speicher */
if ( userpo->sysflg /* Sysop oder kein Sysop-Port? */
|| g_utyp(userpo->uid) != L2_USER
|| !sysoponly(((LNKBLK*)g_ulink(userpo->uid))->liport)
#ifdef USER_PASSWORD
|| userpo->pwdtyp != PW_NOPW
#endif
)
{
#ifdef ALIASCMD
clipoi2 = clipoi;
i = 0;
/* Kommando extrahieren und in Grossbuchstaben konvertieren */
while (*clipoi2 && *clipoi2 != ' ' && i < 255)
cmdtmp[i++] = toupper(*clipoi2++);
cmdtmp[i] = '\0';
if (i > 0)
{
for (ap = aliaslist; ap != NULL; ap = ap->next)
if (!strcmp(cmdtmp, ap->alias))
break;
if (ap != NULL)
{
strcpy(cmdtmp, ap->cmd); /* neues Kommando einsetzen */
clicnt = strlen(cmdtmp);
if (*clipoi2 == ' ') /* wenn Pars da waren */
{
while (*clipoi2 && clicnt < 255) /* diese anfuegen */
cmdtmp[clicnt++] = *clipoi2++;
cmdtmp[clicnt] = NUL;
}
strcpy(clilin, cmdtmp);
clipoi = clilin;
}
}
#endif
result = intern_command(cmdtab); /* interner Befehl */
if (result == ERRORS) /* Sonderzeichen im Befehl? */
{
inv_cmd();
return;
}
if (result == YES /* kein Interner Befehl */
&& read_txt() /* kein lesbarer Text */
&& extern_command() /* kein externer Befehl */
)
inv_cmd(); /* unbekannter Befehl */
else /* Befehl war OK */
userpo->errcnt = 0;
} else { /* SYSOP-Port */
if (intern_command(syscmdtab))
inv_cmd(); /* einfach nur Invalid Command */
}
}
}
void l7rx(void) {
FILE *prot;
char huge *usnxtc;
WORD usget;
WORD zeichen;
MBHEAD *mhdp;
MBHEAD *usrmhd;
MBHEAD *mbp;
UID uid;
UID p_uid;
PTCENT *ptcp;
CQBUF *cqp;
/*=== eingelaufene Info Frames fuer den CCP verarbeiten ===*/
while ((mhdp = (MBHEAD *) userhd.head) != (MBHEAD *) &userhd.head)
{
ulink((LEHEAD *)mhdp);
uid = mhdp->type; /* User ID lesen */
ptcp = ptctab+uid;
userpo = ptcp->ublk; /* Userblock-Zeiger lesen */
if (userpo == NULL) { /* nicht im CCP? */
dealmb(mhdp);
continue;
}
/*==================================================================*/
/*=== eingelaufene Info Frames fuer User verarbeiten ===*/
/*------------------------------------------------------------------*/
if ((usrmhd = userpo->mbhd) == NULL)
userpo->mbhd = mhdp;
else {
usnxtc = usrmhd->mbbp;
usget = usrmhd->mbgc;
while (usrmhd->mbgc < usrmhd->mbpc)
getchr(usrmhd);
while (mhdp->mbgc < mhdp->mbpc)
putchr(getchr(mhdp), usrmhd);
usrmhd->mbbp = usnxtc;
usrmhd->mbgc = usget;
dealmb(mhdp);
}
while (userpo && (mhdp = userpo->mbhd) != NULL && getlin(mhdp))
{
if (l7tosh(mhdp)) /* Shell hat verarbeitet */
continue;
if (userpo->fp != NULL) /* Laeuft Datei-Uebertragung? */
{
if ( userpo->status == US_SBIN /* binaersenden? */
&& abort_sbin(mhdp) == FALSE) /* kam #OK#?, ignorieren */
{
dealmb(mhdp);
userpo->mbhd = NULL;
continue;
}
fclose(userpo->fp); /* Ja, dann abbrechen */
userpo->fp = NULL;
if (userpo->fname != NULL)
{
xremove(userpo->fname);
free(userpo->fname);
userpo->fname = NULL;
}
mbp = getmbp();
#ifdef SPEECH
putstr(speech_message(141), mbp);
#else
putstr("\r- Aborted -\r\r", mbp);
#endif
prompt(mbp);
seteom(mbp);
dealmb(mhdp); /* Abbruchzeile ignorieren */
userpo->mbhd = NULL;
userpo->status = US_CCP;
continue;
}
if (userpo->status == US_RBIN) /* BIN-Load */
{
program_load(mhdp);
if (mhdp->mbgc == mhdp->mbpc)
{
dealmb(mhdp);
userpo->mbhd = NULL;
}
continue;
}
if (userpo->convers != NULLCONNECTION)
if (convers_input(mhdp))
{
if (mhdp->mbgc == mhdp->mbpc)
{
dealmb(mhdp);
userpo->mbhd = NULL;
}
continue;
}
clipoi = clilin;
clicnt = 0;
#ifdef AUTOBINAERFIX
if (userpo->status == US_WBIN)
{
if ((zeichen = getchr(mhdp)) == CR)
clicnt = 0;
else
{
*clipoi++ = (char)zeichen;
clicnt++;
}
}
#endif /* AUTOBINAERFIX */
while ((mhdp->mbgc < mhdp->mbpc)
&& ((zeichen = getchr(mhdp)) != CR))
{
if ((zeichen == BS) || (zeichen == DEL))
{
if (clicnt != 0)
{
--clipoi;
--clicnt;
}
}
else
{
if ((zeichen != LF) && (clicnt < (WORD)(sizeof(clilin) - 5)))
{
#ifdef __WIN32__
*clipoi++ = (char)zeichen;
#else
*clipoi++ = zeichen;
#endif /* WIN32 */
++clicnt;
}
}
}
*clipoi = NUL; /* und mit NUL terminieren! */
if (mhdp->mbgc == mhdp->mbpc)
{
dealmb(mhdp);
userpo->mbhd = NULL;
}
/*=== Zeile vom User auswerten ===*/
switch (userpo->status) {
case US_WBIN :
start_autobin();
continue;
case US_RTXT :
load_text();
continue;
}
#ifdef PACSAT
if (userpo->pacsat != NULL) {
l7_to_pacsat();
continue;
}
#endif
clipoi = clilin;
switch (userpo->status) {
case US_WPWD :
case US_WUPW :
get_password();
mbp = getmbp();
prompt(mbp);
seteom(mbp);
continue;
#ifdef USERPROFIL
case US_UPWD :
if (CheckPasswd())
{
mbp = getmbp();
putstr("Invalid Password\r", mbp);
seteom(mbp);
SendPasswdStringProfil();
continue;
}
userpo->status = US_CCP;
send_ctext();
continue;
#endif /* USERPROFIL */
case US_TALK :
if (*clipoi == '/' && tolower(*(clipoi+1)) == 'q')
{
mbp = getmbp();
prompt(mbp);
seteom(mbp);
userpo->talkcall[0] = NUL;
userpo->status = US_CCP;
}
else
talk_to(userpo->talkcall, 0);
continue;
case US_CREQ :
p_uid = ptcp->p_uid;
disusr(p_uid);
ptcp->p_uid = NO_UID;
ptctab[p_uid].p_uid = NO_UID;
userpo->status = US_CCP;
break;
case US_CQ :
for (cqp = (CQBUF *)cq_user.head;
cqp != (CQBUF *)&cq_user;
cqp = cqp->next)
{
if (cqp->uid == userpo->uid)
{
dealoc((MBHEAD *)ulink((LEHEAD *)cqp));
break;
}
}
userpo->status = US_CCP;
ptcp = ptctab + uid;
ptcp->p_uid = NO_UID;
break;
}
clipoi = clilin;
/* hier werden alle Eingaben in einer Datei protokolliert */
/* wenn dies gewuenscht wird ! */
if ( (proto == 2) ||
((proto == 1) && (issyso () )))
{
if ((prot = xfopen("COMMAND.LOG", "at")) != NULL)
{
fprintf(prot, "(%u) %.6s %s > %s\n\n",
uid,
calofs(UPLINK, uid),
ctime(&sys_time),
clipoi);
fclose(prot);
}
}
if (skipsp(&clicnt, &clipoi))
ccpcmd(); /* Zeile mit Inhalt */
else
{ /* leere Zeile */
mbp = getmbp();
prompt(mbp);
seteom(mbp);
} /* else */
} /* while */
} /* while */
}
/************************************************************************/
/* */
/* Wenn noch Reste aus einer Datei zu senden sind, diese an den User */
/* senden */
/* */
/************************************************************************/
void
l7tx(void)
{
MBHEAD *mbp;
LONG pos;
WORD c;
WORD i;
#ifdef PORT_MANUELL
LNKBLK *link;
UWORD PacLen = FALSE;
#endif /* PORT_MANUELL */
for (userpo = (USRBLK *) usccpl.head;
userpo != (USRBLK *) &usccpl;
userpo = (USRBLK *) userpo->unext)
{
if (userpo->status == US_DIG)
{
gateway();
if (userpo->status == US_DIG)
userpo->status = US_CCP;
continue;
}
if (userpo->fp != NULL)
{
#ifdef PORT_MANUELL
switch (g_utyp(userpo->uid))
{
case L2_USER:
link = g_ulink(userpo->uid);
PacLen = portpar[link->liport].paclen;
break;
default:
PacLen = 236;
break;
}
#endif /* PORT_MANUELL */
do
{
pos = ftell(userpo->fp);
mbp = getmbp();
if (userpo->status == US_SBIN)
{
#ifdef PORT_MANUELL
for (i = 0; i < PacLen; ++i)
#else
for (i = 0; i < paclen; ++i)
#endif /* PORT_MANUELL */
{
if ((c = fgetc(userpo->fp)) == EOF)
break; /* for ... */
#ifdef __WIN32__
putchr((char)c, mbp);
#else
putchr(c, mbp);
#endif /* WIN32 */
}
}
else
{
#ifdef MAKRO_FILE
/* USERPO->FILE nach Makros untersuchen */
/* und neue USER->FILE erstellen. */
/* Gibt es einen Fehler in der funktion */
/* update_userpo_file(userpo); wird die */
/* alte userpo->fp genommen! */
update_userpo_file(userpo);
#endif
#ifdef PORT_MANUELL
for (i = 0; i < PacLen; ++i)
#else
for (i = 0; i < paclen; ++i)
#endif /* PORT_MANUELL */
{
if ((c = fgetc(userpo->fp)) == EOF)
break; /* for ... */
if (c != CR)
#ifdef __WIN32__
putchr((char)(c == '\n' ? CR : c), mbp);
#else
putchr(c == '\n' ? CR : c, mbp);
#endif /* WIN32 */
}
}
}
while (i && send_msg(FALSE, mbp)); /* sind wir losgeworden */
if (i) /* spaeter versuchen */
{
dealmb((MBHEAD *)ulink((LEHEAD *) mbp));
fseek(userpo->fp, pos, SEEK_SET);
}
else /* Ende erreicht */
{
#ifdef MAKRO_FILE
/* Alle Daten verarbeitet, */
/* dies markieren. */
userpo->read_ok = FALSE;
#endif
putchr('\r', mbp);
prompt(mbp);
send_msg(TRUE, mbp);
fclose(userpo->fp);
userpo->fp = NULL;
if (userpo->fname != NULL)
{
xremove(userpo->fname);
free(userpo->fname);
userpo->fname = NULL;
}
userpo->status = US_CCP;
}
}
}
convers_output();
}
/**************************************************************************/
/* BEACON */
/*------------------------------------------------------------------------*/
void ccpbea(void)
{
MBHEAD *mbp;
BEACON *beapoi;
char call[L2IDLEN];
char digil[L2VLEN+1];
WORD port;
WORD interval;
WORD telemetrie;
WORD chaptr;
if (issyso())
{
skipsp(&clicnt, &clipoi);
if (clicnt)
if ((port = (WORD) (nxtnum(&clicnt, &clipoi) & 0x7F)) < L2PNUM) {
beapoi = &beacon[port];
skipsp(&clicnt, &clipoi);
if (*clipoi == '=') {
++clipoi;
--clicnt;
skipsp(&clicnt, &clipoi);
chaptr = 0;
while ((clicnt-- >0) && chaptr < 79)
beapoi->text[chaptr++] = *clipoi++;
beapoi->text[chaptr] = NUL;
if (beapoi->text[0] == '.')
beapoi->text[0] = NUL;
} else {
interval = nxtnum(&clicnt, &clipoi);
telemetrie = nxtnum (&clicnt, &clipoi);
if (getcal(&clicnt, &clipoi, FALSE, call) == YES) {
cpyid(beapoi->beades, call);
getdig(&clicnt, &clipoi, TRUE, digil);
cpyidl(beapoi->beadil, digil);
beapoi->interval = interval;
beapoi->telemetrie = telemetrie;
if (beapoi->interval != 0)
{
beapoi->beatim = interval; /* vorzeitige Aussendung erwirken */
beacsv();
}
}
}
userpo->sysflg = 2;
}
}
mbp = putals("Beacons:\r");
for (port = 0, beapoi = beacon; port < L2PNUM; ++port, ++beapoi) {
if (beapoi->interval != 0) {
if (userpo->sysflg == 2)
beapoi->beatim = 0;
putnum(port, mbp);
putchr(' ', mbp);
putnum(beapoi->interval, mbp);
putchr(' ', mbp);
putnum(beapoi->telemetrie, mbp);
putchr(' ', mbp);
putid(beapoi->beades, mbp);
putdil(beapoi->beadil, mbp);
putchr('\r', mbp);
putstr(beapoi->text, mbp);
putchr('\r', mbp);
}
}
prompt(mbp);
seteom(mbp);
}
/**************************************************************************/
/* READ - Datei lesen */
/*------------------------------------------------------------------------*/
void ccpread(char *text) /* READ - Befehl (Dateien lesen) */
{
char file[MAXPATH+1];
MBHEAD *mbp;
#ifdef __WIN32__
int a;
#endif
/* wenn text == NULL, dann war es ein Readbefehl
ansonsten enthaelt text entweder den Namen einer Infodatei
oder einer Tempdatei
ob die Datei geloescht werden muss, erfaehrt man,
wenn userpo->fname != NULL ist
*/
if (text != NULL)
{
normfname(text);
if (strpbrk(text, ":\\/") == NULL) {
strcpy(file, textpath);
strcat(file, text);
}
else
strcpy(file, text);
userpo->fp = xfopen(file, "rt");
}
else
{
if (issyso())
{
strncpy(file, (char*)clipoi, MAXPATH);
file[MAXPATH] = NUL;
#ifdef WIN32
a = strlen((char*)clipoi);
if (a == 0) {
mbp = getmbp();
#ifdef SPEECH
putstr(speech_message(142), mbp);
#else
putstr("Sri, no text available!\r", mbp);
#endif
prompt(mbp);
seteom(mbp);
return;
}
#endif
}
userpo->fp = xfopen(file, "rt");
}
if (userpo->fp == NULL) {
mbp = getmbp();
if (text != NULL)
if (strcmp(text, "CMD.TMP") == 0) {
#ifdef SPEECH
putstr(speech_message(143), mbp);
#else
putstr("CLI failed!\r", mbp);
#endif
prompt(mbp);
seteom(mbp);
return;
}
if (userpo->fname != NULL)
{
free(userpo->fname);
userpo->fname = NULL;
}
#ifdef SPEECH
putstr(speech_message(142), mbp);
#else
putstr("Sri, no text available!\r", mbp);
#endif
prompt(mbp);
seteom(mbp);
}
}
/**
* Parameter-Auswertung fuer LOAD/EDIT.
* Es kann immer nur ein EDIT/LOAD zur Zeit laufen, dafuer aber mit
* vollen Pfaden. Dies ist wohl keine echte Einschraenkung, es sollten
* sowieso nicht zwei Sysops auf einmal schrauben, das bringt nur Chaos.
*/
static BOOLEAN loadprm(void) {
char name[MAXPATH], *c;
if (issyso()) {
if (!*loadname)
{
clipoi[clicnt] = NUL;
if (sscanf((char *) clipoi, "%s", name) == 1)
{
/* TMP-File auf dem Pfad des Zielfiles wegen Rename */
if (strpbrk(name, ":/\\") == NULL)
{
strcpy(loadname, textpath);
strcpy(loadtmp, textpath);
}
else
{
strcpy(loadtmp, name);
if ((c = strrchr(loadtmp, '/')) == NULL)
if ((c = strrchr(loadtmp, '\\')) == NULL)
c = strchr(loadtmp, ':');
c++;
*c = NUL;
}
strcat(loadname, name);
strcat(loadtmp, "LOAD.TMP");
return(TRUE);
} else
#ifdef SPEECH
putmsg(speech_message(188));
#else
putmsg("Invalid filename!\r");
#endif
} else
#ifdef SPEECH
putmsg(speech_message(189));
#else
putmsg("EDIT/LOAD in use by other Sysop\r");
#endif
}
else
invmsg();
return(FALSE);
}
/**************************************************************************/
/* EDIT */
/*------------------------------------------------------------------------*/
void ccpedi(void)
{
MBHEAD *mbp;
#ifdef EDITOR
if (loadprm())
{
#ifndef MC68302
if ((loadfp = xfopen(loadtmp, "wt")) != NULL)
#else
xremove(loadname);
if ((loadfp = xfopen(loadname, "wt")) != NULL)
#endif
{
userpo->status = US_RTXT;
mbp = getmbp();
#ifdef SPEECH
putprintf(mbp, speech_message(175), loadname);
#else
putprintf(mbp, "editing>%s\r"
"Enter text. End with '.' in a new line.\r", loadname);
#endif
seteom(mbp);
}
else {
#ifdef SPEECH
putmsg(speech_message(190));
#else
putmsg("Open error!\r");
#endif
loadname[0] = loadtmp[0] = NUL;
}
}
#else
if (loadprm()) {
#ifndef MC68302
if ((loadfp = xfopen(loadtmp, "wt")) != NULL)
#else
xremove(loadname);
if ((loadfp = xfopen(loadname, "wt")) != NULL)
#endif
{
userpo->status = US_RTXT;
mbp = getmbp();
#ifdef SPEECH
putprintf(mbp, speech_message(175), loadname);
#else
putprintf(mbp, "editing>%s\r"
"Enter text. End with '.' in a new line.\r", loadname);
#endif
seteom(mbp);
}
else {
#ifdef SPEECH
putmsg(speech_message(190));
#else
putmsg("Open error!\r");
#endif
loadname[0] = loadtmp[0] = NUL;
}
}
#endif /* EDITOR */
}
/**************************************************************************/
/* LOAD */
/*------------------------------------------------------------------------*/
void ccpload(void)
{
MBHEAD *mbp;
if (loadprm()) {
#ifndef MC68302
if ((loadfp = xfopen(loadtmp, "wb")) != NULL)
#else
xremove(loadname);
if ((loadfp = xfopen(loadname, "wb")) != NULL)
#endif
{
userpo->status = US_WBIN;
mbp = getmbp();
#ifdef SPEECH
putstr(speech_message(144), mbp);
#else
putstr("Waiting for AUTOBIN-Transfer...\r", mbp);
#endif
seteom(mbp);
checksum = 0L;
crc = 0;
}
else {
#ifdef SPEECH
putmsg(speech_message(191));
#else
putmsg("File error!\r");
#endif
loadname[0] = loadtmp[0] = NUL;
}
}
}
/**************************************************************************/
/* SysOp */
/*------------------------------------------------------------------------*/
void ccpsys(void) /* SYSOP - Befehl (Als Sysop anmelden) */
{
#ifndef USER_PASSWORD
WORD num;
WORD i, j;
MBHEAD *mbp;
if (paswle != 0)
{
mbp = putals("");
srand((UWORD)tic10);
for (i = 0; i < 5; ++i) {
do {
do;
while (((num = (rand()%256)) >= paswle) || (paswrd[num] == ' '));
for (j = 0; j < i; ++j) {
if ((userpo->paswrd[j] & 0xFF) == num)
break;
}
} while (i != j);
#ifdef __WIN32__
userpo->paswrd[i] = (unsigned char)num;
#else
userpo->paswrd[i] = num;
#endif /* WIN32 */
putchr(' ', mbp);
putnum((num + 1), mbp);
}
putchr('\r', mbp);
seteom(mbp);
for (i = 0; i < 5; ++i) /* Antwort aufbauen */
userpo->paswrd[i] = paswrd[userpo->paswrd[i]];
userpo->status = US_WPWD;
}
#else
WORD num;
WORD i, j;
MBHEAD *mbp;
FILE *fp;
BOOLEAN found = FALSE;
char *pwd = paswrd;
int pwl = paswle;
char userpwd[100];
char call1[L2IDLEN];
char call2[L2IDLEN];
char line[256];
char fn[MAXPATH];
char *c;
if (userpo->pwdtyp == PW_NOPW)
{
cpyid(call1, calofs(UPLINK, userpo->uid));
if ((fp = xfopen("PERMS.TNN", "rt")) != NULL)
{
while (fgets(line, 256, fp) != NULL)
{
if (line[0] == '#') /* Kommentarzeile ignorieren */
continue;
str2call(call2, line); /* Call steht am Zeilenanfang */
if (cmpcal(call1, call2)) /* User gefunden? */
{
sscanf(line, "%*s %s", fn); /* Filename steht an 2. Stelle */
found = TRUE; /* Password-File gefunden */
break;
}
}
fclose(fp);
}
if (found) /* wenn Password-File angegeben */
{
if ((fp = xfopen(fn, "rt")) != NULL) /* existiert PWD-File? */
{
fgets(userpwd, 81, fp); /* Password lesen */
if ((c = strchr(userpwd, '\n')) != NULL)
*c = NUL;
if ((i = strlen(userpwd)) >= 5) /* min. 5 Zeichen! */
{
pwd = userpwd;
pwl = i;
}
else
found = FALSE; /* war nix - also globales PWD */
fclose(fp);
}
}
}
if (pwl >= 5)
{
mbp = putals("");
srand((UWORD)tic10);
for (i = 0; i < 5; ++i)
{
do
{
do; while (((num = (rand()%256)) >= pwl) || (pwd[num] == ' '));
for (j = 0; j < i; ++j)
{
if ((userpo->paswrd[j] & 0xFF) == num)
break;
}
} while (i != j);
#ifdef __WIN32__
userpo->paswrd[i] = (UBYTE)num;
#else
userpo->paswrd[i] = num;
#endif
putchr(' ', mbp);
putnum((num + 1), mbp);
}
putchr('\r', mbp);
seteom(mbp);
for (i = 0; i < 5; ++i) /* Antwort aufbauen */
userpo->paswrd[i] = pwd[userpo->paswrd[i]];
userpo->status = US_WPWD;
if (found) /* war User-Password */
userpo->status = US_WUPW;
}
#endif
}
/************************************************************************/
/* USER */
/*----------------------------------------------------------------------*/
void ccpuse(void)
{
WORD port;
MBHEAD *mbp;
#define USE_ALL 255
#define USE_MASK 254
#define USE_CALL 253
#define USE_CONV 252
#define USE_HOST 251
char call[L2IDLEN+1];
char mask[MAXMASK];
int i;
/* Titelzeile in neuen Buffer */
mbp = putals(" ");
putprintf(mbp, "%s%d)", signon, nmbfre);
i = mbp->mbpc;
/* Ueberpruefen, ob Befehl mit Parametern eingegeben wurde... */
if (skipsp(&clicnt, &clipoi))
{
if (getport(&clicnt, &clipoi, &port)) {
/* Bei U Port alle L2-Uses dieses Ports zeigen */
l2user(mbp, port, "");
if (i == mbp->mbpc) putchr('\r', mbp);
prompt(mbp);
seteom(mbp);
return;
}
if (strchr(clipoi, '+'))
{
l2user(mbp, USE_ALL, ""); /* Level 2 User in Tabellenform anzeigen */
l4user(mbp, USE_ALL, ""); /* Level 4 User in Tabellenform anzeigen */
#ifdef L1TCPIP
TcpipUser(mbp, USE_ALL, "");/* Tcpip-User in Tabellenform anzeigen. */
#endif /* L1TCPIP */
hostuser(mbp, USE_ALL, ""); /* Host-User in Tabellenform anzeigen */
} else
if (toupper(*clipoi) == 'C' && clicnt == 1)
{
l4user(mbp, USE_ALL, ""); /* Bei U C nur die L4 User ausgeben */
} else
if (toupper(*clipoi) == 'L' && clicnt == 1)
{
l2user(mbp, USE_ALL, ""); /* Bei U L alle L2 user anzeigen */
} else
if (toupper(*clipoi) == 'H' && clicnt == 1)
{
ptcuser(mbp, USE_CONV, "");
ptcuser(mbp, USE_HOST, "");
#ifdef L1TCPIP
TcpipUser(mbp, USE_ALL, ""); /* Telnet-User in Tabellenform anzeigen*/
#endif /* L1TCPIP */
hostuser(mbp, USE_ALL, "");
} else
if (getcal(&clicnt, &clipoi, TRUE, call) == YES) {
ptcuser(mbp, USE_CALL, call);
l2user(mbp, USE_CALL, call);
l4user(mbp, USE_CALL, call);
#ifdef L1TCPIP
TcpipUser(mbp, USE_CALL, call);/* Telnet-User in Tabellenform anzeigen */
#endif /* L1TCPIP */
hostuser(mbp, USE_CALL, call);
} else
if (mhprm(clipoi, clicnt, mask) == TRUE) {
ptcuser(mbp, USE_MASK, mask);
l2user(mbp, USE_MASK, mask);
l4user(mbp, USE_MASK, mask);
#ifdef L1TCPIP
TcpipUser(mbp, USE_MASK, mask); /* Telnet-User in Tabellenform anzeigen*/
#endif /* L1TCPIP */
hostuser(mbp, USE_MASK, mask);
}
if (i == mbp->mbpc) putchr('\r', mbp);
}
else
ptcuser(mbp, USE_ALL, "");
prompt(mbp);
seteom(mbp);
}
/*
* Formatierte Ausgabe einer Zahl 7stellig plus Suffix (k, M, G)
*/
static void put_kMG(MBHEAD *mbp, ULONG num) {
const char *kMG = " kMG";
int suffix = 0;
while ((num > 999999L) && (suffix < 3)) {
num /= 1024L;
suffix++;
}
putprintf(mbp, " %6lu%c", num, kMG[suffix]);
}
/************************************************************************/
/* */
/* Formatierte Ausgabe evtl. sehr grosser Zahlen mit Punkten. */
/* Die tatsaechliche Zahl besteht aus den Teilen "num" und "millions", */
/* die zusammengerechnet werden muessen zu "num + millions * 1000000". */
/* */
/************************************************************************/
static void
put_pktnum(MBHEAD *mbp, ULONG millions, ULONG num)
{
char str[20];
char *p;
int len;
int i;
sprintf(str, "%lu%06lu", millions, num);
p = str;
while (*p == '0')
p++;
for (i = len = (int) strlen(p); i > 0; i--)
{
if ((i % 3) == 0)
if (i != len)
putchr(',', mbp);
putchr(*p++, mbp);
}
}
/*
* Baudrate, Counter und Connect-Zeit aus der Patchcord-Tabelle ausgeben.
*/
static void putptcinfo(PTCENT *ptcp, MBHEAD *mbp) {
ULONG Baud = (ptcp->rxbps + ptcp->txbps) * 8;
#ifndef CONNECTTIME
ULONG d, h, m, s;
/* Die Ausgabe aller Werte erfolgt 7stellig plus Suffix (k, M, G) */
#endif /* CONNECTTIME */
put_kMG(mbp, ptcp->inforx); /* empfangene Bytes */
put_kMG(mbp, ptcp->infotx); /* gesendete Bytes */
put_kMG(mbp, Baud); /* errechnete Baudrate */
#ifndef CONNECTTIME
d = ptcp->contime;
s = d % 60L; d /= 60L;
m = d % 60L; d /= 60L;
h = d % 24L; d /= 24L;
if (d < 1L)
putprintf(mbp, " %2lu:%02lu:%02lu", h, m, s); /* hh:mm:ss */
else
if (d < 99L)
putprintf(mbp, " %2lu/%02lu:%02lu", d, h, m); /* dd/hh:mm */
else
putprintf(mbp, "%5lu/%02lu", d, h); /* ddddd/hh */
#else /* CONNECTTIME */
putprintf(mbp, " %s", ConnectTime(ptcp->contime));
#endif /* CONNECTTIME */
}
/*------------------------------------------------------------------------*/
/*
* Level 2 User in Tabellenform anzeigen:
*
* Po SrcCall DstCall LS Rx Tx Tr SRTT RxkB TxkB Baud ConTime Pri
* -------------------------------------------------------------------------
* 0 DD1FR DB0KH IXF 2 10 3 1234 3456 72345 122 0:45:16 0
* 1 DB0KH DF7ZE REJ 0 0 0 254 652 52345 345 1:23:01 10
* / / / / / / / / / / / / /
* 0) 1) 2) 3) 4) 5) 6) 7) 8) 9) 10) 11) 12)
* 0) Port
* 1) Quellrufzeichen des L2-QSOs
* 2) Zielrufzeichen des L2-QSOs
* 3) L2-Link-Status:
* SET = Link-Setup
* FMR = Frame Reject
* DRQ = Disconnect Request
* IXF = Info Transfer
* REJ = REJ Sent
* WAK = Waiting Ackknowledge
* DBS = Device Busy
* RBS = Remote Busy
* BBS = Both Busy
* WDB = Waiting Ack And Device Busy
* WRB = Waiting Ack And Remote Busy
* WBB = Waiting Ack And Both Busy
* RDB = REJ Sent and Device Busy
* RRB = REJ Sent and Remote Busy
* RBB = REJ Sent and Both Busy
* HTH = HTH waiting
* 4) Anzahl der empfangenen Frames in der Warteschlange fuer diesen
* Link
* 5) Anzahl der noch zu sendenden Frames in der Warteschlange fuer
* diesen Link
* 6) Anzahl Retries
* 7) Stand des 'Smoothed Round Trip Timers'
* 8) Anzahl empfangender Bytes seit Bestehen des Links
* 9) Anzahl gesendetet Bytes seit Bestehen des Links
* 10) Aus 8) + 9) errechnete effektive Baudrate fuer diesen Link
* 11) Connectzeit
* 12) Bei DAMA-Netzeinstiegen: aktuelle Prioritaet des Users
* (0 = hoechste Prioritaet)
* */
static void l2user(MBHEAD *mbp, WORD what, const char *pstr)
{
LNKBLK *lp;
char lsts[] = {"DISSETFMRDRQIXFREJWAKDBSRBSBBSWDBWRBWBBRDBRRBRBBHTH"};
char tmp1[10],
tmp2[10];
LHEAD *actlp;
PTCENT *ptcp;
int port;
BOOLEAN first = TRUE;
for (port = 0, actlp = &l2actl[0]; port < L2PNUM; port++, actlp++) {
for (lp = (LNKBLK *) actlp->head;
lp != (LNKBLK *) actlp;
lp = lp->next) {
switch (what) {
case USE_ALL : break;
case USE_MASK : if ( !c6mtch(lp->dstid, pstr)
&& !c6mtch(lp->srcid, pstr)) continue;
break;
case USE_CALL : if ( !cmpid(lp->dstid, pstr)
&& !cmpid(lp->srcid, pstr)) continue;
break;
default : if (what < L2PNUM && port != what) continue;
}
ptcp = ptctab + g_uid(lp, L2_USER);
mbp->l4time = mbp->mbpc;
call2str(tmp1, lp->srcid);
call2str(tmp2, lp->dstid);
if (first) {
putstr("\rL2 - User:\r", mbp);
putstr("Po SrcCall DstCall LS Rx Tx Tr SRTT RxB TxB Baud ConTime Pr Da\r", mbp);
putstr("-------------------------------------------------------------------------------\r", mbp);
first = FALSE;
}
putprintf(mbp, "%2d %-9.9s %-9.9s %3.3s%3u%3u%3u%5u",
lp->liport, /* Port nr user */
tmp1, /* Quell-Rufzeichen */
tmp2, /* Ziel-Rufzeichen */
&lsts[lp->state * 3], /* Link-Status */
lp->rcvd, /* Frames in RX-Queue */
lp->tosend, /* Frames in TX-Queue */
lp->tries, /* Link-Retries */
lp->SRTT); /* Round Trip Timer */
putptcinfo(ptcp, mbp);
if (dama(lp->liport))
putprintf(mbp, " %2d %2d\r", /* DAMA-Prioritaet */
lp->damapm,
portpar[lp->liport].dch + 1);
else
putstr(" -\r", mbp);
}
}
}
/*------------------------------------------------------------------------*/
/*
* Level 4 User in Tabellenform anzeigen:
*
* Call Node S Rx Tx Tr Win RxB TxB Baud ConTime
* ------------------------------------------------------------------------------
* DL9HCJ HHOST :DB0HHO IXF 0 1 0 10 4321 45621 153 01:33:12
* DG9FU KS :DB0EAM IXF 0 0 0 10 87554 12874 743 01:59:03
* / / / / / / / / / / /
* 1) 2) 3) 4) 5) 6) 7) 8) 9) 10) 11)
*
* 1) Rufzeichen des Users
* 2) Ident und Call des Knotens an dem der User eingeloggt ist
* 3) L4-Circuit-Status:
* SET = Circuit-Setup
* IXF = Info-Transfer
* DRQ = Disconnect-Request
* 4) Anzahl der empfangenen Frames in der Warteschlange fuer diesen
* Circuit
* 5) Anzahl der noch zu sendenden Frames in der Warteschlange fuer
* diesen Circuit
* 6) Anzahl Transport-Retries
* 7) Transport Fenstergroesse
* 8) Anzahl empfangender Bytes seit Bestehen des Circuits
* 9) Anzahl gesendetet Bytes seit Bestehen des Circuits
* 10) Aus 8) + 9) errechnete effektive Baudrate fuer diesen Circuit
* 11) Connectzeit
*
*/
static void l4user(MBHEAD *mbp, WORD what, const char *pstr)
{
CIRBLK *p;
WORD i;
char lsts[] = {"-SID"}; /* {"---SETIXFDRQ"}; */
char tmp1[10],
tmp3[10];
PTCENT *ptcp;
BOOLEAN first = TRUE;
/*
* Circuit-Tabelle durchgehen und fuer alle nicht disconnecteten
* Circuits Info anzeigen
*/
for (p = cirtab, i = 0; i < NUMCIR; ++p, ++i) {
if (p->state != 0) { /* nur aktive Circuits */
switch (what) {
case USE_ALL : break;
case USE_MASK : if (!c6mtch(p->upcall, pstr)) continue;
break;
case USE_CALL : if (!cmpid(p->upcall, pstr)) continue;
break;
}
ptcp = ptctab + g_uid(p, L4_USER);
mbp->l4time = mbp->mbpc;
call2str(tmp1, p->upcall);
call2str(tmp3, p->l3node);
/*find_best_qual((int)(np-netp->nodetab), &bestpp, DG);
call2str(tmp2, bestpp->l2link->call);*/
if (first) {
#ifdef SPEECH
putstr(speech_message(146), mbp);
#else
putstr("\rL4 - User:\r", mbp);
putstr("Call Node S Rx Tx Tr Win SRTT RxB TxB Baud ConTime\r", mbp);
#endif
putstr("-----------------------------------------------------------------------------\r", mbp);
first = FALSE;
}
putprintf(mbp, "%-9.9s %-9.9s %c%c%c%3u %3u %2u %2u %5u ",
tmp1, /* User-Call */
tmp3, /* Node */
((p->l4flag & L4FBUSY) ? '.':' '),
lsts[(int)p->state], /* Circuit Status */
((p->l4flag & L4FPBUSY) ? '.':' '),
p->numrx, /* Frames in RX-Queue */
p->numtx, /* Frames in TX-Queue */
p->l4try, /* Transport-Retries */
p->window, /* Transport-Window */
p->SRTT);
putptcinfo(ptcp, mbp);
putchr('\r', mbp);
}
}
}
/*----------------------------------------------------------------------*/
/* */
/*----------------------------------------------------------------------*/
void viaput(LINKTYP seite, UID uid, MBHEAD *mbp)
{
UBYTE typ = g_utyp(uid);
LNKBLK *lp;
CIRBLK *cp;
const char *p;
#ifdef USER_AUSGABE
int index;
NODE *np;
#endif /* USER_AUSGABE */
if (typ == L2_USER) {
lp = g_ulink(uid);
p = ndigipt(lp->viaidl);
if ((*p != NUL) || (!updmheard(lp->liport)))
{
#ifndef USER_AUSGABE
putstr(seite == UPLINK ? "\r Uplink" : "\r Downlink", mbp);
if (*p == NUL) /* ohne Digis */
putprintf(mbp, " %s", portpar[lp->liport].name);
else
putdil(p, mbp);
#else
if (*p != NUL) /* Ausgabe nur mit Digis */
{
putstr(seite == UPLINK ? "\r Uplink" : "\r Downlink", mbp);
putdil(p, mbp);
}
#endif /* USER_AUSGABE */
}
} else {
#ifdef USER_AUSGABE
if (typ == L4_USER)
#else
if (typ == L4_USER && seite == UPLINK) /* User ist Circuit */
#endif /* USER_AUSGABE */
{
/************************************************************************\
* *
* Die Uplinkinformation wird nur angezeigt, wenn entweder der letzte *
* Absenderknoten nicht der Uplinkknoten ist oder aber wenn beim Uplink *
* Digis verwendet wurden. Dann steht in einer eigenen Zeile: *
* ' Uplink @ uplinkknoten via digikette' *
* *
\************************************************************************/
#ifdef USER_AUSGABE
cp = g_ulink(uid);
if ( (!cmpid(cp->downca, cp->upnod))
||(*(cp->upnodv) != NUL))
{
putstr(seite == UPLINK ? "\r Uplink @ " : "\r Downlink @ ", mbp);
index = find_node_this_ssid(cp->downca);
if (index != -1)
{
np = netp->nodetab+index;
putalt(np->alias, mbp);
}
putid(cp->downca, mbp);
#else
cp = g_ulink(uid);
if ( (!cmpid(cp->upnod, cp->downca))
||(*(cp->upnodv) != NUL))
{
putstr("\r Uplink @ ", mbp);
putid(cp->upnod, mbp);
putdil(cp->upnodv, mbp);
#endif /* USER_AUSGABE */
}
}
}
}
#ifdef USER_MONITOR
void puttraceu(USRBLK *u, MBHEAD *mbp)
{
UID uid = u->uid;
putuse(UPLINK, uid, mbp);
putspa(38, mbp);
putstr("<--> (", mbp);
putid(calofs(UPLINK, uid), mbp);
putspa(53,mbp);
putstr("<> Tracen)", mbp);
putspa(65,mbp);
putstr(" PO ", mbp);
putprintf(mbp,"%d",u->monitor->Mport);
}
#endif /* USER_MONITOR */
/* Ausgeben der Patchcordliste, eventuell auch nur fuer ein Call oder eine */
/* Menge von Calls. */
static void ptcuser(MBHEAD *mbp, WORD what, const char *pstr)
{
LINKTYP updown;
PTCENT *ptcp;
UID uid;
WORD cvsflg = 0;
if (what == USE_CONV) {
cvsflg = 1;
what = USE_ALL;
}
/*
* Ausgegeben werden alle Uplinks aus der Patchcord mit ihren Downlinks
* und die CCP-User (Convers, echte User usw)
*/
if (what != USE_HOST)
putchr('\r', mbp);
for (uid = 0, ptcp = ptctab; uid < NUMPAT; ++uid, ptcp++)
{
if (ptcp->state == 0) continue;
switch (what) {
case USE_ALL : break;
case USE_MASK : if ( (!c6mtch(calofs(UPLINK, uid), pstr))
&& (!c6mtch(calofs(DOWNLINK, uid), pstr)))
continue;
break;
case USE_CALL : if ( (!cmpid(calofs(UPLINK, uid), pstr))
&& (!cmpid(calofs(DOWNLINK, uid), pstr)))
continue;
break;
case USE_HOST : if ( (g_utyp(uid) != HOST_USER)
&& (g_utyp(ptcp->p_uid) != HOST_USER))
continue;
break;
}
mbp->l4time = mbp->mbpc;
switch (ptcp->state) {
case UPLINK : /* kommt vom CCP (Convers) */
if (ptcp->ublk) { /* ist der im CCP? */
if ( (!cvsflg && ptcp->ublk->convflag == TRUE)
|| (cvsflg && !ptcp->ublk->convflag == TRUE))
continue;
if (ptcp->ublk->convers != NULLCONNECTION) {
putcvsu(ptcp->ublk, mbp); /* Convers-Verb. */
putchr('\r', mbp);
continue;
}
#ifdef USER_MONITOR
if (ptcp->ublk->status == US_TRAC)
{
puttraceu(ptcp->ublk, mbp); /* Trace-Verb. */
putchr('\r', mbp);
continue;
}
#endif /* USER_MONITOR */
}
break;
#ifndef USER_AUSGABE
case D_IPLINK :
#endif /* USER_AUSGABE */
case U_IPLINK :
updown = ptcp->state == D_IPLINK ? DOWNLINK : UPLINK;
putuse(updown, uid, mbp);
putspa(38, mbp);
#ifdef USER_AUSGABE
putstr("<--> (", mbp);
putid(calofs(UPLINK, uid), mbp);
putspa(53,mbp);
putstr("<> IP-Router)", mbp);
#else /* USER_AUSGABE */
putstr("<--> IP-Router", mbp);
#endif /* USER_AUSGABE */
viaput(updown, uid, mbp);
putchr('\r', mbp);
continue;
#ifdef L1IPCONV
case C_IPLINK :
updown = ptcp->state == D_IPLINK ? DOWNLINK : UPLINK;
if (ptcp->ublk->convers == NULL) /* Login fehlgeschlagen. */
continue; /* zum naechsten Eintrag. */
putuse(updown, uid, mbp);
putspa(38, mbp);
#ifdef USER_AUSGABE
putstr("<--> (", mbp);
putid(calofs(UPLINK, uid), mbp);
putspa(53,mbp);
putstr("<> Convers)", mbp);
putspa(65,mbp);
putstr("Ch ", mbp);
#ifndef L1IRC
if (ptcp->ublk != NULL)
putlong(ptcp->ublk->convers->channel, 0, mbp);
#else
if (ptcp->ublk != NULL)
{
if (ptcp->ublk->convers->channel == EOF)
putstr(" no Channel", mbp);
else
putlong(ptcp->ublk->convers->channel, 0, mbp);
}
#endif /* L1IRC */
#else /* USER_AUSGABE */
putstr("<--> Convers", mbp);
#endif /* USER_AUSGABE */
putchr('\r', mbp);
continue;
#endif /* L1IPCONV / L1IRC */
default:
continue;
}
if (cvsflg)
continue;
putuse(UPLINK, uid, mbp);
if (ptcp->p_uid != NO_UID) { /* gibts einen Partner-Link? */
putspa(38, mbp);
putstr(ptcp->ublk ? "<..> " : "<--> ", mbp);
if (ptcp->ublk)
if (ptcp->ublk->status == US_CQ)
{
putuse(CQ_LINK, uid, mbp);
continue;
}
putuse(DOWNLINK, ptcp->p_uid, mbp);
}
viaput(UPLINK, uid, mbp);
if (ptcp->p_uid != NO_UID)
viaput(DOWNLINK, ptcp->p_uid, mbp);
putchr('\r', mbp);
}
}
#ifdef L1TCPIP
static void TcpipUser(MBHEAD *mbp, WORD what, const char *pstr)
{
TCPIP *tpoi;
int i;
char tmp1[10];
char tmp2[10];
PTCENT *ptcp;
BOOLEAN first = TRUE;
static char *Interface[] = {"Telnet","Httpd ","IPConv"};
for (i = 0, tpoi = tcptbl; i < MAXTCPIP; ++i, ++tpoi)
{
if ( tpoi->activ == TRUE
&& tpoi->login == TRUE)
{
switch (what)
{
case USE_ALL : break;
case USE_MASK : if (!c6mtch(tpoi->Upcall, pstr)) continue;
break;
case USE_CALL : if (!cmpid(tpoi->Upcall, pstr)) continue;
break;
}
call2str(tmp1, tpoi->Upcall);
call2str(tmp2, tpoi->Downcall);
ptcp = ptctab + g_uid(tpoi, TCP_USER);
if (first)
{
putstr("\rTCPIP-User:\r"
"Interf SrcCall DstCall T3 RxB TxB Baud ConTime\r"
"-------------------------------------------------------------------\r", mbp);
first = FALSE;
}
putprintf(mbp, "%6s: %-9.9s %-9.9s %5u ",
Interface[tpoi->Interface - KISS_TCPIP]
,tmp1
,tmp2
,tpoi->noacti);
putptcinfo(ptcp, mbp);
putchr('\r', mbp);
}
}
}
#endif /* L1TCPIP */
/*
*
* Host-User in Tabellenform anzeigen:
*
* CH Call F NT RX TX ST RxB TxB Baud ConTime
* -------------------------------------------------------------------------
* 03 DB0IL-3 CD 7199 1 0 0 65 1494 120 0:02:05
* 05 DB0IL-5 C 7086 0 0 0 51 595 56 0:02:05
* 06 OZ5BBS-1 C 7068 0 0 0 7620 1598 96 0:09:37
* / / / / / / / / / / /
* 1) 2) 3) 4) 5) 6) 7) 8) 9) 10) 11)
*
* 1) Hostmode-Kanal
* 2) Rufzeichen des Users (Connect vom User) oder eigenes Call (Connect
* vom Host zum Knoten)
* 3) Hostmode-Flags
* C = Connected
* D = Disconnecten wenn Info uebertragen
* 4) Noactivity-Timer
* 5) empfangene Frames in Warteschlange
* 6) zu sendende Frames in Warteschlange
* 7) Statusmeldungen in Warteschlange
* 8) Anzahl empfangender Bytes seit Bestehen des Links
* 9) Anzahl gesendetet Bytes seit Bestehen des Links
* 10) Aus 8) + 9) + 11) errechnete effektive Baudrate fuer diesen Link
* 11) Connectzeit
*
*/
static void
hostuser(MBHEAD *mbp, WORD what, const char *pstr)
{
HOSTUS *hp;
int i;
char str[10];
PTCENT *ptcp;
BOOLEAN first = TRUE;
for (hp = hstubl + 1, i = 1; i < MAXHST; ++hp, ++i)
{
if ( (!hp->conflg)
&& (!hp->disflg)
&& (cmpid(hp->call, hostid))
)
continue;
switch (what)
{
case USE_ALL : break;
case USE_MASK : if (!c6mtch(hp->call, pstr)) continue;
break;
case USE_CALL : if (!cmpid(hp->call, pstr)) continue;
break;
}
call2str(str, hp->call);
if (first)
{
#ifdef SPEECH
putstr(speech_message(149), mbp);
#else
putstr("\rHost-User:\r"
"CH Call F NT RX TX ST RxB TxB Baud ConTime\r"
"-------------------------------------------------------------------------\r", mbp);
#endif
first = FALSE;
}
putprintf(mbp, "%02ld %-9.9s %c%c %5u %5u %5u %5u ",
hp - hstubl, str, (hp->conflg ? 'C':' '),
(hp->disflg ? 'D':' '), hp->noacti, hp->inlin,
hp->outlin, hp->outsta);
ptcp = ptctab + g_uid(hp, HOST_USER);
putptcinfo(ptcp, mbp);
putchr('\r', mbp);
}
}
/************************************************************************/
/* Time */
/*----------------------------------------------------------------------*/
void ccptim(void)
{
#ifdef MC68K
UWORD t1, t2, t3;
char t4;
struct tm *tim;
#endif
MBHEAD *mbp;
#ifdef MC68K
if (issyso()) {
t1 = nxtnum(&clicnt, &clipoi);
t4 = *clipoi++;
clicnt--;
t2 = nxtnum(&clicnt, &clipoi);
clipoi++;
clicnt--;
t3 = nxtnum(&clicnt, &clipoi);
if (t4 == '.') {
if (t1 <= 31 && t2 <= 12 && t3 <= 99) {
if (t3 < 92)
t3 += 100;
tim = localtime(&sys_time);
tim->tm_mday = t1;
tim->tm_mon = t2 - 1;
tim->tm_year = t3;
sys_time = mktime(tim);
stime(&sys_time);
}
}
if (t4 == ':') {
if (t1 <= 23 && t2 <= 59 && t3 <= 59)
{
tim = localtime(&sys_time);
tim->tm_hour = t1;
tim->tm_min = t2;
tim->tm_sec = t3;
sys_time = mktime(tim);
stime(&sys_time);
}
}
}
#endif
mbp = putals("Time: ");
puttim(&sys_time, mbp);
putstr(" (", mbp);
putlong(tic10, FALSE, mbp);
putstr(")\r", mbp);
prompt(mbp);
seteom(mbp);
}
/************************************************************************/
/* CLEAR : Loeschen der Statistiken */
/*----------------------------------------------------------------------*/
void
ccpclr(void)
{
register int i;
STAT *statp;
char call[L2IDLEN];
char viacall[L2IDLEN];
if (issyso())
{
memset(portstat, 0, sizeof(portstat));
for (i = 0, statp = mh; i < MAXSTAT; ++i, statp++)
{
/* Rufzeichen und via-Rufzeichen beibehalten, Start-Zeit setzen */
cpyid(call, statp->call);
cpyid(viacall, statp->viacall);
memset(statp, 0, sizeof(STAT));
cpyid(statp->call, call);
cpyid(statp->viacall, viacall);
statp->hfirst = sys_time;
}
for (i = 3; i <= 19; ++i)
if (i != 13) /* Timeout nicht ruecksetzen */
Ip_mib[i].value.integer = 0;
l1sclr("*");
time(&clear_time);
#ifdef SPEECH
putmsg(speech_message(192));
#else
putmsg("Statistic-table cleared!\r");
#endif
userpo->sysflg = 2;
}
else
invmsg();
}
/************************************************************************/
/* percent */
/* int comma: gibt an wieviele Nachkommastellen berechnet werden sollen */
/*----------------------------------------------------------------------*/
static void
percent (ULONG zaehler, ULONG nenner, int comma, int space, MBHEAD *mbp)
{
int i, zaehlernull;
char resultstr[32];
resultstr[0] = NUL;
zaehlernull = 0;
if (nenner == 0)
{
zaehler = 0L;
nenner = 1L;
}
if (zaehler / nenner != 0)
sprintf(resultstr, "%s%lu", resultstr, zaehler / nenner);
else
zaehlernull = 1;
zaehler = (zaehler % nenner) * 10;
if (zaehlernull != 1 || zaehler / nenner != 0)
sprintf(resultstr, "%s%lu", resultstr, zaehler / nenner);
zaehler = (zaehler % nenner) * 10;
sprintf(resultstr, "%s%lu", resultstr, zaehler / nenner);
zaehler = (zaehler % nenner) * 10;
if (comma > 0)
strcat(resultstr, ".");
for (i = 0 ; i < comma; i++)
{
sprintf(resultstr, "%s%lu", resultstr, zaehler / nenner);
zaehler = (zaehler % nenner) * 10;
}
/* String mit space Angabe formatieren */
putprintf(mbp, "%*s%%", space, resultstr);
return;
}
/************************************************************************/
/* Statistik-Befehl */
/* Syntax: S + <call> <viacall> nimmt ein neues Call in die Statistik */
/* auf */
/* S - <call> <viacall> loescht ein Call aus der Statistik */
/* S p zeigt nur die Port-Statistik */
/* S e zeigt nur die Fehler-Statistik */
/* S l zeigt nur die Link-Statistik */
/* S h zeigt nur die Hardware-Statistik */
/* S i zeigt nur die IP-statistik */
/* S zeigt nur die System-Statistik */
/* S * zeigt alles */
/*----------------------------------------------------------------------*/
void
ccpsta(void)
{
MBHEAD *mbp;
STAT *statp;
WORD i, j;
char call[L2IDLEN], viacall[L2IDLEN];
ULONG summe, /* Gesamter Datendurchsatz in KBytes */
offset;
#ifndef CONNECTTIME
LONG upt, upd, uph;
#endif /* CONNECTTIME */
PORTSTAT *pstatp;
PORTINFO *portp;
ULONG rxoverhead = 0L, txoverhead = 0L;
ULONG trxframes[2];
int ch;
#define PORTSTATFLAG 1 /* Die Reihenfolge muss mit chars */
#define ERRORSTATFLAG 2 /* uebereinstimmen */
#define LINKSTATFLAG 4
#define HARDWAREFLAG 8
#define IPSTATFLAG 16
#define KERNELFLAG 32
#define STATFLAG 64 /* kein oder falscher parameter */
int flag = 0;
#ifndef KERNELIF
const char *chars = "PELHI", *cp;
#else
const char *chars = "PELHIK", *cp;
#endif
mbp = getmbp();
skipsp(&clicnt, &clipoi);
ch = toupper(*clipoi);
for (cp = chars, i = 1; *cp; cp++, i <<= 1)
if (ch == *cp) flag |= i;
if (ch == '*')
flag = (~0); /* Monats-Statistik (alles) */
if (flag == 0)
flag |= STATFLAG;
if (issyso())
{
/******* Delete Call from Statistics ************************************/
if (ch == '-')
{
clipoi++;
clicnt--;
if (getcal(&clicnt, &clipoi, FALSE, call) == YES)
{
if (getcal(&clicnt, &clipoi, TRUE, viacall) == YES)
{
for (statp = mh, j = 0; j < MAXSTAT; statp++, j++)
if ( cmpid(statp->call, call)
&& cmpid(statp->viacall, viacall))
{
statp->call[0] = NUL;
statp->viacall[0] = NUL;
}
}
else /* Kein oder falsches via Rufzeichen */
{
for (statp = mh, j = 0; j < MAXSTAT; statp++, j++)
if ( cmpid(statp->call, call)
&& !*statp->viacall)
{
statp->call[0] = NUL;
statp->viacall[0] = NUL;
}
}
}
flag |= LINKSTATFLAG;
}
/******** Add Call to Statistics ****************************************/
if (*clipoi == '+')
{
clipoi++;
clicnt--;
/************************************************************************/
/* Wenn das Call schon in der Statistik steht, dann tragen wir es nicht */
/* nochmal ein. Rufzeichen und Via Rufzeichen duerfen nicht gleich */
/* sein. Das Zeichen "*" ist nur erlaubt, wenn ein korrektes Via- */
/* Rufzeichen mitangegeben wird. */
/************************************************************************/
if (getcal(&clicnt, &clipoi, FALSE, call) == YES)
/* Es ist ein "*" oder ein gueltiges Rufzeichen */
if (cmpid(call, anycall) || fvalca(call) == YES)
{
if ( getcal(&clicnt, &clipoi, TRUE, viacall) == YES
&& !cmpid(call, viacall))
{
for (statp = mh, j = 0; j < MAXSTAT; statp++, j++)
if ( cmpid(statp->call, call)
&& cmpid(statp->viacall, viacall))
break;
}
else /* Kein oder falsches Via-Rufzeichen */
{
viacall[0] = NUL;
for (statp = mh, j = 0; j < MAXSTAT; statp++, j++)
{
/* "*" ohne Via-Rufzeichen nicht zulassen */
if (cmpid(call, anycall))
break;
/* Rufzeichen (ohne via) schon gefunden, kein Eintrag noetig */
if (cmpid(statp->call, call) && !*statp->viacall)
break;
}
}
if (j >= MAXSTAT)
{
for (statp = mh, j = 0; j < MAXSTAT; statp++, j++)
if (!*statp->call)
{
memset(statp, 0, sizeof(STAT));
cpyid(statp->call, call);
cpyid(statp->viacall, viacall);
statp->hfirst = sys_time;
statp->hlast = sys_time;
userpo->sysflg = 2;
break;
}
}
}
flag |= LINKSTATFLAG;
}
}
summe = 0L;
/********** Show System Statistics **************************************/
#ifdef SPEECH
putstr(speech_message(151), mbp); /* aktuelle Uhrzeit */
#else
putstr("\r System Statistics: ", mbp); /* aktuelle Uhrzeit */
#endif
puttim(&clear_time, mbp);
putstr(" - ", mbp);
puttim(&sys_time, mbp);
#ifdef SPEECH
putstr(speech_message(152), mbp); /* Startzeit */
#else
putstr("\r Startup: ", mbp); /* Startzeit */
#endif
puttim(&start_time, mbp);
#ifndef CONNECTTIME
upt = sys_time - start_time; /* Uptime in seconds */
upd = upt / SECONDS_PER_DAY; /* Uptime days */
upt %= SECONDS_PER_DAY;
uph = upt / SECONDS_PER_HOUR; /* Uptime hours */
upt %= SECONDS_PER_HOUR;
putprintf(mbp, "\r Uptime:%9ld/%02ld:%02ld\r",
upd, uph, upt / SECONDS_PER_MIN);
#else /* CONNECTTIME */
putprintf(mbp, "\r Runtime: %s", ConnectTime(tic10 / 100));
#endif /* CONNECTTIME */
if (flag & STATFLAG)
{
#ifdef SPEECH
putprintf(mbp, speech_message(177),
rounds_min_sec, rounds_pro_sec, rounds_max_sec);
#else
putprintf(mbp, "\r (min) (now) (max)\r"
" Rounds/sec: %8lu %8lu %8lu\r",
rounds_min_sec, rounds_pro_sec, rounds_max_sec);
#endif
#ifdef SPEECH
putprintf(mbp, speech_message(178),
nmbfre_min, nmbfre, nmbfre_max,
thbps * 8L, thbps_max * 8L,
nmblks, nmblks_max,
nmbcir, nmbcir_max,
netp->num_nodes,
num_nodes_max);
#else
putprintf(mbp, " Free Buffers: %8u %8u %8u\r"
"Overall Throughput:%18lu %8lu Baud\r"
" Active L2-Links:%18u %8u\r"
" Active Circuits:%18u %8u\r"
" Active Nodes:%18u %8u\r",
nmbfre_min, nmbfre, nmbfre_max,
thbps * 8L, thbps_max * 8L,
nmblks, nmblks_max,
nmbcir, nmbcir_max,
netp->num_nodes,
num_nodes_max);
#endif
#ifdef L1TCPIP
putprintf(mbp, "\r Active Socket:%18u %8u\r"
,nmbtcp, nmbtcp_max);
#endif /* L1TCPIP */
#ifdef __LINUX__
print_load (mbp);
if (nmbfre_max)
#ifdef SPEECH
putprintf(mbp, speech_message(180),
100 - (((ULONG)nmbfre) * 100L) / ((ULONG)nmbfre_max));
#else
putprintf(mbp, "\r Buffer usage: %lu%%",
100 - (((ULONG)nmbfre) * 100L) / ((ULONG)nmbfre_max));
#endif
#ifdef SPEECH
putprintf(mbp, speech_message(181),
sizeof(NETWORK) + (ULONG)netp->num_peers * (sizeof(PEER) +
(ULONG)netp->max_nodes * sizeof(ROUTE)));
#else
putprintf(mbp, "\r Network Heap: %lu Bytes",
sizeof(NETWORK) + (ULONG)netp->num_peers * (sizeof(PEER) +
(ULONG)netp->max_nodes * sizeof(ROUTE)));
#endif
putprintf(mbp, "\r Console: ");
switch (console_type)
{
case CONS_NO_CONSOLE: putprintf(mbp, "no console\r"); break;
case CONS_TERM_DO_SETUP:
case CONS_TERM_RUNNING: putprintf(mbp, "terminal\r"); break;
case CONS_SOCKET_DO_SETUP: putprintf(mbp, "unix socket (setting up)\r"); break;
case CONS_SOCKET_WAITING: putprintf(mbp, "unix socket (waiting)\r"); break;
case CONS_SOCKET_CONNECTED: putprintf(mbp, "unix socket (connected)\r"); break;
default: putprintf(mbp, "unknown\r"); break;
}
#else
if (rounds_max_sec)
#ifdef SPEECH
putprintf(mbp, speech_message(182),
100 - (((ULONG)rounds_pro_sec) * 100L) / ((ULONG)rounds_max_sec));
#else
putprintf(mbp, "\r CPU load: %lu%%",
100 - (((ULONG)rounds_pro_sec) * 100L) / ((ULONG)rounds_max_sec));
#endif
if (nmbfre_max)
#ifdef SPEECH
putprintf(mbp, speech_message(180),
100 - (((ULONG)nmbfre) * 100L) / ((ULONG)nmbfre_max));
#else
putprintf(mbp, "\r Buffer usage: %lu%%",
100 - (((ULONG)nmbfre) * 100L) / ((ULONG)nmbfre_max));
#endif
#ifdef SPEECH
putprintf(mbp, speech_message(181),
sizeof(NETWORK) + (ULONG)netp->num_peers * (sizeof(PEER) +
(ULONG)netp->max_nodes * sizeof(ROUTE)));
#else
putprintf(mbp, "\r Network Heap: %lu Bytes\r",
sizeof(NETWORK) + (ULONG)netp->num_peers * (sizeof(PEER) +
(ULONG)netp->max_nodes * sizeof(ROUTE)));
#endif
#endif
}
/********** Show Port Statistics ****************************************/
if (flag & PORTSTATFLAG)
{
/******************** number of byte rx/tx per port *********************/
summe =
offset = 0L;
#ifdef SPEECH
putstr(speech_message(153), mbp);
#else
putstr("\r\r Port-Statistics:\r\r"
" Links RxB TxB RxBaud"
" TxBaud RxOver TxOver\r", mbp);
#endif
for (i = 0, pstatp = portstat, portp = portpar;
i < L2PNUM;
i++, pstatp++, portp++)
{
if (portenabled(i))
{
putprintf(mbp, "%2u:%-10s%3u/%-3u ", i, portp->name,
portp->nmblks,
portp->nmbstn);
put_kMG(mbp, pstatp->rx_bytes);
putchr(' ', mbp);
put_kMG(mbp, pstatp->tx_bytes);
putchr(' ', mbp);
put_kMG(mbp, pstatp->rx_baud*8L);
putchr(' ', mbp);
put_kMG(mbp, pstatp->tx_baud*8L);
if (pstatp->rx_bytes / 100L)
{
rxoverhead = pstatp->rx_overhead / (pstatp->rx_bytes / 100L);
if (rxoverhead > 99)
rxoverhead = 100;
putprintf(mbp, " %3lu%%", rxoverhead);
}
else
if (pstatp->tx_bytes / 100L)
putstr(" ", mbp);
if (pstatp->tx_bytes / 100L)
{
txoverhead = pstatp->tx_overhead / (pstatp->tx_bytes / 100L);
if (txoverhead > 99)
txoverhead = 100;
putprintf(mbp, " %3lu%%", txoverhead);
}
putchr(CR, mbp);
summe += (pstatp->rx_bytes + pstatp->tx_bytes);
while (summe > 999999L)
{
offset++;
summe -= 1000000L;
}
}
}
#ifdef SPEECH
putstr(speech_message(154), mbp);
#else
putstr("\rTotal = ", mbp);
#endif
/* wird noch erweitert, gilt noch nicht fuer die einzelnen Ports, die */
/* koennen weiterhin nur bis 4.2GB zaehlen */
put_pktnum(mbp, offset, summe);
#ifdef SPEECH
putstr(speech_message(155), mbp);
#else
putstr(" Bytes\r", mbp);
#endif
}
/************* Fehler-Statistik *****************************************/
if (flag & ERRORSTATFLAG)
{
#ifdef SPEECH
putstr(speech_message(156), mbp);
#else
putstr("\r Error-Statistics:\r\r"
" RxID RxLen RxCtl Resets\r", mbp);
#endif
for (i = 0, pstatp = portstat, portp = portpar;
i < L2PNUM;
i++, pstatp++, portp++)
{
if (portenabled(i))
{
putprintf(mbp, "%2u:%-10s ", i, portp->name);
for (j = 0; j < 3; j++)
putprintf(mbp, "%6u ", pstatp->invalid[j]);
putprintf(mbp, "%6u\r", pstatp->reset_count);
}
}
}
if (flag & HARDWAREFLAG)
l1stat("*", mbp);
#ifdef KERNELIF
/************* Show Kernel Link Statistics ********************************/
if (flag & KERNELFLAG)
ifip_dispstat(mbp);
#endif
/************* Show Link Statistics *************************************/
if (flag & LINKSTATFLAG)
{
#ifdef SPEECH
putstr(speech_message(157), mbp);
#else
putstr("\rLink-Statistics:\r", mbp);
#endif
for (i = MAXSTAT, statp = mh; i--; statp++)
{
if (*statp->call)
{
mbp->l4time = mbp->mbpc;
#ifdef SPEECH
putstr(speech_message(158), mbp);
#else
putstr("\rLink to ", mbp);
#endif
putid(statp->call, mbp);
if (*statp->viacall)
{
#ifdef SPEECH
putstr(speech_message(159), mbp);
#else
putstr(" via ", mbp);
#endif
putid(statp->viacall, mbp);
}
putspa(35, mbp);
puttim(&statp->hfirst, mbp);
if (statp->hlast > 0)
{
putstr(" - ", mbp);
puttim(&statp->hlast, mbp);
}
#ifdef SPEECH
putstr(speech_message(160), mbp);
#else
putstr("\rFrames: I UI RR REJ "
"RNR SABM/UA DISC/DM FRMR\r", mbp);
#endif
for (j = 0; j < 2; j++)
putprintf(mbp, "%s:%11lu%11lu%11lu%10lu%9lu%9lu%9lu%5lu\r",
(j == 0) ? "RX" : "TX",
statp->Ino[j],
statp->UIno[j],
statp->RRno[j],
statp->REJno[j],
statp->RNRno[j],
statp->SABMno[j] + statp->UAno[j],
statp->DISCno[j] + statp->DMno[j],
statp->FRMRno[j]);
#ifdef SPEECH
putstr(speech_message(161), mbp);
#else
putstr("Bytes: Total Info Header Overhead %I "
"%RR %REJ %RNR\r", mbp);
#endif
for (j = 0; j < 2; j++)
{
trxframes[j] = statp->Ino[j] + statp->UIno[j] + statp->RRno[j]
+ statp->REJno[j] + statp->RNRno[j] + statp->SABMno[j]
+ statp->UAno[j] + statp->DISCno[j] + statp->DMno[j]
+ statp->FRMRno[j];
putprintf(mbp, "%s:%11lu%11lu%11lu",
(j == 0) ? "RX" : "TX",
statp->Bytetotal[j],
statp->Bytetotal[j] - statp->Byteheader[j],
statp->Byteheader[j]);
percent(statp->Byteheader[j], statp->Bytetotal[j], 1, 9, mbp);
percent(statp->Ino[j], trxframes[j], 1, 7, mbp);
percent(statp->RRno[j], trxframes[j], 1, 7, mbp);
percent(statp->REJno[j], trxframes[j], 1, 7, mbp);
percent(statp->RNRno[j], trxframes[j], 1, 7, mbp);
putchr(CR, mbp);
}
txoverhead = (statp->Bytetotal[1] - statp->Byteheader[1])
- statp->txByterepeated;
#ifdef SPEECH
putprintf(mbp, speech_message(183),
txoverhead,
statp->txByterepeated);
#else
putprintf(mbp, "TX: Once:%11lu Repeated:%10lu IQual:",
txoverhead,
statp->txByterepeated);
#endif
percent(txoverhead, statp->Bytetotal[1] - statp->Byteheader[1],
1, 7, mbp);
#ifdef SPEECH
putstr(speech_message(162),mbp);
#else
putstr(" TQual:",mbp);
#endif
percent(txoverhead,statp->Bytetotal[1], 1, 7, mbp);
putchr(CR, mbp);
}
}
}
#ifdef IPROUTE
/************* Show IP-Gateway Statistics *******************************/
if (flag & IPSTATFLAG)
{
#ifdef SPEECH
putstr(speech_message(163), mbp);
#else
putstr("\rIP-Gateway-Statistics:\r\r", mbp);
#endif
for (i = 1; i <= NUMIPMIB; )
{
mbp->l4time = mbp->mbpc;
for (j = 0; j < 3 && i <= NUMIPMIB; j++, i++)
{
#ifdef __WIN32__
putspa((char)(26 * j), mbp);
#else
putspa(26 * j, mbp);
#endif /* WIN32 */
putstr(Ip_mib[i].name, mbp);
putchr(':', mbp);
#ifdef __WIN32__
putspa((char)(26 * j + 19), mbp);
#else
putspa(26 * j + 19, mbp);
#endif /* WIN32 */
putnum(Ip_mib[i].value.integer, mbp);
}
putchr(CR, mbp);
}
putchr(CR, mbp);
}
#endif
putchr(CR, mbp);
prompt(mbp);
seteom(mbp);
}
/************************************************************************/
/* Test-Command */
/*----------------------------------------------------------------------*/
void ccptst(void)
{
MBHEAD *mbp;
WORD port;
if (issyso()) /* Bin ich Sysop? */
{
if ((port = (char) nxtnum(&clicnt, &clipoi)) >= L2PNUM)
{
#ifdef SPEECH
putmsg(speech_message(193));
#else
putmsg("\rInvalid Port\r");
#endif
return;
}
if (!portenabled(port)) /* Port nicht eingeschaltet */
{
#ifdef SPEECH
putmsg(speech_message(345));
#else
putmsg("\rCan't send, Port is disabled\r");
#endif
return;
}
l1ctl(L1CTST, port);
mbp = putals("Sending test on Port ");
putnum(port, mbp);
putchr('\r', mbp);
prompt(mbp);
seteom(mbp);
}
else
invmsg();
}
/************************************************************************/
/* Version-Command */
/*----------------------------------------------------------------------*/
void ccpver(void)
{
MBHEAD *mbp; /* message-buffer-pointer */
mbp = putals(version); /* Versionskennung zeigen */
#ifdef SPEECH
putprintf(mbp,speech_message(184), L2PNUM, LINKNMBR, NUMCIR,author);
#else
putprintf(mbp," Copyright by NORD><LINK, free for non-commercial"
" usage.\r See www.nordlink.org for further"
" information.\r This version compiled for %d Ports, %d"
" L2-Links and %d Circuits.\r"
" %s\r", L2PNUM, LINKNMBR, NUMCIR,author);
#endif
if (clicnt != 0 && (*clipoi == '*' || *clipoi == '+')) {
putstr("\rCompiled options:\r"
#ifdef IPROUTE
" * IP-Router\r"
#endif
#ifdef PACSAT
" * PACSAT Server\r"
#endif
#ifdef PADDLE
" * Paddle\r"
#endif
#ifdef FLEXHOST
" * Local-Hosting\r"
#endif
#ifdef L2PROFILER
" * L2-Profiling\r"
#endif
#ifdef PROFILING
" * Profiling\r"
#endif
#ifdef GRAPH
" * Graph\r"
#endif
#ifdef USER_PASSWORD
" * User-Password\r"
#endif
#ifdef USERMAXCON
" * User-MaxConnection\r"
#endif
#ifdef DAMASLAVE
" * DAMA-Slave\r"
#endif
#ifdef KERNELIF
" * Kernel-Interface\r"
#endif
#ifdef ALIASCMD
" * Command-Aliasing\r"
#endif
#ifdef EAX25
" * Extended-AX.25\r"
#endif
#ifdef SPEECH
" * Speech Support\r"
#endif
#ifdef USERPROFIL
" * User-Profil\r"
#endif /* USERPROFIL */
"\r", mbp);
putstr("Hardware:\r", mbp);
l1enum(mbp);
putchr('\r', mbp);
}
prompt(mbp);
seteom(mbp);
}
/************************************************************************/
/* Links-Command */
/*----------------------------------------------------------------------*/
void ccplnk(void)
{
MBHEAD *mbp;
char call[L2IDLEN];
char ident[L2CALEN];
char digil[L2VLEN+1];
UWORD port;
char mode;
char typ[] = {" "};
#ifdef PROXYFUNC
BOOLEAN typproxy = FALSE;
#endif
char typs = 0;
char *via;
PEER *pp;
int i;
int max_peers = netp->max_peers;
const char *cp;
#ifdef LINKSMODINFO
char info[INFOSIZE + 1];
#endif /* LINKSMODINFO */
mbp = getmbp();
/* nur Neueintraege als Sysop und wenn noch was in der Kommandozeile da ist */
if (issyso() && clicnt > 0)
{
mode = *clipoi; /* Modus bestimmen (+ oder -) */
clipoi++;
clicnt--;
skipsp(&clicnt, &clipoi);
typ[0] = toupper(*clipoi); /* Linktyp holen (N I F usw.) */
clipoi++;
clicnt--;
if (*clipoi != ' ') /* Linkzusatz holen (+ oder -) wenn vorhanden */
{
typ[1] = *clipoi++;
clicnt--;
}
#ifdef PROXYFUNC
skipsp(&clicnt, &clipoi);
if ( (typproxy = ((*clipoi == 'P' || *clipoi == 'p') && *(clipoi+1) == ' ' ) ? TRUE : FALSE) == TRUE) {
clipoi++;
clicnt--;
}
#endif
if ((port = (UWORD) nxtnum(&clicnt, &clipoi)) < L2PNUM)
{
skipsp(&clicnt, &clipoi);
if (strchr((char *)clipoi, ':'))
*strchr((char *)clipoi, ':') = ' ';
if (getide(&clicnt, &clipoi, ident) == YES)
{
skipsp(&clicnt, &clipoi);
if ((getcal(&clicnt, &clipoi, TRUE, call)) == YES)
{
getdig(&clicnt, &clipoi, TRUE, digil);
digil[2*L2IDLEN] = NUL;
#ifdef LINKSMODINFO
/* Frischer Buffer. */
memset(info, 0, sizeof(info));
/* Pruefe, ob es weiter Zeichen gibt. */
if (skipsp(&clicnt, &clipoi))
{
char *infotext;
if ((infotext = strchr(clipoi, '=')) != NULL)
{
/* Zeichen "=" loeschen. */
infotext++;
/* Stations-Beschreibung speichern. */
strncpy(info, infotext, INFOSIZE);
} /* kein "=" enthalen. */
} /* keine weiteren Zeichen im Buffer. */
#endif /* LINKSMODINFO */
for (cp = typtbl; *cp; cp += 2)
if ((cp[0] == typ[0]) && (cp[1] == typ[1])) /* Typ stimmt */
typs = ((int)(cp-typtbl))/2;
#ifdef LINKSMODROUTINGTYP
if ( (typs == NETROM) /* NETROM-TYP */
&&(typs == (mode == '+'))) /* und soll eingetragen werden, */
{ /* nicht zulassen!!! */
putstr("None Routing-Typ indicated.\r", mbp);
prompt(mbp); /* Zum Prompt zurueck. */
seteom(mbp);
return;
}
#endif /* LINKSMODROUTINGTYP */
if (mode == '+')
{
#ifdef PROXYFUNC
typs = typproxy ? typs+PROXYMASK : typs;
#endif
pp = register_neigb(call, digil, ident, port, typs
#ifdef LINKSMODINFO
,info
#endif /* LINKSMODINFO */
#ifdef AUTOROUTING
,FIXED_ROUTE /* Link ist immer Fest. */
#endif /* AUTOROUTING */
);
if (!portenabled(port))
#ifdef SPEECH
putstr(speech_message(166), mbp);
#else
putstr("Warning - Port not active.\r", mbp);
#endif
#ifdef LINKSMOD_MSG
if (pp != NULL) /* Linkpartner erfolgreich eingetragen. */
{
putstr("Link is registered.\r", mbp);
prompt(mbp); /* Zum Prompt zurueck. */
seteom(mbp);
return;
}
#endif /* LINKSMOD_MSG. */
}
if (mode == '-')
#ifdef LINKSMOD_MSG
{
if (unregister_neigb(call, digil, port)) /* Link austragen. */
{
#ifdef AXIPR_HTML
/* Protokoll fuer HTML-Ausgabe setzen. */
SetHTML(port, call, NULL, FALSE);
#endif /* AXIPR_HTML */
putstr("Link is deleted.\r", mbp);
prompt(mbp); /* Und zum Prompt zurueck. */
seteom(mbp);
return;
}
}
#else
unregister_neigb(call, digil, port);
#endif /* LINKSMOD_MSG. */
} /* if (getcal(&clicnt ... */
else /* Call war nicht ok */
{
#ifdef SPEECH
putstr(speech_message(167), mbp);
#else
putstr("Invalid callsign.\r", mbp);
#endif
prompt(mbp);
seteom(mbp);
return;
}
} /* if (ident_ok... */
else /* Ident ist nicht ok (enthaelt ungueltige Zeichen etc.) */
{
#ifdef SPEECH
putstr(speech_message(168), mbp);
#else
putstr("Invalid ident.\r", mbp);
#endif
prompt(mbp);
seteom(mbp);
return;
}
} /* if (port = nxtnum(&clicnt, &clipoi) < L2PNUM) */
/* putstr("Syntax: L +/- TYP PORT ALIAS:CALL[-*] [Digi1 [Digi2]]\r", mbp);*/
} /* if (sysop... */
#ifdef LINKSMODSYNTAXFIX
/* Nur Sysop's duerfen die Syntax sehen. */
if (issyso())
putstr("Syntax: L +/- TYP PORT ALIAS:CALL[-*] [Digi1 [Digi2]] [INFO=<text>]\r", mbp);
#endif /* LINKSMODSYNTAXFIX */
putstr("Links of ", mbp); /* Konfiguration zeigen */
putalt(alias, mbp);
putid(myid, mbp);
putprintf(mbp, " (%d/%d)\r", netp->num_peers, netp->max_peers);
#ifndef LINKSMODINFO
putstr("Type-Port--Alias:Call------Route--------------\r", mbp);
#else
putstr("Type-Port--Alias:Call------Route--------------Info------------------------\r", mbp);
#endif /* LINKSMODINFO */
for (i = 0, pp = netp->peertab; i < max_peers; i++, pp++)
if (pp->used) {
mbp->l4time = mbp->mbpc; /* Zaehler merken fuer putspa() */
#ifdef LINKSMOD_LOCALMOD
if ( (pp->typ == LOCAL_V) /* Local-Link versteckt. */
&&(!issyso())) /* und kein Sysop. */
continue; /* Zum naechsten Eintrag. */
#endif /* LINKSMOD_LOCALMOD */
#ifdef PROXYFUNC
putprintf (mbp, "%2.2s %c", typtbl + pp->typ*2 , pp->proxy ? 'P' : ' ');
#else
putspa(2, mbp);
putprintf (mbp, "%2.2s", typtbl + pp->typ*2);
#endif
putspa(6, mbp);
if (pp->l2link->port < 10) putchr(' ', mbp);
putnum(pp->l2link->port, mbp);
putstr(" ", mbp);
putide(pp->l2link->alias, mbp);
putchr(':', mbp);
putid(pp->l2link->call, mbp);
via = pp->l2link->digil; /* nicht putdil() wegen "via" */
if (via[0])
{
putspa(27, mbp);
putid(via, mbp);
if (via[L2IDLEN])
{
putchr(' ', mbp);
putid(via+L2IDLEN, mbp);
}
}
#ifdef LINKSMODINFO
/* Ab spalte 46. */
putspa(46, mbp);
/* Stations-Beschreibung ausgeben. */
putprintf(mbp, "%s",pp->l2link->info, mbp);
#endif /* LINKSMODINFO */
putchr('\r', mbp);
}
prompt(mbp);
seteom(mbp);
}
/************************************************************************/
/* Quit-Command */
/*----------------------------------------------------------------------*/
void ccpquit(void)
{
MBHEAD *mbp;
char name[MAXPATH];
mbp = getmbp();
/* Gibt es eine QUIT.TXT ? */
if (xaccess("QUIT.TXT", 0) == 0)
{
/* Markiere Path/Datei. */
sprintf(name, "%sQUIT.TXT", textpath);
/* Gibt es Makros, diese ausfuehren. */
out_ctext(name, mbp);
}
else
{
putstr("\r73 de ", mbp);
putid(myid, mbp);
}
putchr('\r', mbp);
seteom(mbp);
disusr(userpo->uid);
}
/************************************************************************/
/* */
/* ECHO Befehl */
/* */
/* Funktion : Rest der Eingabezeile des Users zurueck schicken. */
/* Anwendung z.B. fuer RTT Messung. */
/* */
/* Syntax : //E <text> */
/* */
/*----------------------------------------------------------------------*/
void ccpecho(void) {
MBHEAD *mbp;
mbp = getmbp();
if (clicnt > 0 && !strnicmp(clilin, "//E", 3)) {
putchr('\r', mbp);
while (clicnt > 0) {
putchr(*clipoi++, mbp);
clicnt--;
}
putchr('\r', mbp);
}
prompt(mbp);
seteom(mbp);
}
/************************************************************************/
/* */
/* TALK Befehl */
/* */
/* Funktion : Nachricht an einen anderen User schicken, der im CCP und */
/* nicht anderweitig connected ist! */
/* Syntax : TALK <user> <text> */
/* Ausgabe : Msg from <call>: <text> */
/*----------------------------------------------------------------------*/
void ccptalk(void)
{
char tmp[8];
WORD suc;
MBHEAD *mbp;
char call[L2IDLEN];
if (skipsp(&clicnt, &clipoi)) { /* steht da was? */
if (!strnicmp((char *)clipoi, "ALL", 3)) { /* an alle? */
nextspace(&clicnt, &clipoi);
if (skipsp(&clicnt, &clipoi) == FALSE) { /* kein Text? */
#ifdef SPEECH
putmsg(speech_message(195));
#else
putmsg("No Text\r");
#endif
return;
}
call[0] = '*';
suc = talk_to(call, 0); /* weiterpetzen */
} else
if (getcal(&clicnt, &clipoi, TRUE, call) == YES) { /* ein call ? */
if (skipsp(&clicnt, &clipoi)) { /* kommtn Text? */
suc = talk_to(call, 0); /* weiterpetzen */
} else {
suc = talk_to(call, 1); /* gibs den? */
mbp = getmbp();
if (suc) {
cpyid(userpo->talkcall, call); /* call merken */
userpo->status = US_TALK;
callss2str(tmp, call);
#ifdef SPEECH
putprintf(mbp, speech_message(185), tmp);
#else
putprintf(mbp, "You are now talking with %s. Leave this mode with /q\r", tmp);
#endif
} else {
#ifdef SPEECH
putstr(speech_message(172), mbp);
#else
putstr("No such User!\r", mbp);
#endif
prompt(mbp); /* Prompt dran */
}
seteom(mbp); /* fertig */
return;
}
} else {
#ifdef SPEECH
putmsg(speech_message(196));
#else
putmsg("Invalid Call\r");
#endif
return;
}
#ifdef SPEECH
putmsg(suc ? speech_message(197) : speech_message(198));
#else
putmsg(suc ? "Msg sent\r" : "No User\r");
#endif
} else
#ifdef SPEECH
putmsg(speech_message(199));
#else
putmsg("No Arguments\r");
#endif
}
static BOOLEAN talk_to(char *call, WORD test)
{
char tmp[8];
WORD cnt = 0;
USRBLK *save_userpo = userpo;
MBHEAD *mbp;
callss2str(tmp, calofs(UPLINK, userpo->uid));
strlwr(tmp);
for (userpo = (USRBLK *) usccpl.head;
userpo != (USRBLK *) &usccpl;
userpo = (USRBLK *) userpo->unext)
{
if ( userpo->convers == NULLCONNECTION
&& ( userpo->status == US_CCP
|| userpo->status == US_TALK)
&& userpo != save_userpo
&& ( cmpcal(calofs(UPLINK, userpo->uid), call)
|| call[0] == '*')) {
if (test) {
userpo = save_userpo;
return(TRUE);
}
mbp = getmbp();
/* String zu lang? */
if (clicnt > 214)
{
/* Aktuellen user setzen. */
userpo = save_userpo;
/* Der String ist zu lang, abbruch. */
return(TRUE);
}
#ifdef SPEECH
putprintf(mbp, speech_message(186), tmp, clipoi);
#else
putprintf(mbp, "Msg from %s (use TALK to reply): %s\r", tmp, clipoi);
#endif
seteom(mbp);
if (call[0] != '*') {
userpo = save_userpo;
return(TRUE);
}
cnt++;
}
}
userpo = save_userpo;
return(cnt ? TRUE : FALSE);
}
/************************************************************************/
/* Mailbox-Befehl */
/************************************************************************/
void ccpmail(void)
{
if (issyso() && skipsp(&clicnt, &clipoi)) {
ccp_call(boxid); /* Rufzeichen setzen */
} else { /* Connect zur Mailbox */
if (boxid[0]) {
call2str((char *)(clipoi = clilin), boxid);
clicnt = strlen((char *)clipoi);
ccpcon(NULL);
} else
#ifdef SPEECH
putmsg(speech_message(200));
#else
putmsg("No mailbox!\r");
#endif
}
}
/************************************************************************/
/* DXCluster-Command */
/*----------------------------------------------------------------------*/
void ccpdxc(void)
{
if (issyso() && skipsp(&clicnt, &clipoi)) {
ccp_call(dxcid); /* Rufzeichen setzen */
} else { /* Connect zur Mailbox */
if (dxcid[0]) {
call2str((char *)(clipoi = clilin), dxcid);
clicnt = strlen((char *)clipoi);
ccpcon(NULL);
} else
#ifdef SPEECH
putmsg(speech_message(201));
#else
putmsg("No DX-Cluster!\r");
#endif
}
}
#ifdef HOSTMYCALL
/************************************************************************/
/* */
/* Consolen-Mycall setzen. */
/* */
/************************************************************************/
void ccpmyhost(void)
{
MBHEAD *mbp;
if (issyso()) /* Nur Sysop darf aendern. */
{
if (skipsp(&clicnt, &clipoi))
{
ccp_call(hostuserid); /* Neues rufzeichen setzen */
return;
}
mbp = putals("HostMyCall:\r\r");
putstr("Consolen MyCall:", mbp);
putid(hostuserid, mbp);
putstr("\r", mbp);
prompt(mbp);
seteom(mbp);
}
else
invmsg();
}
#endif /* HOSTMYCALL */
#ifdef SYSOPPASSWD
/*************************************************************************/
/* */
/* Sysop-Passwort im laufenden Betrieb aendern. */
/* Das neue Passwort wird in der TNN179.TNB gespeichert und beim */
/* naechsten neustart eingelesen. */
/* */
/* SYNTAX: PASS dasistmeinpasswort */
/* (Passwortstring muss genau 80Zeichen haben) */
/* */
/*************************************************************************/
void ccppasswd(void)
{
MBHEAD *mbp;
if (issyso()) /* Nur Sysop darf aendern. */
{
if (skipsp(&clicnt, &clipoi))
{
if (clicnt == 80) /* Passwort hat 80 Zeichen. */
{
strncpy(paswrd, clipoi, 80); /* Neues Passwort sichern. */
mbp = putals("Sysop Passwort:\r\r");
#ifdef SPEECH
putstr(speech_message(173),mbp);
#else
putstr("Das Sysop Passwort wurde geaendert!\r",mbp);
#endif
prompt(mbp);
seteom(mbp);
return;
}
else /* Passwort hat keine 80 Zeichen. */
{
mbp = putals("Sysop Passwort:\r\r");
#ifdef SPEECH
putstr(speech_message(174),mbp);
#else
putstr("Fehler: Das Passwort muss 80 Zeichen enthalten!\r",mbp);
#endif
prompt(mbp);
seteom(mbp);
return;
}
}
mbp = putals("Sysop Passwort:\r\r");
putprintf(mbp,"%s\r",paswrd);
prompt(mbp);
seteom(mbp);
}
else
invmsg();
}
#endif /* SYSPASSWD */
/************************************************************************/
/* Paddle-Command */
/*----------------------------------------------------------------------*/
#ifdef PADDLE /* spezielle Hardware fuer AtariST */
char *padread(WORD i);
extern WORD paddles[8];
void ccppaddle(void)
{
int i;
MBHEAD *mbp;
mbp = putals("Analog inputs:\r");
for (i = 0; i < 6; i++)
putstr(padread(i), mbp);
putchr(CR, mbp);
prompt(mbp);
seteom(mbp);
}
#endif
/************************************************************************/
/* */
/*----------------------------------------------------------------------*/
void send_ctext(void)
{
BOOLEAN ok = FALSE;
UWORD port = 0;
MBHEAD *mbp;
char file[14];
char name[MAXPATH];
UBYTE typ = g_utyp(userpo->uid);
CIRBLK *cp;
LNKBLK *lp;
int i;
PERMLINK *p;
/*
* Wenn eine Verbindung als Digipeating reinkommt, setzen wir den
* Status entsprechend und senden kein CTEXT.
*/
if (typ == L2_USER) {
lp = g_ulink(userpo->uid);
if (lp->state == L2SHTH) {
userpo->status = US_DIG;
return;
}
} else
if (typ == L4_USER) {
cp = g_ulink(userpo->uid);
if (cmpid(cp->destca, myid) == FALSE) {
userpo->status = US_DIG;
return;
}
}
#ifdef L1TCPIP
{
TCPIP *tc;
if (typ == TCP_USER)
{
tc = g_ulink(userpo->uid);
switch(tc->Interface)
{
#ifdef L1HTTPD
case KISS_HTTPD :
return;
#endif /* L1HTTPD */
#ifdef L1IPCONV
case KISS_IPCONV :
return;
#endif /* L1IPCONV */
#ifdef L1IRC
case KISS_IRC :
return;
#endif /* L1IRC */
default :
break;
}
}
}
#endif /* L1TCPIP */
/*
* Der CTEXT wird abhaengig vom Port gesendet.
*/
port = userport(userpo);
#ifndef NOCTEXT
/* Jedes Rufzeichen, das wir in der Nodes-Liste finden, begruessen
* wir ueberhaupt nicht. */
if (find_node_ssid_range(calofs(UPLINK, userpo->uid)) != -1)
return;
#else
{
PEER *pp;
int i;
int max_peers = netp->max_peers;
for (i = 0, pp = netp->peertab; i < max_peers; i++, pp++)
{
if (pp->used)
{
if (cmpid(pp->l2link->call, calofs(UPLINK, userpo->uid)))
{
if (pp->typ <= FLEXNET) /* Routing-Protokolle kein CTEXT. */
return;
}
}
}
}
#endif /* NOCTEXT */
/* Keinen Ctext fuer eingetragene Convers-Hosts */
for (i = 0; i < MAXCVSHOST; i++)
{
if ((p = permarray[i]) != NULLPERMLINK)
if (cmpcal(calofs(UPLINK, userpo->uid), p->cname))
return;
}
if (port == L2PNUM) /* HOST */
ok = TRUE;
else
if (ctextenabled(port))
ok = TRUE;
mbp = getmbp();
if (ok) {
#ifndef MAKRO_NOLOGINSTR
putstr(loginstr, mbp);
#endif
sprintf(name, "%sCTEXT.TXT", textpath);
out_ctext(name, mbp);
/* sende nun CTEXT.Port */
sprintf(name, "%sCTEXT.%u", textpath, port);
out_ctext(name, mbp);
/* Digimail Text(e), falls File "CALL.MSG" vorhanden */
callss2str(file, calofs(UPLINK, userpo->uid));
sprintf(name, "%s%s.MSG", msgpath, file);
if (xaccess(name, 0) == 0) {
putstr("\r", mbp);
seteom(mbp);
ccpread(name);
return; /* nicht nochmal Prompt */
}
} /* kein CTEXT gewuenscht .. dann nur Prompt */
putchr('\r', mbp);
prompt(mbp);
seteom(mbp);
}
#ifdef MAKRO_FILE
/* USERPO->FILE nach Makros untersuchen */
/* und neue USER->FILE erstellen. */
static int update_userpo_file(USRBLK *user)
{
MBHEAD *usermbp;
FILE *fp;
char *tmpfile;
char zeichen;
char inbuf[255],
*inread = inbuf;
if (user->read_ok == FALSE)
{
/* Buffer besorgen. */
usermbp = getmbp();
/* Wir lesen userpo->fp komplett ein. */
while(fgets(inread,255,user->fp) != NULL)
/* Jede Zeile nach Makros pruefen */
/* und gegebenfalls auswerten. */
prompt2str(usermbp,inread);
/* Buffer zurueck spulen. */
rwndmb(usermbp);
/* Markiere, das wir die funktion */
/* durchlaufen haben. */
user->read_ok = TRUE;
/* Ermitteln eines Namens fuer eine temporaere Datei. */
if ((tmpfile = tempnam(textpath, "tmp")) == NULL)
/* da ging was schief. */
return(TRUE);
/* Temp-File oeffenen. */
if ((fp = xfopen(tmpfile, "wt")) == NULL)
{
putmsg("Sri, can't open tempfile...\r");
free(tmpfile);
return(TRUE);
}
/* Keine Fehler, jetzt koennen wir */
/* die alte Temp-File Schliessen!. */
fclose(user->fp);
user->fp = NULL;
if (user->fname != NULL)
{
xremove(user->fname);
free(user->fname);
user->fname = NULL;
}
while(usermbp->mbpc != usermbp->mbgc)
/* Alle Zeichen in das Temp-File schreiben.*/
fprintf(fp,"%c",(zeichen = getchr(usermbp)));
/* Buffer leeren/entsorgen. */
dealmb(usermbp);
/* Temporaeres File schliessen */
fclose(fp);
/* Temporaeres File setzen. */
user->fname = tmpfile;
/* NEUE (mit eventuelle Makros) */
/* Temporaeres File einlesen. */
ccpread(tmpfile);
return(FALSE);
}
return(FALSE);
}
#endif
/* End of src/l7ccp.c */
Reference in New Issue View Git Blame Copy Permalink