836 lines
30 KiB
C
Executable File
836 lines
30 KiB
C
Executable File
/************************************************************************/
|
|
/* */
|
|
/* ***** ***** */
|
|
/* ***** ***** */
|
|
/* ***** ***** */
|
|
/* ***** ***** */
|
|
/* *************** *************** */
|
|
/* ***************** ***************** */
|
|
/* *************** *************** */
|
|
/* ***** ***** TheNetNode */
|
|
/* ***** ***** Portable */
|
|
/* ***** ***** Network */
|
|
/* ***** ***** Software */
|
|
/* */
|
|
/* File src/l7.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"
|
|
|
|
static BOOLEAN itoccp(MBHEAD *);
|
|
static void kill_partner(UID);
|
|
static void clrccp(void);
|
|
|
|
/************************************************************************/
|
|
/*---- ----*/
|
|
/*----------------------------------------------------------------------*/
|
|
void initl7(void)
|
|
{
|
|
UID uid;
|
|
|
|
time(&sys_time); /* Systemzeit lesen */
|
|
sys_localtime = localtime(&sys_time);
|
|
|
|
init_crctab(); /* CRC-Tabelle aufbauen */
|
|
inithd(&usccpl); /* CCP-User-Liste (L7) */
|
|
inithd(&userhd); /* USER-Liste */
|
|
inithd(&cq_user); /* CQ-Rufer */
|
|
inithd(&cq_statl); /* Connect-Meldungen bei CQ */
|
|
|
|
for (uid = 0; uid < NUMPAT; uid++)
|
|
clrptc(uid);
|
|
|
|
convers_init(); /* CONVERS */
|
|
|
|
tic1s = 0;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Informationstransfer vom L7. */
|
|
/* */
|
|
/* Frames fuer den Level 2 werden mit der gewuenschten PID gesendet. */
|
|
/* (mbp->l2fflg) */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
BOOLEAN
|
|
itousr(UID to_uid, UID fm_uid, BOOLEAN conflg, MBHEAD *mbp)
|
|
{
|
|
BOOLEAN ok = FALSE;
|
|
int bytes = mbp->mbpc - mbp->mbgc;
|
|
|
|
if (g_utyp(fm_uid) != L4_USER)
|
|
mbp->morflg = 0;
|
|
mbp->l2link = g_ulink(to_uid);
|
|
switch (g_utyp(to_uid)) /* je nach Typ */
|
|
{
|
|
case L4_USER:
|
|
ok = itocir(conflg, mbp);
|
|
break;
|
|
case L2_USER:
|
|
ok = itolnk(mbp->l2fflg, conflg, mbp);
|
|
break;
|
|
case HOST_USER:
|
|
ok = itohst(conflg, mbp);
|
|
break;
|
|
#ifdef L1TCPIP
|
|
case TCP_USER:
|
|
ok = itoTCP(conflg, mbp);
|
|
break;
|
|
#endif /* L1TCPIP */
|
|
}
|
|
if (ok)
|
|
{
|
|
ptctab[to_uid].infotx += bytes;
|
|
if (fm_uid != NO_UID)
|
|
ptctab[fm_uid].inforx += bytes;
|
|
}
|
|
return(ok);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* IP-Frames herrausfiltern, nur PID F0 (L2CPID) durchlassen. */
|
|
/* */
|
|
/************************************************************************/
|
|
static BOOLEAN itoccp(MBHEAD *mbp) {
|
|
int uid;
|
|
PTCENT *ptcp;
|
|
|
|
mbp->type = uid = g_uid(mbp->l2link, (unsigned char)mbp->type);
|
|
ptcp = ptctab + uid;
|
|
ptcp->inforx += (mbp->mbpc-mbp->mbgc); /* reine Info ohne Header */
|
|
|
|
switch (mbp->l2fflg) {
|
|
#ifdef IPROUTE
|
|
case L2CIP :
|
|
relink(ulink((LEHEAD *)mbp), (LEHEAD *)iprxfl.tail);
|
|
break;
|
|
|
|
case L2CARP :
|
|
relink(ulink((LEHEAD *)mbp), (LEHEAD *)arprxfl.tail);
|
|
break;
|
|
#endif
|
|
|
|
case L2CPID :
|
|
relink(ulink((LEHEAD *)mbp), (LEHEAD *)userhd.tail);
|
|
break;
|
|
|
|
default :
|
|
dealmb((MBHEAD *)ulink((LEHEAD *)mbp));
|
|
break;
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Informationstransfer in den L7. */
|
|
/* */
|
|
/* Wenn der Link einen Partner hat, die Daten direkt transferieren, */
|
|
/* ansonsten die Daten in den CCP. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
BOOLEAN fmlink(BOOLEAN conflg, MBHEAD *mbp)
|
|
{
|
|
PTCENT *ptcp;
|
|
UID p_uid;
|
|
UID uid;
|
|
|
|
uid = g_uid(mbp->l2link, (unsigned char)mbp->type);
|
|
ptcp = ptctab + uid;
|
|
|
|
p_uid = ptcp->p_uid; /* gibts einen Partner-Link? */
|
|
if (ptcp->local == PTC_LOCAL) { /* Locals senden nie in CCP */
|
|
if (p_uid != NO_UID) /* gibts einen Partner-Link? */
|
|
return(itousr(p_uid, uid, conflg, mbp));
|
|
/* Wenn der Link noch keinen Partner hat, haben wir l7tx() noch */
|
|
/* nicht erreicht, um den Connect einzuleiten. Wir lehnen die Info */
|
|
/* aus dem L2 solange ab, bis der Weiterconnect steht. */
|
|
return(FALSE); /* Info abgelehnt */
|
|
} else {
|
|
if (ptcp->ublk) /* noch im CCP? */
|
|
return(itoccp(mbp)); /* Info in den CCP */
|
|
if (p_uid != NO_UID) /* gibts einen Partner-Link? */
|
|
return(itousr(p_uid, uid, conflg, mbp));
|
|
return(itoccp(mbp)); /* den Rest auch in den CCP */
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
static void kill_partner(UID this_uid) {
|
|
UID uid;
|
|
PTCENT *ptcp;
|
|
|
|
for (uid = 0, ptcp = ptctab; uid < NUMPAT; uid++, ptcp++)
|
|
if (ptcp->p_uid == this_uid) {
|
|
disusr(uid);
|
|
ptcp->p_uid = NO_UID;
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Statusmeldungen an L7. Es wird auf Connect, Disconnect, Busy, */
|
|
/* Failure reagiert. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
void
|
|
l2tol7(WORD opcod, void *userlink, WORD typ)
|
|
{
|
|
UID uid = g_uid(userlink, (unsigned char)typ);
|
|
UID p_uid;
|
|
PTCENT *ptcp;
|
|
PTCENT *p_ptcp;
|
|
MBHEAD *mbp;
|
|
LNKBLK *oldlp = lnkpoi;
|
|
CIRBLK *oldcp = cirpoi;
|
|
HOSTUS *oldhp = hstusr;
|
|
USRBLK *oldup = userpo;
|
|
#ifdef L1TCPIP
|
|
TCPIP *oldtc = tcppoi;
|
|
#endif /* L1TCPIP */
|
|
|
|
/* Wenn das Sysop-Port Flag gesetzt ist, duerfen wir keinen via-Connect */
|
|
/* zulassen, weil eine Password-Pruefung nicht moeglich ist. */
|
|
|
|
if (typ == L2_USER && opcod == L2MCONNT)
|
|
{
|
|
if (lnkpoi->state == L2SHTH)
|
|
if (portpar[lnkpoi->liport].l2mode & MODE_s)
|
|
{
|
|
rejlnk(lnkpoi);
|
|
return;
|
|
}
|
|
}
|
|
|
|
ptcp = ptctab + uid; /* Zeiger auf den Patchcord */
|
|
p_uid = ptcp->p_uid; /* Partner-UID, wenn vorhanden */
|
|
switch (opcod) /* je nach Opcode */
|
|
{
|
|
case L2MCONNT:
|
|
case L7MCONNT:
|
|
if (p_uid != NO_UID) /* hat der Link einen Partner? */
|
|
{
|
|
p_ptcp = ptctab + p_uid; /* Zeiger auf Partner-Patchcord */
|
|
userpo = p_ptcp->ublk; /* Userblock des Partners im CCP */
|
|
if (userpo)
|
|
{
|
|
if (p_ptcp->local == PTC_NORMAL)
|
|
msgfrm(opcod == L2MCONNT
|
|
? DOWNLINK
|
|
: CQ_LINK, uid, conmsg);
|
|
#ifdef CONL3LOCAL
|
|
if (g_utyp(p_uid) == L4_USER) /* Partner kommt via L4? */
|
|
ackcir(g_ulink(p_uid)); /* ja? mit CACK bestaetigen */
|
|
#endif
|
|
if (g_utyp(p_uid) == L2_USER) /* Partner kommt via L2? */
|
|
acklnk(g_ulink(p_uid)); /* falls HTH, bestaetigen */
|
|
clrccp(); /* User aus dem CCP werfen */
|
|
ptcp->state = DOWNLINK; /* ist ein Downlink */
|
|
p_ptcp->ublk = NULL;
|
|
}
|
|
else
|
|
{
|
|
kill_partner(uid); /* eventuelle Partner loeschen */
|
|
disusr(uid);
|
|
lnkpoi = oldlp;
|
|
cirpoi = oldcp;
|
|
hstusr = oldhp;
|
|
userpo = oldup;
|
|
#ifdef L1TCPIP
|
|
tcppoi = oldtc;
|
|
#endif /* L1TCPIP */
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
kill_partner(uid); /* eventuelle Partner loeschen */
|
|
if ((userpo = ptcp->ublk) != NULL) /* Connect vom CCP */
|
|
{
|
|
if (userpo->status == US_CHST)
|
|
{
|
|
userpo->status = US_CCP;
|
|
send_proto("L7", "Entering convers");
|
|
mbp = getmbp();
|
|
putstr("convers\r", mbp); /* Partner in den Convers */
|
|
seteom(mbp);
|
|
mbp = getmbp();
|
|
putprintf(mbp, "/\377\200HOST %s %s %s\r", myhostname, myrev, myfeatures);
|
|
seteom(mbp);
|
|
}
|
|
/* war nur ein Linkreset */
|
|
}
|
|
else
|
|
{ /* neuer User */
|
|
if (!new_user(FALSE, uid)) /* User abgelehnt? */
|
|
{
|
|
disusr(uid);
|
|
lnkpoi = oldlp;
|
|
cirpoi = oldcp;
|
|
hstusr = oldhp;
|
|
userpo = oldup;
|
|
#ifdef L1TCPIP
|
|
tcppoi = oldtc;
|
|
#endif /* L1TCPIP */
|
|
return;
|
|
}
|
|
ptcp->state = UPLINK; /* ein User ist Uplink */
|
|
ptcp->ublk = userpo; /* Partnerblock eintragen */
|
|
#ifdef USER_PASSWORD
|
|
if (typ != L2_USER)
|
|
userpo->pwdtyp = PW_USER;
|
|
else
|
|
if (!(portpar[lnkpoi->liport].l2mode & MODE_s))
|
|
userpo->pwdtyp = PW_USER;
|
|
#endif
|
|
#ifdef USERPROFIL
|
|
if (SearchPasswdProfil())
|
|
#endif /* USERPROFIL */
|
|
send_ctext(); /* CTEXT senden */
|
|
}
|
|
}
|
|
break;
|
|
case L2MDISCF :
|
|
case L2MBUSYF :
|
|
case L2MFAILW :
|
|
if (p_uid != NO_UID) /* User hatte einen Partner */
|
|
{
|
|
p_ptcp = ptctab + p_uid;
|
|
if ((userpo = p_ptcp->ublk) == NULL) /* Partner nicht im CCP? */
|
|
{
|
|
if (p_ptcp->recflg) /* moechte aber zurueck */
|
|
{
|
|
if (new_user(TRUE, p_uid)) /* dann erneut in CCP */
|
|
{
|
|
msgfrm(DOWNLINK, NO_UID, recmsg);/* Reconnected to ... */
|
|
p_ptcp->ublk = userpo;
|
|
}
|
|
else
|
|
disusr(p_uid);
|
|
}
|
|
else
|
|
disusr(p_uid); /* sonst Partner abwerfen */
|
|
}
|
|
else
|
|
{ /* Partner ist noch im CCP */
|
|
if (p_ptcp->local == PTC_LOCAL) /* Local? */
|
|
{
|
|
if (g_utyp(p_uid) == L2_USER && opcod == L2MBUSYF)
|
|
rejlnk(g_ulink(p_uid)); /* Busy durchreichen */
|
|
disusr(p_uid);
|
|
}
|
|
else
|
|
{
|
|
if (opcod != L2MDISCF)
|
|
msgfrm(DOWNLINK, uid, (opcod == L2MBUSYF) ? dmmsg : failmsg);
|
|
p_ptcp->local = PTC_NORMAL;
|
|
userpo->status = US_CCP;
|
|
}
|
|
}
|
|
p_ptcp->p_uid = NO_UID;
|
|
}
|
|
if ((userpo = ptcp->ublk) != NULL)
|
|
clrccp();
|
|
clrptc(uid);
|
|
kill_partner(uid); /* eventuelle Partner loeschen */
|
|
}
|
|
lnkpoi = oldlp;
|
|
cirpoi = oldcp;
|
|
hstusr = oldhp;
|
|
userpo = oldup;
|
|
#ifdef L1TCPIP
|
|
tcppoi = oldtc;
|
|
#endif /* L1TCPIP */
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* Usereintrag aus der CCP-Userliste loeschen. */
|
|
/* Vorher die von diesem User verwendeten Resourcen freigeben. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
clrccp(void)
|
|
{
|
|
MBHEAD *mbp;
|
|
char file[128];
|
|
CQBUF *cqp;
|
|
|
|
if (userpo->sysflg > 1)
|
|
save_stat();
|
|
|
|
if (userpo->monitor)
|
|
{
|
|
moncmd(NULL, userpo->monitor, "N", 1); /* Monitor abschalten */
|
|
dealoc((MBHEAD *)userpo->monitor);
|
|
userpo->monitor = NULL;
|
|
}
|
|
|
|
for (cqp = (CQBUF *)cq_user.head; /* CQ-Liste durchsuchen */
|
|
cqp != (CQBUF *)&cq_user;
|
|
cqp = cqp->next)
|
|
{
|
|
if (userpo->uid == cqp->uid) /* Eintrag gefunden */
|
|
dealoc((MBHEAD *)ulink((LEHEAD *)cqp)); /* CQ-Eintrag loeschen */
|
|
break;
|
|
}
|
|
|
|
if ( userpo->status == US_WBIN /* Upload beenden */
|
|
|| userpo->status == US_RBIN
|
|
|| userpo->status == US_RTXT
|
|
)
|
|
{
|
|
fclose(loadfp);
|
|
#ifndef MC68302
|
|
xremove(loadtmp);
|
|
#else
|
|
xremove(loadname);
|
|
#endif
|
|
loadname[0] = loadtmp[0] = NUL;
|
|
}
|
|
|
|
if (userpo->fp != NULL) /* Read beenden */
|
|
{
|
|
fclose(userpo->fp);
|
|
userpo->fp = NULL;
|
|
if (userpo->fname != NULL)
|
|
{
|
|
xremove(userpo->fname);
|
|
free(userpo->fname);
|
|
userpo->fname = NULL;
|
|
}
|
|
}
|
|
|
|
if (userpo->convers != NULLCONNECTION) /* Convers beenden */
|
|
{
|
|
userpo->convers->up = NULL;
|
|
send_proto("L7", "link failure with %s", userpo->convers->name);
|
|
if (userpo->convers->type == CT_HOST)
|
|
{
|
|
#ifdef SPEECH
|
|
sprintf(file, speech_message(139), myhostname, userpo->convers->name);
|
|
#else
|
|
sprintf(file, "%s<>%s broken", myhostname, userpo->convers->name);
|
|
#endif
|
|
bye_command2(userpo->convers, file);
|
|
}
|
|
else
|
|
bye_command2(userpo->convers, "link failure");
|
|
}
|
|
userpo->convers = NULLCONNECTION;
|
|
userpo->convflag = 0;
|
|
|
|
userpo->status = US_NULL;
|
|
|
|
if ((mbp = userpo->mbhd) != NULL)
|
|
dealmb(mbp);
|
|
|
|
#ifdef PACSAT
|
|
if (userpo->pacsat != NULL)
|
|
{
|
|
if (userpo->pacsat->tempfp != NULL)
|
|
{
|
|
fclose(userpo->pacsat->tempfp);
|
|
xremove(userpo->pacsat->tempfile);
|
|
free(userpo->pacsat->tempfile);
|
|
}
|
|
dealoc((MBHEAD *)userpo->pacsat);
|
|
userpo->pacsat = NULL;
|
|
}
|
|
#endif
|
|
|
|
dealoc((MBHEAD *)ulink((LEHEAD *)userpo));
|
|
userpo = NULL;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/*---- ----*/
|
|
/*----------------------------------------------------------------------*/
|
|
void disusr(UID uid)
|
|
{
|
|
LNKBLK *cblk2;
|
|
CIRBLK *cblk4;
|
|
HOSTUS *cblk0;
|
|
#ifdef L1TCPIP
|
|
TCPIP *cblk8;
|
|
#endif /* L1TCPIP */
|
|
|
|
switch (g_utyp(uid)) {
|
|
case L4_USER:
|
|
cblk4 = cirpoi;
|
|
cirpoi = (CIRBLK *) g_ulink(uid);
|
|
discir();
|
|
cirpoi = cblk4;
|
|
break;
|
|
case L2_USER:
|
|
cblk2 = lnkpoi;
|
|
lnkpoi = (LNKBLK *) g_ulink(uid);
|
|
dsclnk();
|
|
lnkpoi = cblk2;
|
|
break;
|
|
case HOST_USER:
|
|
cblk0 = hstusr;
|
|
hstusr = (HOSTUS *) g_ulink(uid);
|
|
hstout();
|
|
hstusr = cblk0;
|
|
break;
|
|
#ifdef L1TCPIP
|
|
case TCP_USER:
|
|
cblk8 = tcppoi;
|
|
tcppoi = (TCPIP *) g_ulink(uid);
|
|
SetDiscTCP();
|
|
tcppoi = cblk8;
|
|
break;
|
|
#endif /* L1TCPIP */
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
/*---- ----*/
|
|
/* Neuen Message-Buffer besorgen und Inhalte umkopieren. Dabei je */
|
|
/* nach Paclen-Parameter entsprechend viele Packete der vorgegebenen */
|
|
/* Laenge erzeugen und mit send_msg() an L2, L4 oder Host weitergeben. */
|
|
/*----------------------------------------------------------------------*/
|
|
void seteom(MBHEAD *mbp1)
|
|
{
|
|
MBHEAD *mbp2;
|
|
#ifdef PORT_MANUELL
|
|
LNKBLK *link;
|
|
UWORD PacLen;
|
|
UID uid;
|
|
#endif /* PORT_MANUELL */
|
|
|
|
rwndmb(mbp1);
|
|
|
|
if (mbp1->mbpc == mbp1->mbgc) { /* Info im Frame? */
|
|
dealmb(mbp1); /* Nein, dann weg damit */
|
|
return;
|
|
}
|
|
|
|
mbp2 = (MBHEAD *) allocb(ALLOC_MBHEAD);
|
|
mbp2->l2link = mbp1->l2link;
|
|
mbp2->type = mbp1->type;
|
|
|
|
#ifdef PORT_MANUELL
|
|
uid = g_uid(mbp1->l2link, (unsigned char)mbp1->type);
|
|
|
|
switch (g_utyp(uid))
|
|
{
|
|
case L2_USER:
|
|
link = g_ulink(uid);
|
|
PacLen = portpar[link->liport].paclen;
|
|
break;
|
|
|
|
#ifdef L1TCPIP
|
|
case TCP_USER:
|
|
link = g_ulink(uid);
|
|
PacLen = TXLEN;
|
|
break;
|
|
#endif /* L1TCPIP */
|
|
|
|
default:
|
|
PacLen = 236;
|
|
break;
|
|
}
|
|
#endif /* PORT_MANUELL */
|
|
while (mbp1->mbpc > mbp1->mbgc) {
|
|
putchr(getchr(mbp1), mbp2);
|
|
|
|
#ifdef PORT_MANUELL
|
|
if (mbp2->mbpc == PacLen) {
|
|
#else
|
|
if (mbp2->mbpc == paclen) {
|
|
#endif /* PORT_MANUELL */
|
|
send_msg(TRUE, mbp2);
|
|
mbp2 = (MBHEAD *) allocb(ALLOC_MBHEAD);
|
|
mbp2->l2link = mbp1->l2link;
|
|
mbp2->type = mbp1->type;
|
|
}
|
|
}
|
|
|
|
if (mbp2->mbpc > mbp2->mbgc)
|
|
send_msg(TRUE, mbp2);
|
|
else
|
|
dealmb(mbp2);
|
|
dealmb(mbp1);
|
|
}
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
BOOLEAN send_msg(BOOLEAN conflg, MBHEAD *mbp)
|
|
{
|
|
static LHEAD mbhd;
|
|
|
|
rwndmb(mbp);
|
|
inithd(&mbhd);
|
|
relink((LEHEAD *)mbp, (LEHEAD *)mbhd.tail);
|
|
mbp->l2fflg = L2CPID;
|
|
|
|
return(itousr(g_uid(mbp->l2link, (unsigned char)mbp->type), NO_UID, conflg, mbp));
|
|
}
|
|
|
|
/************************************************************************/
|
|
/*--- neuen User in Liste aufnehmen ---*/
|
|
/* */
|
|
/* Parameter im Aufruf: */
|
|
/* check = TRUE: nicht aufnehmen, wenn Nachbar oder L2-Link */
|
|
/* uid: User-ID des Users */
|
|
/* */
|
|
/* Rueckgabe: FALSE, wenn User abgelehnt. */
|
|
/*----------------------------------------------------------------------*/
|
|
BOOLEAN new_user(BOOLEAN check, UID uid)
|
|
{
|
|
PERMLINK *p;
|
|
WORD i;
|
|
char call[L2IDLEN];
|
|
MBHEAD *mbp;
|
|
FILE *fp;
|
|
char name[MAXPATH];
|
|
|
|
userpo = NULL;
|
|
if (check) {
|
|
cpyid(call,calofs(UPLINK, uid));
|
|
for (i = 0; i < MAXCVSHOST; i++) {
|
|
p = permarray[i];
|
|
if (p && cmpid(call,p->call))
|
|
return(FALSE);
|
|
}
|
|
}
|
|
|
|
/*--- fuer alle uebrigen User: */
|
|
userpo = (USRBLK *) allocb(ALLOC_USRBLK2); /* Kontrollblock holen */
|
|
userpo->mbhd = NULL; /* keine Info wartend */
|
|
#ifdef PACSAT
|
|
userpo->pacsat = NULL; /* User noch nicht in der Box */
|
|
#endif
|
|
userpo->monitor = NULL; /* User will keinen Monitor */
|
|
userpo->auditlevel = 0;
|
|
userpo->sysflg = 0; /* erstmal nicht Sysop */
|
|
#ifdef USER_PASSWORD
|
|
userpo->pwdtyp = PW_NOPW; /* noch kein Password */
|
|
#endif
|
|
if (g_utyp(uid) == HOST_USER)
|
|
{
|
|
if ( !ishmod /* Terminalmodus -> Sysop */
|
|
|| (HOSTUS *)g_ulink(uid) == hstubl) /* Hostkanal 0 auch (TNBs) */
|
|
userpo->sysflg = 1;
|
|
}
|
|
userpo->uid = uid;
|
|
userpo->errcnt = 0;
|
|
|
|
userpo->status = US_CCP; /* am CCP, Befehl kommt */
|
|
userpo->convers = NULLCONNECTION;
|
|
userpo->convflag = 0; /* noch nicht in CONVERS */
|
|
userpo->talkcall[0] = '\0';
|
|
userpo->fp = NULL;
|
|
userpo->fname = NULL; /* kein Dateiname gespeichert */
|
|
#ifdef MAKRO_FILE
|
|
userpo->read_ok = FALSE;
|
|
#endif
|
|
#ifdef L1IRC
|
|
userpo->IrcMode = FALSE;
|
|
#endif /* L1IRC */
|
|
|
|
#ifdef PORT_SUSPEND
|
|
if (check == FALSE)
|
|
{
|
|
if (port_suspend_enabled(rxfprt)) { /* Wurde Flag l gesetzt ?(Port gesperrt) */
|
|
if (is_port_suspended(userpo)) { /* Ja, dann checken wir ob dieser L2 */
|
|
strcpy(name, textpath); /* auch ein eingetragener LINK ist!!! */
|
|
strcat(name, "LOCK.TXT"); /* Hat der Sysop eine LOCK.TXT erstelt. */
|
|
mbp = getmbp();
|
|
if ((fp = xfopen(name, "rt")) != NULL) { /* Wenn ja, oeffnen wir diese und geben den*/
|
|
while ((i = getc(fp)) != EOF) /* Inhalt dem L2. Anschliessend disconnect. */
|
|
putchr((BYTE)(i == '\n' ? '\r' : i), mbp);
|
|
|
|
fclose(fp);
|
|
putchr('\r', mbp);
|
|
} else
|
|
putstr("INTERLINK.\r", mbp); /* Bevor der L2 Disconnectet wird, bekommt */
|
|
seteom(mbp); /* er noch eine Meldung, WARUM. */
|
|
dealoc((MBHEAD *)userpo);
|
|
return(FALSE); /* ablehnen */
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
if (is_suspended(userpo)) {
|
|
strcpy(name, textpath);
|
|
strcat(name, "SUSPEND.TXT");
|
|
mbp = getmbp();
|
|
if ((fp = xfopen(name, "rt")) != NULL) {
|
|
while ((i = getc(fp)) != EOF)
|
|
putchr((char)(i == '\n' ? '\r' : i), mbp);
|
|
|
|
fclose(fp);
|
|
putchr('\r', mbp);
|
|
} else
|
|
#ifdef SPEECH
|
|
putstr(speech_message(140), mbp);
|
|
#else
|
|
putstr("You are suspended.\r", mbp);
|
|
#endif
|
|
seteom(mbp);
|
|
dealoc((MBHEAD *)userpo);
|
|
return(FALSE); /* ablehnen */
|
|
}
|
|
/* neuen User in Kette haengen */
|
|
relink((LEHEAD *)userpo, (LEHEAD *) usccpl.tail);
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
/************************************************************************\
|
|
* *
|
|
* "get user id" *
|
|
* *
|
|
* Die User-ID-Nummer fuer einen Link-Pointer und einen Link-Typ (Level 2,*
|
|
* Level 4, Host) feststellen. Die UID setzt sich wie folgt zusammen: *
|
|
* *
|
|
* 0 .. LINKNMBR-1 Level 2 Links *
|
|
* LINKNMBR .. LINKNMBR+NUMCIR-1 Level 4 Circuits *
|
|
* LINKNMBR+NUMCIR .. LINKNMBR+NUMCIR+MAXHST-1 Host User *
|
|
* *
|
|
\************************************************************************/
|
|
UID g_uid(void *userlink, UBYTE typ) {
|
|
|
|
switch (typ) {
|
|
case L2_USER: /* Level 2 User */
|
|
return((UWORD)(((LNKBLK *)userlink) - lnktbl));
|
|
case L4_USER: /* Level 4 User */
|
|
return(((UWORD)(((CIRBLK *)userlink) - cirtab)) + LINKNMBR);
|
|
#ifndef L1TCPIP
|
|
case HOST_USER: /* Host User */
|
|
return(((UWORD)(((HOSTUS *)userlink) - hstubl)) + LINKNMBR + NUMCIR);
|
|
#else
|
|
case HOST_USER: /* Host User */
|
|
return(((UWORD)(((HOSTUS *)userlink) - hstubl)) + LINKNMBR + NUMCIR + MAXTCPIP);
|
|
case TCP_USER: /* TCPIP User/Link */
|
|
return(((UWORD)(((TCPIP *)userlink) - tcptbl)) + LINKNMBR + NUMCIR);
|
|
#endif /* L1TCPIP */
|
|
}
|
|
return(NO_UID);
|
|
}
|
|
|
|
/************************************************************************\
|
|
* *
|
|
* "get user typ" *
|
|
* *
|
|
* Den User-Typ eines User anhand seiner UID feststellen. *
|
|
* *
|
|
* 0 .. LINKNMBR-1 Level 2 Links *
|
|
* LINKNMBR .. LINKNMBR+NUMCIR-1 Level 4 Circuits *
|
|
* LINKNMBR+NUMCIR .. LINKNMBR+NUMCIR+MAXHST-1 Host User *
|
|
* *
|
|
\************************************************************************/
|
|
UBYTE g_utyp(UID uid) {
|
|
#ifndef L1TCPIP
|
|
if (uid >= LINKNMBR+NUMCIR)
|
|
return(HOST_USER);
|
|
#else
|
|
if (uid >= LINKNMBR+NUMCIR+MAXTCPIP)
|
|
return(HOST_USER);
|
|
|
|
if (uid >= LINKNMBR+NUMCIR)
|
|
return(TCP_USER);
|
|
#endif /* L1TCPIP */
|
|
if (uid >= LINKNMBR)
|
|
return(L4_USER);
|
|
return(L2_USER);
|
|
}
|
|
|
|
/************************************************************************\
|
|
* *
|
|
* "get user link" *
|
|
* *
|
|
* Den User-Link eines User anhand seiner UID feststellen. *
|
|
* *
|
|
* 0 .. LINKNMBR-1 Level 2 Links *
|
|
* LINKNMBR .. LINKNMBR+NUMCIR-1 Level 4 Circuits *
|
|
* LINKNMBR+NUMCIR .. LINKNMBR+NUMCIR+MAXHST-1 Host User *
|
|
* *
|
|
\************************************************************************/
|
|
void *g_ulink(UID uid) {
|
|
switch (g_utyp(uid)) {
|
|
case L2_USER : return(lnktbl + uid);
|
|
case L4_USER : return(cirtab + uid - LINKNMBR);
|
|
#ifndef L1TCPIP
|
|
}
|
|
return(hstubl + uid - (LINKNMBR + NUMCIR));
|
|
#else
|
|
case TCP_USER : return(tcptbl + uid - (LINKNMBR + NUMCIR));
|
|
}
|
|
return(hstubl + uid - (LINKNMBR + NUMCIR + MAXTCPIP));
|
|
#endif /* L1TCPIP */
|
|
}
|
|
|
|
/************************************************************************\
|
|
* *
|
|
* "reset patchcord entry" *
|
|
* *
|
|
\************************************************************************/
|
|
void resptc(UID uid) {
|
|
PTCENT *ptcp = ptctab + uid;
|
|
|
|
ptcp->inforx = ptcp->lastrx =
|
|
ptcp->infotx = ptcp->lasttx =
|
|
ptcp->rxbps = ptcp->txbps = 0L;
|
|
ptcp->contime = 1L; /* Ueberlauf verhindern */
|
|
}
|
|
|
|
/************************************************************************\
|
|
* *
|
|
* "clear patchcord entry" *
|
|
* *
|
|
\************************************************************************/
|
|
void clrptc(UID uid) {
|
|
PTCENT *ptcp = ptctab+uid;
|
|
|
|
resptc(uid);
|
|
ptcp->p_uid = NO_UID;
|
|
ptcp->ublk = NULL;
|
|
ptcp->state = EMPTY;
|
|
ptcp->local = PTC_NORMAL; /* 18.10.97 (1) hier zuruecksetzen */
|
|
ptcp->recflg = FALSE;
|
|
}
|
|
|
|
/* End of src/l7.c */
|